// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module c

import v.ast
import v.util

enum SpawnGoMode {
	spawn_
	go_
}

fn (mut g Gen) spawn_and_go_expr(node ast.SpawnExpr, mode SpawnGoMode) {
	if node.call_expr.should_be_skipped {
		return
	}
	is_spawn := mode == .spawn_
	is_go := mode == .go_
	if is_spawn {
		g.writeln('/*spawn (thread) */')
	} else {
		g.writeln('/*go (coroutine) */')
	}
	line := g.go_before_last_stmt()
	mut handle := ''
	tmp := g.new_tmp_var()
	mut expr := node.call_expr
	mut name := expr.name
	mut use_tmp_fn_var := false
	tmp_fn := g.new_tmp_var()

	if expr.is_fn_var {
		// generate a name different for same var fn name declared in another scope
		name = '${name}_${node.pos.pos}'
	}

	if expr.concrete_types.len > 0 {
		name = g.generic_fn_name(expr.concrete_types, name)
	} else if expr.is_fn_var && expr.fn_var_type.has_flag(.generic) {
		fn_var_type := g.unwrap_generic(expr.fn_var_type)
		name = g.styp(fn_var_type)
	}

	if expr.is_method {
		receiver_sym := g.table.sym(g.unwrap_generic(expr.receiver_type))
		name = receiver_sym.cname + '_' + name
		if receiver_sym.is_builtin() && !name.starts_with('_') {
			name = 'builtin__${name}'
		}
	} else if mut expr.left is ast.AnonFn {
		if expr.left.inherited_vars.len > 0 {
			fn_var := g.fn_var_signature(ast.void_type, expr.left.decl.return_type,
				expr.left.decl.params.map(it.typ), tmp_fn)
			g.write('\t${fn_var} = ')
			g.gen_anon_fn(mut expr.left)
			g.writeln(';')
			use_tmp_fn_var = true
			name = g.anon_fn_cname(expr.left.decl.return_type, expr.left.decl.params.map(it.typ))
		} else {
			g.gen_anon_fn_decl(mut expr.left)
			name = expr.left.decl.name
		}
	} else if expr.left is ast.IndexExpr {
		if expr.is_fn_var {
			fn_sym := g.table.sym(expr.fn_var_type)
			func := (fn_sym.info as ast.FnType).func
			fn_var := g.fn_var_signature(ast.void_type, func.return_type, func.params.map(it.typ),
				tmp_fn)
			g.write('\t${fn_var} = ')
			g.expr(expr.left)
			g.writeln(';')
			name = fn_sym.cname
			use_tmp_fn_var = true
		}
	}
	// When inside a generic function, differentiate wrapper struct names
	// per concrete type instantiation so each gets its own typed struct/wrapper.
	if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
		generic_suffix := g.generic_fn_name(g.cur_concrete_types, '')
		if generic_suffix != '' && !name.ends_with(generic_suffix) {
			name = g.generic_fn_name(g.cur_concrete_types, name)
		}
	}
	name = util.no_dots(name)
	g.empty_line = true
	g.writeln('// start go')
	wrapper_struct_name := 'thread_arg_' + name
	wrapper_fn_name := name + '_thread_wrapper'
	arg_tmp_var := 'arg_' + tmp
	if is_spawn {
		if g.pref.prealloc {
			g.writeln('${wrapper_struct_name} *${arg_tmp_var} = (${wrapper_struct_name} *) malloc(sizeof(thread_arg_${name}));')
			g.writeln('if (${arg_tmp_var} == NULL) builtin___v_panic(_S("thread argument allocation failed"));')
		} else {
			g.writeln('${wrapper_struct_name} *${arg_tmp_var} = (${wrapper_struct_name} *) builtin___v_malloc(sizeof(thread_arg_${name}));')
		}
	} else if is_go {
		g.writeln('${wrapper_struct_name} ${arg_tmp_var};')
	}
	dot := if is_spawn { '->' } else { '.' }
	fn_name := if use_tmp_fn_var {
		tmp_fn
	} else if expr.is_fn_var {
		expr.name
	} else {
		if func := g.table.find_fn(expr.name) {
			if func.mod == 'builtin' && !name.starts_with('builtin__') && func.language != .c {
				'builtin__${name}'
			} else {
				name
			}
		} else {
			name
		}
	}
	if !(expr.is_method && (g.table.sym(expr.receiver_type).kind == .interface
		|| (g.table.sym(expr.receiver_type).kind == .struct && expr.is_field))) {
		g.writeln('${arg_tmp_var}${dot}fn = ${fn_name};')
	}
	if expr.is_method {
		g.write('${arg_tmp_var}${dot}arg0 = ')
		if mut expr.left is ast.Ident && expr.left.obj.typ.is_ptr()
			&& !node.call_expr.receiver_type.is_ptr() {
			g.write('*'.repeat(expr.left.obj.typ.nr_muls()))
		}
		g.expr(expr.left)
		g.writeln(';')
	}
	for i, arg in expr.args {
		g.write('${arg_tmp_var}${dot}arg${i + 1} = ')
		g.expr(arg.expr)
		g.writeln(';')
	}
	if is_spawn && g.pref.prealloc {
		g.writeln('${arg_tmp_var}->prealloc_scope = builtin__prealloc_scope_retain_current();')
	}
	call_ret_type := if expr.is_fn_var && g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0
		&& g.cur_fn.generic_names.len > 0 {
		// In generic contexts, node.call_expr.return_type may be stale from
		// a previous instantiation. Look up the original fn param from the table
		// and resolve through convert_generic_type.
		mut resolved_ret := g.unwrap_generic(node.call_expr.return_type)
		cur_fn_name := g.cur_fn.fkey()
		orig_fn := g.table.find_fn(cur_fn_name) or { ast.Fn{} }
		for param in orig_fn.params {
			if param.name == expr.name {
				if param.typ.has_flag(.generic) || g.type_has_unresolved_generic_parts(param.typ) {
					mut muttable := unsafe { &ast.Table(g.table) }
					if resolved_type := muttable.convert_generic_type(param.typ,
						orig_fn.generic_names, g.cur_concrete_types)
					{
						fn_sym := g.table.sym(resolved_type)
						if fn_sym.info is ast.FnType {
							resolved_ret = fn_sym.info.func.return_type
						}
					}
				}
				break
			}
		}
		resolved_ret
	} else {
		g.unwrap_generic(node.call_expr.return_type)
	}
	s_ret_typ := g.styp(g.unwrap_generic(call_ret_type))
	if g.pref.os == .windows && call_ret_type != ast.void_type {
		if g.pref.prealloc {
			g.writeln('${arg_tmp_var}->ret_ptr = (void *) malloc(sizeof(${s_ret_typ}));')
			g.writeln('if (${arg_tmp_var}->ret_ptr == NULL) builtin___v_panic(_S("thread return allocation failed"));')
		} else {
			g.writeln('${arg_tmp_var}->ret_ptr = (void *) builtin___v_malloc(sizeof(${s_ret_typ}));')
		}
	}
	gohandle_name := g.gen_gohandle_name(call_ret_type)
	if is_spawn {
		if g.pref.os == .windows {
			simple_handle := if node.is_expr && call_ret_type != ast.void_type {
				'thread_handle_${tmp}'
			} else {
				'thread_${tmp}'
			}
			stack_size := g.get_cur_thread_stack_size(expr.name)
			g.writeln('HANDLE ${simple_handle} = CreateThread(0, ${stack_size}, (LPTHREAD_START_ROUTINE)${wrapper_fn_name}, ${arg_tmp_var}, 0, 0); // fn: ${expr.name}')
			g.writeln('if (!${simple_handle}) builtin__panic_lasterr(builtin__tos3("`go ${name}()`: "));')
			if node.is_expr && call_ret_type != ast.void_type {
				g.writeln('${gohandle_name} thread_${tmp} = {')
				g.writeln('\t.ret_ptr = ${arg_tmp_var}->ret_ptr,')
				g.writeln2('\t.handle = thread_handle_${tmp}', '};')
			}
			if !node.is_expr {
				g.writeln('CloseHandle(thread_${tmp});')
			}
		} else {
			g.writeln('pthread_t thread_${tmp};')
			mut sthread_attributes := 'NULL'
			if g.pref.os != .vinix {
				g.writeln('pthread_attr_t thread_${tmp}_attributes;')
				g.writeln('pthread_attr_init(&thread_${tmp}_attributes);')
				size := g.get_cur_thread_stack_size(expr.name)
				g.writeln('pthread_attr_setstacksize(&thread_${tmp}_attributes, ${size}); // fn: ${expr.name}')
				sthread_attributes = '&thread_${tmp}_attributes'
			}
			g.writeln('int ${tmp}_thr_res = pthread_create(&thread_${tmp}, ${sthread_attributes}, (void*)${wrapper_fn_name}, ${arg_tmp_var});')
			g.writeln('if (${tmp}_thr_res) builtin__panic_error_number(builtin__tos3("`go ${name}()`: "), ${tmp}_thr_res);')
			if !node.is_expr {
				g.writeln('pthread_detach(thread_${tmp});')
			}
		}
	} else if is_go {
		if util.nr_jobs > 1 {
			g.writeln('photon_thread_create_and_migrate_to_work_pool((void*)${wrapper_fn_name}, &${arg_tmp_var});')
		} else {
			g.writeln('photon_thread_create((void*)${wrapper_fn_name}, &${arg_tmp_var}, 8 * 1024);')
		}
	}
	g.writeln('// end go')
	if node.is_expr {
		handle = 'thread_${tmp}'
		g.create_waiter_handler(call_ret_type, s_ret_typ, gohandle_name)
	}
	// Register the wrapper type and function
	mut should_register := false
	lock g.threaded_fns {
		if name !in g.threaded_fns {
			g.threaded_fns << name
			should_register = true
		}
	}
	if should_register {
		g.type_definitions.writeln('\ntypedef struct ${wrapper_struct_name} {')
		mut fn_var := ''
		mut wrapper_return_type := call_ret_type
		mut resolved_fn_params := []ast.Param{}
		if node.call_expr.is_fn_var {
			mut fn_var_type := node.call_expr.fn_var_type
			// In generic contexts, fn_var_type may be stale from the last checker pass.
			// Look up the original fn parameter from the table to get the generic fn type,
			// then resolve it through convert_generic_type.
			if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0
				&& g.cur_fn.generic_names.len > 0 {
				cur_fn_name := g.cur_fn.fkey()
				orig_fn := g.table.find_fn(cur_fn_name) or { ast.Fn{} }
				for param in orig_fn.params {
					if param.name == expr.name {
						if param.typ.has_flag(.generic)
							|| g.type_has_unresolved_generic_parts(param.typ) {
							mut muttable := unsafe { &ast.Table(g.table) }
							if resolved := muttable.convert_generic_type(param.typ,
								orig_fn.generic_names, g.cur_concrete_types)
							{
								fn_var_type = resolved
							}
						}
						break
					}
				}
			}
			fn_sym := g.table.sym(fn_var_type)
			info := fn_sym.info as ast.FnType
			resolved_fn_params = info.func.params.clone()
			wrapper_return_type = info.func.return_type
			fn_var = g.fn_var_signature(ast.void_type, wrapper_return_type,
				info.func.params.map(it.typ), 'fn')
		} else if node.call_expr.left is ast.AnonFn {
			f := node.call_expr.left.decl
			wrapper_return_type = f.return_type
			fn_var =
				g.fn_var_signature(ast.void_type, wrapper_return_type, f.params.map(it.typ), 'fn')
		} else {
			if node.call_expr.is_method {
				rec_sym := g.table.sym(g.unwrap_generic(node.call_expr.receiver_type))
				if f := rec_sym.find_method_with_generic_parent(node.call_expr.name) {
					mut muttable := unsafe { &ast.Table(g.table) }
					return_type := muttable.convert_generic_type(f.return_type, f.generic_names,
						node.call_expr.concrete_types) or { f.return_type }
					wrapper_return_type = return_type
					mut arg_types := f.params.map(it.typ)
					arg_types = arg_types.map(muttable.convert_generic_type(it, f.generic_names,
						node.call_expr.concrete_types) or { it })
					fn_var = g.fn_var_signature(ast.void_type, return_type, arg_types, 'fn')
				}
			} else {
				if f := g.table.find_fn(node.call_expr.name) {
					concrete_types := node.call_expr.concrete_types.map(g.unwrap_generic(it))
					return_type := g.table.convert_generic_type(f.return_type, f.generic_names,
						concrete_types) or { f.return_type }
					wrapper_return_type = return_type
					mut arg_types := f.params.map(it.typ)
					arg_types = arg_types.map(g.table.convert_generic_type(it, f.generic_names,
						concrete_types) or { it })
					for i, typ in arg_types {
						mut typ_sym := g.table.sym(typ)
						for {
							if mut typ_sym.info is ast.Array {
								typ_sym = g.table.sym(typ_sym.info.elem_type)
							} else {
								if typ_sym.info is ast.FnType {
									arg_types[i] = expr.args[i].typ
								}
								break
							}
						}
					}
					fn_var = g.fn_var_signature(ast.void_type, return_type, arg_types, 'fn')
				}
			}
		}
		wrapper_return_type = g.unwrap_generic(wrapper_return_type)
		wrapper_s_ret_typ := g.styp(wrapper_return_type)
		if fn_var != '' {
			g.type_definitions.writeln('\t${fn_var};')
		}
		if expr.is_method {
			styp := g.styp(expr.receiver_type)
			g.type_definitions.writeln('\t${styp} arg0;')
		}
		need_return_ptr := g.pref.os == .windows && wrapper_return_type != ast.void_type
		for i, arg in expr.args {
			mut arg_typ := arg.typ
			// For fn var and AnonFn calls in generic contexts, use the declared
			// parameter types instead of argument expression types, since the
			// AST arg types may be stale from a previous generic instantiation.
			if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
				if expr.left is ast.AnonFn {
					anon := expr.left as ast.AnonFn
					f := anon.decl
					if i < f.params.len {
						arg_typ = g.unwrap_generic(f.params[i].typ)
					}
				} else if expr.is_fn_var && resolved_fn_params.len > 0 {
					if i < resolved_fn_params.len {
						arg_typ = resolved_fn_params[i].typ
					}
				} else {
					resolved_arg_typ := g.unwrap_generic(arg_typ)
					if resolved_arg_typ != 0 {
						arg_typ = resolved_arg_typ
					}
				}
			}
			arg_sym := g.table.sym(arg_typ)
			if arg_sym.info is ast.FnType {
				sig := g.fn_var_signature(arg_typ, arg_sym.info.func.return_type,
					arg_sym.info.func.params.map(it.typ), 'arg${i + 1}')
				g.type_definitions.writeln('\t' + sig + ';')
			} else {
				styp := g.styp(arg_typ)
				g.type_definitions.writeln('\t${styp} arg${i + 1};')
			}
		}
		if is_spawn && g.pref.prealloc {
			g.type_definitions.writeln('\tvoid* prealloc_scope;')
		}
		if need_return_ptr {
			g.type_definitions.writeln('\tvoid* ret_ptr;')
		}
		g.type_definitions.writeln('} ${wrapper_struct_name};')
		thread_ret_type := if g.pref.os == .windows { 'u32' } else { 'void*' }
		g.waiter_fn_definitions.writeln('${g.static_non_parallel}${thread_ret_type} ${wrapper_fn_name}(${wrapper_struct_name} *arg);')
		g.gowrappers.writeln('${thread_ret_type} ${wrapper_fn_name}(${wrapper_struct_name} *arg) {')
		if is_spawn && g.pref.prealloc && wrapper_return_type == ast.void_type {
			g.gowrappers.writeln('\tvoid* thread_prealloc_scope = builtin__prealloc_scope_begin();')
		}
		if wrapper_return_type != ast.void_type {
			if g.pref.os == .windows {
				g.gowrappers.write_string('\t*((${wrapper_s_ret_typ}*)(arg->ret_ptr)) = ')
			} else {
				if g.pref.prealloc {
					g.gowrappers.writeln('\t${wrapper_s_ret_typ}* ret_ptr = (${wrapper_s_ret_typ}*) malloc(sizeof(${wrapper_s_ret_typ}));')
					g.gowrappers.writeln('\tif (ret_ptr == NULL) builtin___v_panic(_S("thread return allocation failed"));')
				} else {
					g.gowrappers.writeln('\t${wrapper_s_ret_typ}* ret_ptr = (${wrapper_s_ret_typ}*) builtin___v_malloc(sizeof(${wrapper_s_ret_typ}));')
				}
				$if tinyc && arm64 {
					g.gowrappers.write_string('\t${wrapper_s_ret_typ} tcc_bug_tmp_var = ')
				} $else {
					g.gowrappers.write_string('\t*ret_ptr = ')
				}
			}
		} else {
			g.gowrappers.write_string('\t')
		}
		if expr.is_method {
			unwrapped_rec_type := g.unwrap_generic(expr.receiver_type)
			typ_sym := g.table.sym(unwrapped_rec_type)
			if typ_sym.kind == .interface
				&& (typ_sym.info as ast.Interface).defines_method(expr.name) {
				rec_cc_type := g.cc_type(unwrapped_rec_type, false)
				receiver_type_name := util.no_dots(rec_cc_type)
				g.gowrappers.write_string2('${c_name(receiver_type_name)}_name_table[', 'arg->arg0')
				dot_or_ptr := g.dot_or_ptr(unwrapped_rec_type)
				mname := c_name(expr.name)
				g.gowrappers.write_string2('${dot_or_ptr}_typ]._method_${mname}(', 'arg->arg0')
				g.gowrappers.write_string('${dot_or_ptr}_object')
			} else if typ_sym.kind == .struct && expr.is_field {
				g.gowrappers.write_string('arg->arg0')
				idot := if expr.left_type.is_ptr() { '->' } else { '.' }
				mname := c_name(expr.name)
				g.gowrappers.write_string('${idot}${mname}(')
			} else {
				g.gowrappers.write_string2('arg->fn(', 'arg->arg0')
			}
			if expr.args.len > 0 && (typ_sym.kind != .struct || !expr.is_field) {
				g.gowrappers.write_string(', ')
			}
		} else {
			g.gowrappers.write_string('arg->fn(')
		}
		if expr.args.len > 0 {
			mut has_cast := false
			for i in 0 .. expr.args.len {
				if g.table.sym(expr.expected_arg_types[i]).kind == .interface
					&& g.table.sym(expr.args[i].typ).kind != .interface {
					has_cast = true
					break
				}
			}
			if has_cast {
				pos := g.out.len
				g.call_args(expr)
				mut call_args_str := g.out.after(pos).trim_space()
				g.go_back(call_args_str.len)
				mut rep_group := []string{cap: 2 * expr.args.len}
				for i in 0 .. expr.args.len {
					rep_group << g.expr_string(expr.args[i].expr)
					rep_group << 'arg->arg${i + 1}'
				}
				if call_args_str.starts_with('I_') {
					g.gowrappers.write_string(call_args_str.all_before('('))
					g.gowrappers.write_string('(')
					g.gowrappers.write_string(call_args_str.all_after('(').replace_each(rep_group))
				} else {
					call_args_str = call_args_str.replace_each(rep_group)
					g.gowrappers.write_string(call_args_str)
				}
			} else if expr.name in ['print', 'println', 'eprint', 'eprintln', 'panic']
				&& expr.args[0].typ != ast.string_type {
				pos := g.out.len
				g.gen_expr_to_string(expr.args[0].expr, expr.args[0].typ)
				mut call_args_str := g.out.after(pos)
				g.out.go_back(call_args_str.len)
				mut rep_group := []string{cap: 2 * expr.args.len}
				for i in 0 .. expr.args.len {
					rep_group << g.expr_string(expr.args[i].expr)
					rep_group << 'arg->arg${i + 1}'
				}
				call_args_str = call_args_str.replace_each(rep_group)
				g.gowrappers.write_string(call_args_str)
			} else {
				for i in 0 .. expr.args.len {
					expected_nr_muls := expr.expected_arg_types[i].nr_muls()
					arg_nr_muls := expr.args[i].typ.nr_muls()
					if arg_nr_muls > expected_nr_muls {
						g.gowrappers.write_string('*'.repeat(arg_nr_muls - expected_nr_muls))
					} else if arg_nr_muls < expected_nr_muls {
						g.gowrappers.write_string('&'.repeat(expected_nr_muls - arg_nr_muls))
					}
					g.gowrappers.write_string('arg->arg${i + 1}')
					if i != expr.args.len - 1 {
						g.gowrappers.write_string(', ')
					}
				}
			}
		}
		g.gowrappers.writeln(');')
		$if tinyc && arm64 {
			if g.pref.os != .windows && wrapper_return_type != ast.void_type {
				g.gowrappers.writeln('\t*ret_ptr = tcc_bug_tmp_var;')
			}
		}
		if is_spawn && g.pref.prealloc {
			if wrapper_return_type == ast.void_type {
				g.gowrappers.writeln('\tbuiltin__prealloc_scope_end(thread_prealloc_scope);')
			}
			g.gowrappers.writeln('\tbuiltin__prealloc_scope_release(arg->prealloc_scope);')
		}
		if is_spawn {
			if g.pref.prealloc {
				g.gowrappers.writeln('\tfree(arg);')
			} else {
				g.gowrappers.writeln('\tbuiltin___v_free(arg);')
			}
		}
		if g.pref.os != .windows && wrapper_return_type != ast.void_type {
			g.gowrappers.writeln('\treturn ret_ptr;')
		} else {
			g.gowrappers.writeln('\treturn 0;')
		}
		g.gowrappers.writeln('}')
	}
	if node.is_expr {
		g.empty_line = false
		g.write2(line, handle)
	}
}

// get current thread size, if fn hasn't defined return default
@[inline]
fn (mut g Gen) get_cur_thread_stack_size(name string) string {
	ast_fn := g.table.fns[name] or { return '${g.pref.thread_stack_size}' }
	attrs := ast_fn.attrs
	if isnil(attrs) {
		return '${g.pref.thread_stack_size}'
	}
	for attr in attrs {
		if attr.name == 'spawn_stack' {
			return attr.arg
		}
	}
	return '${g.pref.thread_stack_size}'
}

fn (mut g Gen) gen_gohandle_name(typ ast.Type) string {
	mut gohandle_name := ''
	if typ == ast.void_type {
		if typ.has_flag(.option) {
			gohandle_name = '__v_thread_Option_void'
		} else if typ.has_flag(.result) {
			gohandle_name = '__v_thread_Result_void'
		} else {
			gohandle_name = '__v_thread'
		}
	} else {
		ret_styp := g.styp(g.unwrap_generic(typ)).replace('*', '_ptr')
		gohandle_name = '__v_thread_${ret_styp}'
	}
	return gohandle_name
}

fn (mut g Gen) create_waiter_handler(call_ret_type ast.Type, s_ret_typ string, gohandle_name string) {
	// create wait handler for this return type if none exists
	waiter_fn_name := gohandle_name + '_wait'
	mut should_register := false
	lock g.waiter_fns {
		if waiter_fn_name !in g.waiter_fns {
			g.waiter_fns << waiter_fn_name
			should_register = true
		}
	}
	if !should_register {
		return
	}
	g.waiter_fn_definitions.writeln('${s_ret_typ} ${waiter_fn_name}(${gohandle_name} thread);')
	g.gowrappers.writeln('\n${s_ret_typ} ${waiter_fn_name}(${gohandle_name} thread) {')
	mut c_ret_ptr_ptr := 'NULL'
	if call_ret_type != ast.void_type {
		g.gowrappers.writeln('\t${s_ret_typ}* ret_ptr;')
		c_ret_ptr_ptr = '&ret_ptr'
	}
	if g.pref.os == .windows {
		if call_ret_type == ast.void_type {
			g.gowrappers.writeln('\tu32 stat = WaitForSingleObject(thread, INFINITE);')
		} else {
			g.gowrappers.writeln('\tu32 stat = WaitForSingleObject(thread.handle, INFINITE);')
			g.gowrappers.writeln('\tret_ptr = thread.ret_ptr;')
		}
	} else {
		g.gowrappers.writeln('\tif ((unsigned long int)thread == 0) { builtin___v_panic(_S("unable to join thread")); }')
		g.gowrappers.writeln('\tint stat = pthread_join(thread, (void **)${c_ret_ptr_ptr});')
	}
	g.gowrappers.writeln('\tif (stat != 0) { builtin___v_panic(_S("unable to join thread")); }')
	if g.pref.os == .windows {
		if call_ret_type == ast.void_type {
			g.gowrappers.writeln('\tCloseHandle(thread);')
		} else {
			g.gowrappers.writeln('\tCloseHandle(thread.handle);')
		}
	}
	if call_ret_type != ast.void_type {
		g.gowrappers.writeln('\t${s_ret_typ} ret = *ret_ptr;')
		if g.pref.prealloc {
			g.gowrappers.writeln('\tfree(ret_ptr);')
		} else {
			g.gowrappers.writeln('\tbuiltin___v_free(ret_ptr);')
		}
		g.gowrappers.writeln('\treturn ret;')
	}
	g.gowrappers.writeln('}')
}