1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/compiler/fn.v

1088 lines
30 KiB
V
Raw Normal View History

2019-06-23 05:21:30 +03:00
// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
2019-06-22 21:20:28 +03:00
module main
import(
os
strings
)
2019-06-22 21:20:28 +03:00
const (
MaxLocalVars = 50
)
struct Fn {
// addr int
mut:
2019-07-14 12:01:32 +03:00
name string
mod string
2019-09-23 20:34:08 +03:00
//local_vars []Var
//var_idx int
2019-06-22 21:20:28 +03:00
args []Var
is_interface bool
// called_fns []string
// idx int
scope_level int
typ string // return type
is_c bool
receiver_typ string
2019-07-15 23:09:34 +03:00
is_public bool
2019-06-22 21:20:28 +03:00
is_method bool
returns_error bool
is_decl bool // type myfn fn(int, int)
defer_text []string
2019-08-17 22:19:37 +03:00
//gen_types []string
2019-06-22 21:20:28 +03:00
}
2019-09-23 20:34:08 +03:00
fn (p &Parser) find_var(name string) ?Var {
for i in 0 .. p.var_idx {
if p.local_vars[i].name == name {
return p.local_vars[i]
}
}
return none
}
fn (p &Parser) find_var_check_new_var(name string) ?Var {
2019-09-23 20:34:08 +03:00
for i in 0 .. p.var_idx {
if p.local_vars[i].name == name {
return p.local_vars[i]
}
}
// A hack to allow `newvar := Foo{ field: newvar }`
// Declare the variable so that it can be used in the initialization
if name == 'main__' + p.var_decl_name {
return Var{
name : p.var_decl_name
typ : 'voidptr'
is_mut : true
}
}
return none
}
fn (p mut Parser) open_scope() {
p.cur_fn.defer_text << ''
p.cur_fn.scope_level++
2019-06-22 21:20:28 +03:00
}
fn (p mut Parser) mark_var_used(v Var) {
2019-09-24 06:18:06 +03:00
if v.idx == -1 || v.idx >= p.local_vars.len {
2019-09-23 22:47:09 +03:00
return
}
p.local_vars[v.idx].is_used = true
}
fn (p mut Parser) mark_var_returned(v Var) {
2019-09-23 22:47:09 +03:00
if v.idx == -1 || v.idx >= p.local_vars.len {
return
}
p.local_vars[v.idx].is_returned = true
}
fn (p mut Parser) mark_var_changed(v Var) {
2019-09-23 22:47:09 +03:00
if v.idx == -1 || v.idx >= p.local_vars.len {
return
}
p.local_vars[v.idx].is_changed = true
2019-06-22 21:20:28 +03:00
}
fn (p mut Parser) mark_arg_moved(v Var) {
for i, arg in p.cur_fn.args {
if arg.name == v.name {
//println('setting f $p.cur_fn.name arg $arg.name to is_mut')
p.cur_fn.args[i].is_moved = true
break
}
}
p.table.fns[p.cur_fn.name] = p.cur_fn
}
2019-09-23 20:34:08 +03:00
fn (p mut Parser) known_var(name string) bool {
_ = p.find_var(name) or {
return false
}
return true
2019-06-22 21:20:28 +03:00
}
2019-09-23 20:34:08 +03:00
fn (p mut Parser) register_var(v Var) {
2019-09-23 22:47:09 +03:00
mut new_var := {v | idx: p.var_idx, scope_level: p.cur_fn.scope_level}
2019-09-23 20:34:08 +03:00
if v.line_nr == 0 {
spos := p.scanner.get_scanner_pos()
new_var.scanner_pos = spos
new_var.line_nr = spos.line_nr
}
2019-06-22 21:20:28 +03:00
// Expand the array
2019-09-23 20:34:08 +03:00
if p.var_idx >= p.local_vars.len {
p.local_vars << new_var
2019-06-22 21:20:28 +03:00
}
else {
2019-09-23 20:34:08 +03:00
p.local_vars[p.var_idx] = new_var
2019-06-22 21:20:28 +03:00
}
2019-09-23 20:34:08 +03:00
p.var_idx++
2019-06-22 21:20:28 +03:00
}
2019-09-23 20:34:08 +03:00
fn (p mut Parser) clear_vars() {
// shared a := [1, 2, 3]
p.var_idx = 0
2019-09-26 05:28:43 +03:00
if p.local_vars.len > 0 {
if p.pref.autofree {
p.local_vars.free()
}
p.local_vars = []Var
}
}
2019-06-22 21:20:28 +03:00
// vlib header file?
fn (p mut Parser) is_sig() bool {
2019-09-10 17:36:14 +03:00
return (p.pref.build_mode == .default_mode || p.pref.build_mode == .build_module) &&
2019-07-16 18:42:04 +03:00
(p.file_path.contains(ModPath))
2019-06-22 21:20:28 +03:00
}
// Function signatures are added to the top of the .c file in the first run.
fn (p mut Parser) fn_decl() {
2019-09-23 20:34:08 +03:00
p.clear_vars() // clear local vars every time a new fn is started
2019-06-22 21:20:28 +03:00
p.fgen('fn ')
2019-08-17 22:19:37 +03:00
//defer { p.fgenln('\n') }
2019-09-23 20:34:08 +03:00
mut f := Fn {
mod: p.mod
is_public: p.tok == .key_pub
}
2019-08-17 22:19:37 +03:00
is_live := p.attr == 'live' && !p.pref.is_so && p.pref.is_live
if p.attr == 'live' && p.first_pass() && !p.pref.is_live && !p.pref.is_so {
println('INFO: run `v -live program.v` if you want to use [live] functions')
}
2019-09-23 20:34:08 +03:00
if f.is_public {
2019-06-22 21:20:28 +03:00
p.next()
}
p.returns = false
2019-07-08 04:42:36 +03:00
//p.gen('/* returns $p.returns */')
2019-06-22 21:20:28 +03:00
p.next()
// Method receiver
mut receiver_typ := ''
if p.tok == .lpar {
2019-06-22 21:20:28 +03:00
f.is_method = true
p.check(.lpar)
2019-06-22 21:20:28 +03:00
receiver_name := p.check_name()
is_mut := p.tok == .key_mut
is_amp := p.tok == .amp
2019-06-22 21:20:28 +03:00
if is_mut || is_amp {
2019-08-17 22:19:37 +03:00
p.check_space(p.tok)
2019-06-22 21:20:28 +03:00
}
receiver_typ = p.get_type()
T := p.table.find_type(receiver_typ)
if T.cat == .interface_ {
2019-06-22 21:20:28 +03:00
p.error('invalid receiver type `$receiver_typ` (`$receiver_typ` is an interface)')
}
// Don't allow modifying types from a different module
2019-09-26 05:28:43 +03:00
if !p.first_pass() && !p.builtin_mod && T.mod != p.mod &&
p.id != 'vgen' { // allow .str() on builtin arrays
println('T.mod=$T.mod')
2019-07-10 15:18:21 +03:00
println('p.mod=$p.mod')
2019-06-22 21:20:28 +03:00
p.error('cannot define new methods on non-local type `$receiver_typ`')
}
// `(f *Foo)` instead of `(f mut Foo)` is a common mistake
//if !p.builtin_mod && receiver_typ.contains('*') {
if receiver_typ.contains('*') {
2019-06-22 21:20:28 +03:00
t := receiver_typ.replace('*', '')
p.error('use `($receiver_name mut $t)` instead of `($receiver_name *$t)`')
}
f.receiver_typ = receiver_typ
if is_mut || is_amp {
receiver_typ += '*'
}
p.check(.rpar)
2019-08-17 22:19:37 +03:00
p.fspace()
2019-06-22 21:20:28 +03:00
receiver := Var {
name: receiver_name
is_arg: true
typ: receiver_typ
is_mut: is_mut
ref: is_amp
ptr: is_mut
line_nr: p.scanner.line_nr
scanner_pos: p.scanner.get_scanner_pos()
2019-06-22 21:20:28 +03:00
}
f.args << receiver
2019-09-23 20:34:08 +03:00
p.register_var(receiver)
2019-06-22 21:20:28 +03:00
}
if p.tok == .plus || p.tok == .minus || p.tok == .mul {
2019-06-22 21:20:28 +03:00
f.name = p.tok.str()
p.next()
}
else {
f.name = p.check_name()
}
// C function header def? (fn C.NSMakeRect(int,int,int,int))
2019-08-17 22:19:37 +03:00
is_c := f.name == 'C' && p.tok == .dot
2019-06-22 21:20:28 +03:00
// Just fn signature? only builtin.v + default build mode
// is_sig := p.builtin_mod && p.pref.build_mode == default_mode
// is_sig := p.pref.build_mode == default_mode && (p.builtin_mod || p.file.contains(LANG_TMP))
2019-06-22 21:20:28 +03:00
is_sig := p.is_sig()
2019-08-31 16:38:13 +03:00
// println('\n\nfn_decl() name=$f.name receiver_typ=$receiver_typ')
2019-06-22 21:20:28 +03:00
if is_c {
p.check(.dot)
2019-06-22 21:20:28 +03:00
f.name = p.check_name()
f.is_c = true
}
else if !p.pref.translated && !p.file_path.contains('view.v') {
2019-06-22 21:20:28 +03:00
if contains_capital(f.name) {
p.error('function names cannot contain uppercase letters, use snake_case instead')
}
if f.name.contains('__') {
2019-07-10 11:08:37 +03:00
p.error('function names cannot contain double underscores, use single underscores instead')
2019-06-22 21:20:28 +03:00
}
}
// simple_name := f.name
// println('!SIMP.le=$simple_name')
2019-06-22 21:20:28 +03:00
// user.register() => User_register()
has_receiver := receiver_typ.len > 0
if receiver_typ != '' {
// f.name = '${receiver_typ}_${f.name}'
}
// full mod function name
2019-06-22 21:20:28 +03:00
// os.exit ==> os__exit()
if !is_c && !p.builtin_mod && p.mod != 'main' && receiver_typ.len == 0 {
f.name = p.prepend_mod(f.name)
2019-06-22 21:20:28 +03:00
}
2019-09-18 15:06:34 +03:00
if p.first_pass() && receiver_typ.len == 0 {
for {
existing_fn := p.table.find_fn(f.name) or { break }
2019-06-22 21:20:28 +03:00
// This existing function could be defined as C decl before (no body), then we don't need to throw an erro
if !existing_fn.is_decl {
p.error('redefinition of `$f.name`')
}
2019-09-18 15:06:34 +03:00
break
}
2019-06-22 21:20:28 +03:00
}
// Generic?
mut is_generic := false
if p.tok == .lt {
2019-07-29 19:21:36 +03:00
is_generic = true
2019-06-22 21:20:28 +03:00
p.next()
gen_type := p.check_name()
if gen_type != 'T' {
p.error('only `T` is allowed as a generic type for now')
}
p.check(.gt)
2019-08-17 22:19:37 +03:00
if p.first_pass() {
p.table.register_generic_fn(f.name)
} else {
//gen_types := p.table.fn_gen_types(f.name)
//println(gen_types)
}
2019-06-22 21:20:28 +03:00
}
// Args (...)
p.fn_args(mut f)
// Returns an error?
if p.tok == .not {
2019-06-22 21:20:28 +03:00
p.next()
f.returns_error = true
}
// Returns a type?
mut typ := 'void'
if p.tok == .name || p.tok == .mul || p.tok == .amp || p.tok == .lsbr ||
p.tok == .question || p.tok == .lpar {
2019-06-22 21:20:28 +03:00
p.fgen(' ')
// TODO In
// if p.tok in [ .name, .mul, .amp, .lsbr ] {
2019-06-22 21:20:28 +03:00
typ = p.get_type()
}
// multiple returns
if typ.starts_with('_V_MulRet_') && p.first_pass() && !p.table.known_type(typ) {
p.table.register_type2(Type{
cat: TypeCategory.struct_,
name: typ,
mod: p.mod
})
for i, t in typ.replace('_V_MulRet_', '').replace('_PTR_', '*').split('_V_') {
p.table.add_field(typ, 'var_$i', t, false, '', .public)
}
p.cgen.typedefs << 'typedef struct $typ $typ;'
}
2019-06-22 21:20:28 +03:00
// Translated C code can have empty functions (just definitions)
2019-08-17 22:19:37 +03:00
is_fn_header := !is_c && !is_sig && (p.pref.translated || p.pref.is_test) && p.tok != .lcbr
2019-06-22 21:20:28 +03:00
if is_fn_header {
f.is_decl = true
}
// { required only in normal function declarations
if !is_c && !is_sig && !is_fn_header {
p.fgen(' ')
p.check(.lcbr)
2019-06-22 21:20:28 +03:00
}
2019-07-29 19:21:36 +03:00
// Register ?option type
2019-06-22 21:20:28 +03:00
if typ.starts_with('Option_') {
p.cgen.typedefs << 'typedef Option $typ;'
}
// Register function
f.typ = typ
mut str_args := f.str_args(p.table)
// Special case for main() args
if f.name == 'main' && !has_receiver {
if str_args != '' || typ != 'void' {
2019-06-22 21:20:28 +03:00
p.error('fn main must have no arguments and no return values')
}
typ = 'int'
str_args = 'int argc, char** argv'
}
2019-07-29 19:21:36 +03:00
dll_export_linkage := if p.os == .msvc && p.attr == 'live' && p.pref.is_so {
'__declspec(dllexport) '
2019-08-18 04:44:04 +03:00
} else if p.attr == 'inline' {
'static inline '
2019-07-29 19:21:36 +03:00
} else {
2019-08-17 22:19:37 +03:00
''
}
if !p.is_vweb {
2019-09-07 13:44:41 +03:00
p.set_current_fn( f )
2019-08-17 22:19:37 +03:00
}
// Generate `User_register()` instead of `register()`
2019-06-22 21:20:28 +03:00
// Internally it's still stored as "register" in type User
2019-09-14 23:48:30 +03:00
mut fn_name_cgen := p.table.fn_gen_name(f)
2019-06-22 21:20:28 +03:00
// Start generation of the function body
skip_main_in_test := f.name == 'main' && p.pref.is_test
2019-06-22 21:20:28 +03:00
if !is_c && !is_live && !is_sig && !is_fn_header && !skip_main_in_test {
if p.pref.obfuscate {
2019-07-07 22:46:21 +03:00
p.genln('; // $f.name')
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
// Generate this function's body for all generic types
if is_generic {
gen_types := p.table.fn_gen_types(f.name)
2019-07-29 19:21:36 +03:00
// Remember current scanner position, go back here for each type
2019-08-17 22:19:37 +03:00
// TODO remove this once tokens are cached in `new_parser()`
cur_pos := p.scanner.pos
cur_tok := p.tok
cur_lit := p.lit
2019-07-29 19:21:36 +03:00
for gen_type in gen_types {
2019-08-17 22:19:37 +03:00
p.genln('$dll_export_linkage$typ ${fn_name_cgen}_$gen_type($str_args) {')
p.genln('// T start $p.pass ${p.strtok()}')
p.cur_gen_type = gen_type // TODO support more than T
2019-07-29 19:21:36 +03:00
p.statements()
2019-08-17 22:19:37 +03:00
p.scanner.pos = cur_pos
p.tok = cur_tok
p.lit = cur_lit
}
}
else {
2019-09-14 23:48:30 +03:00
p.gen_fn_decl(f, typ, str_args)
2019-08-17 22:19:37 +03:00
}
2019-06-22 21:20:28 +03:00
}
if is_fn_header {
p.genln('$typ $fn_name_cgen($str_args);')
p.fgenln('')
}
if is_c {
p.fgenln('\n')
}
// Register the method
if receiver_typ != '' {
2019-07-15 23:44:26 +03:00
mut receiver_t := p.table.find_type(receiver_typ)
2019-06-22 21:20:28 +03:00
// No such type yet? It could be defined later. Create a new type.
// struct declaration later will modify it instead of creating a new one.
2019-07-29 19:21:36 +03:00
if p.first_pass() && receiver_t.name == '' {
2019-08-31 16:38:13 +03:00
//println('fn decl ! registering placeholder $receiver_typ')
receiver_t = Type {
2019-06-22 21:20:28 +03:00
name: receiver_typ.replace('*', '')
mod: p.mod
2019-06-22 21:20:28 +03:00
is_placeholder: true
2019-08-31 16:38:13 +03:00
}
p.table.register_type2(receiver_t)
2019-06-22 21:20:28 +03:00
}
2019-09-18 15:37:34 +03:00
p.add_method(receiver_t.name, f)
2019-06-22 21:20:28 +03:00
}
else {
// println('register_fn typ=$typ isg=$is_generic')
p.table.register_fn(f)
}
2019-07-29 19:21:36 +03:00
if is_sig || p.first_pass() || is_live || is_fn_header || skip_main_in_test {
2019-08-17 22:19:37 +03:00
// First pass? Skip the body for now
// Look for generic calls.
2019-06-22 21:20:28 +03:00
if !is_sig && !is_fn_header {
mut opened_scopes := 0
mut closed_scopes := 0
2019-06-22 21:20:28 +03:00
for {
if p.tok == .lcbr {
opened_scopes++
}
if p.tok == .rcbr {
closed_scopes++
}
2019-08-17 22:19:37 +03:00
// find `foo<Bar>()` in function bodies and register generic types
// TODO
if p.tok.is_decl() {
2019-06-22 21:20:28 +03:00
break
}
2019-07-29 19:21:36 +03:00
// fn body ended, and a new fn attribute declaration like [live] is starting?
if closed_scopes > opened_scopes && p.prev_tok == .rcbr {
if p.tok == .lsbr {
break
}
2019-08-17 22:19:37 +03:00
}
p.next()
2019-06-22 21:20:28 +03:00
}
}
// Live code reloading? Load all fns from .so
2019-07-29 19:21:36 +03:00
if is_live && p.first_pass() && p.mod == 'main' {
2019-08-17 22:19:37 +03:00
//println('ADDING SO FN $fn_name_cgen')
2019-06-22 21:20:28 +03:00
p.cgen.so_fns << fn_name_cgen
fn_name_cgen = '(* $fn_name_cgen )'
}
2019-08-17 22:19:37 +03:00
// Function definition that goes to the top of the C file.
mut fn_decl := '$dll_export_linkage$typ $fn_name_cgen($str_args)'
if p.pref.obfuscate {
2019-07-29 19:21:36 +03:00
fn_decl += '; // $f.name'
2019-06-22 21:20:28 +03:00
}
// Add function definition to the top
2019-07-29 19:21:36 +03:00
if !is_c && f.name != 'main' && p.first_pass() {
2019-06-22 21:20:28 +03:00
// TODO hack to make Volt compile without -embed_vlib
if f.name == 'darwin__nsstring' && p.pref.build_mode == .default_mode {
2019-06-22 21:20:28 +03:00
return
}
p.cgen.fns << fn_decl + ';'
}
return
}
if p.attr == 'live' && p.pref.is_so {
//p.genln('// live_function body start')
p.genln('pthread_mutex_lock(&live_fn_mutex);')
}
2019-06-22 21:20:28 +03:00
if f.name == 'main' || f.name == 'WinMain' {
p.genln('init_consts();')
if 'os' in p.table.imports {
2019-06-22 21:20:28 +03:00
if f.name == 'main' {
2019-09-16 21:26:05 +03:00
p.genln('os__args = os__init_os_args(argc, (byteptr*)argv);')
2019-06-22 21:20:28 +03:00
}
else if f.name == 'WinMain' {
2019-06-26 00:43:04 +03:00
p.genln('os__args = os__parse_windows_cmd_line(pCmdLine);')
2019-06-22 21:20:28 +03:00
}
}
// We are in live code reload mode, call the .so loader in bg
if p.pref.is_live {
file_base := os.filename(p.file_path).replace('.v', '')
if p.os != .windows && p.os != .msvc {
so_name := file_base + '.so'
2019-08-17 22:19:37 +03:00
p.genln('
load_so("$so_name");
2019-06-22 21:20:28 +03:00
pthread_t _thread_so;
pthread_create(&_thread_so , NULL, &reload_so, NULL); ')
} else {
2019-08-17 22:19:37 +03:00
so_name := file_base + if p.os == .msvc {'.dll'} else {'.so'}
p.genln('
live_fn_mutex = CreateMutexA(0, 0, 0);
load_so("$so_name");
unsigned long _thread_so;
_thread_so = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)&reload_so, 0, 0, 0);
')
}
2019-06-22 21:20:28 +03:00
}
if p.pref.is_test && !p.scanner.file_path.contains('/volt') {
2019-06-22 21:20:28 +03:00
p.error('tests cannot have function `main`')
}
}
// println('is_c=$is_c name=$f.name')
if is_c || is_sig || is_fn_header {
// println('IS SIG .key_returnING tok=${p.strtok()}')
2019-06-22 21:20:28 +03:00
return
}
2019-07-29 19:21:36 +03:00
// Profiling mode? Start counting at the beginning of the function (save current time).
if p.pref.is_prof && f.name != 'main' && f.name != 'time__ticks' {
2019-06-22 21:20:28 +03:00
p.genln('double _PROF_START = time__ticks();//$f.name')
2019-09-14 23:48:30 +03:00
cgen_name := p.table.fn_gen_name(f)
if f.defer_text.len > f.scope_level {
2019-09-14 23:48:30 +03:00
f.defer_text[f.scope_level] = ' ${cgen_name}_time += time__ticks() - _PROF_START;'
}
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
if is_generic {
// Don't need to generate body for the actual generic definition
p.cgen.nogen = true
}
2019-07-24 03:35:25 +03:00
p.statements_no_rcbr()
2019-08-17 22:19:37 +03:00
p.cgen.nogen = false
2019-06-22 21:20:28 +03:00
// Print counting result after all statements in main
if p.pref.is_prof && f.name == 'main' {
2019-06-22 21:20:28 +03:00
p.genln(p.print_prof_counters())
}
// Counting or not, always need to add defer before the end
2019-08-17 22:19:37 +03:00
if !p.is_vweb {
if f.defer_text.len > f.scope_level {
2019-08-12 17:21:56 +03:00
p.genln(f.defer_text[f.scope_level])
}
2019-08-17 22:19:37 +03:00
}
2019-06-22 21:20:28 +03:00
if typ != 'void' && !p.returns && f.name != 'main' && f.name != 'WinMain' {
p.error('$f.name must return "$typ"')
}
if p.attr == 'live' && p.pref.is_so {
//p.genln('// live_function body end')
p.genln('pthread_mutex_unlock(&live_fn_mutex);')
}
2019-06-22 21:20:28 +03:00
// {} closed correctly? scope_level should be 0
if p.mod == 'main' {
2019-06-22 21:20:28 +03:00
// println(p.cur_fn.scope_level)
}
if p.cur_fn.scope_level > 2 {
// p.error('unclosed {')
}
// Make sure all vars in this function are used (only in main for now)
if p.mod != 'main' {
2019-08-17 22:19:37 +03:00
if !is_generic {
2019-07-29 19:21:36 +03:00
p.genln('}')
2019-08-17 22:19:37 +03:00
}
2019-06-22 21:20:28 +03:00
return
}
p.check_unused_variables()
2019-09-07 13:44:41 +03:00
p.set_current_fn( EmptyFn )
p.returns = false
2019-08-17 22:19:37 +03:00
if !is_generic {
2019-07-29 19:21:36 +03:00
p.genln('}')
2019-08-17 22:19:37 +03:00
}
}
fn (p mut Parser) check_unused_variables() {
2019-09-23 20:34:08 +03:00
for var in p.local_vars {
2019-06-22 21:20:28 +03:00
if var.name == '' {
break
}
2019-07-06 16:33:15 +03:00
if !var.is_used && !p.pref.is_repl && !var.is_arg && !p.pref.translated && var.name != '_' {
p.production_error('`$var.name` declared and not used', var.scanner_pos )
2019-06-22 21:20:28 +03:00
}
if !var.is_changed && var.is_mut && !p.pref.is_repl &&
!p.pref.translated && var.name != '_' {
p.error_with_position( '`$var.name` is declared as mutable, but it was never changed', var.scanner_pos )
}
2019-06-22 21:20:28 +03:00
}
}
// user.register() => "User_register(user)"
// method_ph - where to insert "user_register("
2019-06-22 21:20:28 +03:00
// receiver_var - "user" (needed for pthreads)
// receiver_type - "User"
fn (p mut Parser) async_fn_call(f Fn, method_ph int, receiver_var, receiver_type string) {
// println('\nfn_call $f.name is_method=$f.is_method receiver_type=$f.receiver_type')
// p.print_tok()
mut thread_name := ''
// Normal function => just its name, method => TYPE_FN.name
2019-06-22 21:20:28 +03:00
mut fn_name := f.name
if f.is_method {
2019-08-17 22:19:37 +03:00
fn_name = receiver_type.replace('*', '') + '_' + f.name
//fn_name = '${receiver_type}_${f.name}'
2019-06-22 21:20:28 +03:00
}
// Generate tmp struct with args
arg_struct_name := 'thread_arg_$fn_name'
tmp_struct := p.get_tmp()
p.genln('$arg_struct_name * $tmp_struct = malloc(sizeof($arg_struct_name));')
mut arg_struct := 'typedef struct $arg_struct_name { '
p.next()
p.check(.lpar)
2019-06-22 21:20:28 +03:00
// str_args contains the args for the wrapper function:
// wrapper(arg_struct * arg) { fn("arg->a, arg->b"); }
mut str_args := ''
mut did_gen_something := false
2019-06-22 21:20:28 +03:00
for i, arg in f.args {
arg_struct += '$arg.typ $arg.name ;'// Add another field (arg) to the tmp struct definition
2019-09-14 23:48:30 +03:00
str_args += 'arg $dot_ptr $arg.name'
2019-06-22 21:20:28 +03:00
if i == 0 && f.is_method {
2019-09-14 23:48:30 +03:00
p.genln('$tmp_struct $dot_ptr $arg.name = $receiver_var ;')
2019-06-22 21:20:28 +03:00
if i < f.args.len - 1 {
str_args += ','
}
did_gen_something = true
2019-06-22 21:20:28 +03:00
continue
}
// Set the struct values (args)
2019-09-14 23:48:30 +03:00
p.genln('$tmp_struct $dot_ptr $arg.name = ')
2019-06-22 21:20:28 +03:00
p.expression()
p.genln(';')
if i < f.args.len - 1 {
p.check(.comma)
2019-06-22 21:20:28 +03:00
str_args += ','
}
did_gen_something = true
}
if !did_gen_something {
// Msvc doesnt like empty struct
arg_struct += 'EMPTY_STRUCT_DECLARATION;'
2019-06-22 21:20:28 +03:00
}
2019-06-22 21:20:28 +03:00
arg_struct += '} $arg_struct_name ;'
// Also register the wrapper, so we can use the original function without modifying it
2019-09-14 23:48:30 +03:00
fn_name = p.table.fn_gen_name(f)
2019-06-22 21:20:28 +03:00
wrapper_name := '${fn_name}_thread_wrapper'
wrapper_text := 'void* $wrapper_name($arg_struct_name * arg) {$fn_name( /*f*/$str_args ); }'
p.cgen.register_thread_fn(wrapper_name, wrapper_text, arg_struct)
// Create thread object
tmp_nr := p.get_tmp_counter()
thread_name = '_thread$tmp_nr'
if p.os != .windows && p.os != .msvc {
2019-06-22 21:20:28 +03:00
p.genln('pthread_t $thread_name;')
}
tmp2 := p.get_tmp()
mut parg := 'NULL'
if f.args.len > 0 {
parg = ' $tmp_struct'
}
// Call the wrapper
if p.os == .windows || p.os == .msvc {
2019-06-22 21:20:28 +03:00
p.genln(' CreateThread(0,0, $wrapper_name, $parg, 0,0);')
}
else {
p.genln('int $tmp2 = pthread_create(& $thread_name, NULL, $wrapper_name, $parg);')
}
p.check(.rpar)
2019-06-22 21:20:28 +03:00
}
2019-09-14 23:48:30 +03:00
// p.tok == fn_name
2019-06-22 21:20:28 +03:00
fn (p mut Parser) fn_call(f Fn, method_ph int, receiver_var, receiver_type string) {
2019-08-17 22:19:37 +03:00
if !f.is_public && !f.is_c && !p.pref.is_test && !f.is_interface && f.mod != p.mod {
if f.name == 'contains' {
println('use `value in numbers` instead of `numbers.contains(value)`')
}
2019-06-26 14:17:45 +03:00
p.error('function `$f.name` is private')
}
2019-06-22 21:20:28 +03:00
p.calling_c = f.is_c
if f.is_c && !p.builtin_mod {
2019-07-21 13:22:41 +03:00
if f.name == 'free' {
2019-08-17 22:19:37 +03:00
p.error('use `free()` instead of `C.free()`')
2019-07-21 13:22:41 +03:00
} else if f.name == 'malloc' {
2019-08-17 22:19:37 +03:00
p.error('use `malloc()` instead of `C.malloc()`')
}
}
2019-09-14 23:48:30 +03:00
mut cgen_name := p.table.fn_gen_name(f)
2019-07-29 19:21:36 +03:00
p.next()
2019-08-17 22:19:37 +03:00
mut gen_type := ''
2019-07-29 19:21:36 +03:00
if p.tok == .lt {
p.check(.lt)
2019-08-17 22:19:37 +03:00
gen_type = p.check_name()
// run<T> => run_App
2019-08-13 14:50:19 +03:00
if gen_type == 'T' && p.cur_gen_type != '' {
2019-08-17 22:19:37 +03:00
gen_type = p.cur_gen_type
}
// `foo<Bar>()`
// If we are in the first pass, we need to add `Bar` type to the generic function `foo`,
// so that generic `foo`s body can be generated for each type in the second pass.
2019-07-29 19:23:56 +03:00
if p.first_pass() {
2019-08-17 22:19:37 +03:00
println('registering $gen_type in $f.name fname=$f.name')
p.table.register_generic_fn_type(f.name, gen_type)
// Function bodies are skipped in the first passed, we only need to register the generic type here.
return
}
cgen_name += '_' + gen_type
2019-07-29 19:21:36 +03:00
p.check(.gt)
2019-08-17 22:19:37 +03:00
}
// if p.pref.is_prof {
2019-06-22 21:20:28 +03:00
// p.cur_fn.called_fns << cgen_name
// }
// Normal function call
if !f.is_method {
p.gen(cgen_name)
p.gen('(')
// p.fgen(f.name)
}
// If we have a method placeholder,
// we need to preappend "method(receiver, ...)"
else {
receiver := f.args.first()
2019-09-14 23:48:30 +03:00
//println('r=$receiver.typ RT=$receiver_type')
2019-06-22 21:20:28 +03:00
if receiver.is_mut && !p.expr_var.is_mut {
2019-09-14 23:48:30 +03:00
//println('$method_call recv=$receiver.name recv_mut=$receiver.is_mut')
p.error('`$p.expr_var.name` is immutable, declare it with `mut`')
2019-08-17 22:19:37 +03:00
}
if !p.expr_var.is_changed {
p.mark_var_changed(p.expr_var)
2019-08-17 22:19:37 +03:00
}
2019-09-14 23:48:30 +03:00
p.gen_method_call(receiver_type, f.typ, cgen_name, receiver, method_ph)
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
// foo<Bar>()
2019-07-29 19:21:36 +03:00
p.fn_call_args(mut f)
2019-06-22 21:20:28 +03:00
p.gen(')')
p.calling_c = false
// println('end of fn call typ=$f.typ')
}
// for declaration
// return an updated Fn object with args[] field set
fn (p mut Parser) fn_args(f mut Fn) {
p.check(.lpar)
2019-08-17 22:19:37 +03:00
defer { p.check(.rpar) }
2019-06-22 21:20:28 +03:00
if f.is_interface {
int_arg := Var {
typ: f.receiver_typ
}
f.args << int_arg
}
2019-08-17 22:19:37 +03:00
// `(int, string, int)`
2019-06-22 21:20:28 +03:00
// Just register fn arg types
types_only := p.tok == .mul || p.tok == .amp || (p.peek() == .comma && p.table.known_type(p.lit)) || p.peek() == .rpar// (int, string)
2019-06-22 21:20:28 +03:00
if types_only {
for p.tok != .rpar {
2019-06-22 21:20:28 +03:00
typ := p.get_type()
2019-09-23 13:42:20 +03:00
p.check_and_register_used_imported_type(typ)
2019-06-22 21:20:28 +03:00
v := Var {
typ: typ
is_arg: true
// is_mut: is_mut
line_nr: p.scanner.line_nr
scanner_pos: p.scanner.get_scanner_pos()
2019-06-22 21:20:28 +03:00
}
// f.register_var(v)
f.args << v
if p.tok == .comma {
2019-06-22 21:20:28 +03:00
p.next()
}
}
}
2019-08-06 19:13:04 +03:00
// `(a int, b, c string)` syntax
for p.tok != .rpar {
2019-09-23 20:34:08 +03:00
mut names := [ p.check_name() ]
2019-08-06 19:13:04 +03:00
// `a,b,c int` syntax
for p.tok == .comma {
p.check(.comma)
2019-06-22 21:20:28 +03:00
p.fspace()
names << p.check_name()
}
p.fspace()
is_mut := p.tok == .key_mut
2019-06-22 21:20:28 +03:00
if is_mut {
p.next()
}
2019-07-24 16:24:32 +03:00
mut typ := p.get_type()
2019-09-23 13:42:20 +03:00
p.check_and_register_used_imported_type(typ)
2019-07-24 16:24:32 +03:00
if is_mut && is_primitive_type(typ) {
2019-08-17 22:19:37 +03:00
p.error('mutable arguments are only allowed for arrays, maps, and structs.' +
'\nreturn values instead: `foo(n mut int)` => `foo(n int) int`')
}
2019-06-22 21:20:28 +03:00
for name in names {
2019-08-17 22:19:37 +03:00
if !p.first_pass() && !p.table.known_type(typ) {
2019-07-24 16:24:32 +03:00
p.error('fn_args: unknown type $typ')
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
if is_mut {
2019-07-24 16:24:32 +03:00
typ += '*'
2019-06-22 21:20:28 +03:00
}
v := Var{
2019-06-22 21:20:28 +03:00
name: name
2019-08-17 22:19:37 +03:00
typ: typ
2019-06-22 21:20:28 +03:00
is_arg: true
is_mut: is_mut
ptr: is_mut
line_nr: p.scanner.line_nr
scanner_pos: p.scanner.get_scanner_pos()
2019-06-22 21:20:28 +03:00
}
2019-09-23 20:34:08 +03:00
p.register_var(v)
2019-06-22 21:20:28 +03:00
f.args << v
}
if p.tok == .comma {
2019-06-22 21:20:28 +03:00
p.next()
}
if p.tok == .dotdot {
f.args << Var{
2019-06-22 21:20:28 +03:00
name: '..'
}
p.next()
}
}
}
2019-08-17 22:19:37 +03:00
// foo *(1, 2, 3, mut bar)*
2019-09-01 22:51:16 +03:00
fn (p mut Parser) fn_call_args(f mut Fn) &Fn {
2019-06-22 21:20:28 +03:00
// println('fn_call_args() name=$f.name args.len=$f.args.len')
// C func. # of args is not known
p.check(.lpar)
2019-06-22 21:20:28 +03:00
if f.is_c {
for p.tok != .rpar {
2019-09-16 18:28:20 +03:00
//C.func(var1, var2.method())
//If the parameter calls a function or method that is not C,
//the value of p.calling_c is changed
p.calling_c = true
ph := p.cgen.add_placeholder()
typ := p.bool_expression()
// Cast V byteptr to C char* (byte is unsigned in V, that led to C warnings)
if typ == 'byte*' {
p.cgen.set_placeholder(ph, '(char*)')
}
if p.tok == .comma {
2019-06-22 21:20:28 +03:00
p.gen(', ')
p.check(.comma)
2019-06-22 21:20:28 +03:00
}
}
p.check(.rpar)
2019-06-22 21:20:28 +03:00
return f
}
2019-07-30 16:08:14 +03:00
// add debug information to panic when -debug arg is passed
2019-09-14 23:48:30 +03:00
if p.v.pref.is_debug && f.name == 'panic' && !p.is_js {
2019-07-30 16:08:14 +03:00
mod_name := p.mod.replace('_dot_', '.')
fn_name := p.cur_fn.name.replace('${p.mod}__', '')
file_path := p.file_path.replace('\\', '\\\\') // escape \
p.cgen.resetln(p.cgen.cur_line.replace(
'v_panic (',
'_panic_debug ($p.scanner.line_nr, tos2((byte *)"$file_path"), tos2((byte *)"$mod_name"), tos2((byte *)"$fn_name"), '
2019-07-30 16:08:14 +03:00
))
}
2019-06-22 21:20:28 +03:00
for i, arg in f.args {
// Receiver is the first arg
// Skip the receiver, because it was already generated in the expression
2019-06-22 21:20:28 +03:00
if i == 0 && f.is_method {
2019-09-14 23:48:30 +03:00
if f.args.len > 1 && !p.is_js {
2019-06-22 21:20:28 +03:00
p.gen(',')
}
continue
}
// Reached the final vararg? Quit
if i == f.args.len - 1 && arg.name == '..' {
break
}
ph := p.cgen.add_placeholder()
2019-08-17 22:19:37 +03:00
// `)` here means that not enough args were provided
if p.tok == .rpar {
2019-06-22 21:20:28 +03:00
str_args := f.str_args(p.table)// TODO this is C args
p.error('not enough arguments in call to `$f.name ($str_args)`')
}
2019-08-17 22:19:37 +03:00
// If `arg` is mutable, the caller needs to provide `mut`:
2019-07-10 15:26:37 +03:00
// `mut numbers := [1,2,3]; reverse(mut numbers);`
2019-06-22 21:20:28 +03:00
if arg.is_mut {
2019-08-11 00:02:48 +03:00
if p.tok != .key_mut && p.tok == .name {
2019-08-17 22:19:37 +03:00
mut dots_example := 'mut $p.lit'
2019-08-11 00:02:48 +03:00
if i > 0 {
2019-08-17 22:19:37 +03:00
dots_example = '.., ' + dots_example
}
2019-08-11 00:02:48 +03:00
if i < f.args.len - 1 {
2019-08-17 22:19:37 +03:00
dots_example = dots_example + ',..'
}
2019-08-11 00:02:48 +03:00
p.error('`$arg.name` is a mutable argument, you need to provide `mut`: `$f.name($dots_example)`')
2019-06-22 21:20:28 +03:00
}
if p.peek() != .name {
2019-08-08 11:08:39 +03:00
p.error('`$arg.name` is a mutable argument, you need to provide a variable to modify: `$f.name(... mut a...)`')
2019-06-22 21:20:28 +03:00
}
p.check(.key_mut)
2019-08-17 22:19:37 +03:00
var_name := p.lit
2019-09-23 20:34:08 +03:00
v := p.find_var(var_name) or {
2019-08-08 11:08:39 +03:00
p.error('`$arg.name` is a mutable argument, you need to provide a variable to modify: `$f.name(... mut a...)`')
exit(1)
2019-08-17 22:19:37 +03:00
}
if !v.is_changed {
p.mark_var_changed(v)
2019-08-17 22:19:37 +03:00
}
}
p.expected_type = arg.typ
clone := p.pref.autofree && arg.typ == 'string' && arg.is_moved && p.mod != 'builtin'
if clone {
p.gen('/*YY f=$f.name arg=$arg.name is_moved=$arg.is_moved*/string_clone(')
}
mut typ := p.bool_expression()
if clone {
p.gen(')')
}
// Optimize `println`: replace it with `printf` to avoid extra allocations and
2019-09-14 23:48:30 +03:00
// function calls.
// `println(777)` => `printf("%d\n", 777)`
2019-08-17 22:19:37 +03:00
// (If we don't check for void, then V will compile `println(func())`)
if i == 0 && (f.name == 'println' || f.name == 'print') && typ == 'ustring' {
if typ == 'ustring' {
p.gen('.s')
}
typ = 'string'
}
if i == 0 && (f.name == 'println' || f.name == 'print') && typ != 'string' && typ != 'ustring' && typ != 'void' {
2019-06-23 10:59:34 +03:00
T := p.table.find_type(typ)
$if !windows {
2019-09-14 23:48:30 +03:00
$if !js {
fmt := p.typ_to_fmt(typ, 0)
if fmt != '' {
p.cgen.resetln(p.cgen.cur_line.replace(f.name + ' (', '/*opt*/printf ("' + fmt + '\\n", '))
2019-08-17 22:19:37 +03:00
continue
}
}
2019-09-14 23:48:30 +03:00
}
if typ.ends_with('*') {
p.cgen.set_placeholder(ph, 'ptr_str(')
p.gen(')')
2019-08-17 22:19:37 +03:00
continue
2019-06-23 10:59:34 +03:00
}
// Make sure this type has a `str()` method
2019-09-14 23:48:30 +03:00
$if !js {
if !T.has_method('str') {
2019-08-17 22:19:37 +03:00
// Arrays have automatic `str()` methods
2019-08-11 00:02:48 +03:00
if T.name.starts_with('array_') {
2019-08-31 16:38:13 +03:00
p.gen_array_str(T)
2019-08-11 00:02:48 +03:00
p.cgen.set_placeholder(ph, '${typ}_str(')
p.gen(')')
2019-08-17 22:19:37 +03:00
continue
2019-09-26 05:28:43 +03:00
} else if T.cat == .struct_ {
p.gen_struct_str(T)
p.cgen.set_placeholder(ph, '${typ}_str(')
p.gen(')')
continue
}
2019-07-10 15:26:37 +03:00
error_msg := ('`$typ` needs to have method `str() string` to be printable')
2019-08-17 22:19:37 +03:00
p.error(error_msg)
2019-06-22 21:20:28 +03:00
}
p.cgen.set_placeholder(ph, '${typ}_str(')
2019-06-23 10:59:34 +03:00
p.gen(')')
2019-09-14 23:48:30 +03:00
}
2019-06-22 21:20:28 +03:00
continue
}
got := typ
expected := arg.typ
// println('fn arg got="$got" exp="$expected"')
if !p.check_types_no_throw(got, expected) {
mut j := i
if f.is_method {
j--
}
mut nr := '${i+1}th'
if j == 0 {
nr = 'first'
} else if j == 1 {
nr = 'second'
} else if j == 2 {
nr = 'third'
}
p.error('cannot use type `$typ` as type `$arg.typ` in $nr ' +
'argument to `$f.name()`')
2019-06-22 21:20:28 +03:00
}
is_interface := p.table.is_interface(arg.typ)
// Add `&` or `*` before an argument?
2019-06-22 21:20:28 +03:00
if !is_interface {
// Dereference
if got.ends_with('*') && !expected.ends_with('*') {
p.cgen.set_placeholder(ph, '*')
2019-06-22 21:20:28 +03:00
}
// Reference
// TODO ptr hacks. DOOM hacks, fix please.
if !got.ends_with('*') && expected.ends_with('*') && got != 'voidptr' {
2019-08-07 13:57:07 +03:00
// Special case for mutable arrays. We can't `&` function results,
2019-08-17 22:19:37 +03:00
// have to use `(array[]){ expr }` hack.
if expected.starts_with('array_') && expected.ends_with('*') {
p.cgen.set_placeholder(ph, '& /*111*/ (array[]){')
p.gen('}[0] ')
2019-08-17 22:19:37 +03:00
}
2019-06-22 21:20:28 +03:00
// println('\ne:"$expected" got:"$got"')
else if ! (expected == 'void*' && got == 'int') &&
2019-06-22 21:20:28 +03:00
! (expected == 'byte*' && got.contains(']byte')) &&
2019-08-08 11:46:01 +03:00
! (expected == 'byte*' && got == 'string') &&
2019-08-17 22:19:37 +03:00
//! (expected == 'void*' && got == 'array_int') {
! (expected == 'byte*' && got == 'byteptr') {
p.cgen.set_placeholder(ph, '& /*112 EXP:"$expected" GOT:"$got" */')
2019-06-22 21:20:28 +03:00
}
}
}
// interface?
if is_interface {
if !got.contains('*') {
p.cgen.set_placeholder(ph, '&')
2019-06-22 21:20:28 +03:00
}
// Pass all interface methods
interface_type := p.table.find_type(arg.typ)
for method in interface_type.methods {
p.gen(', ${typ}_${method.name} ')
}
}
// Check for commas
if i < f.args.len - 1 {
// Handle 0 args passed to varargs
is_vararg := i == f.args.len - 2 && f.args[i + 1].name == '..'
if p.tok != .comma && !is_vararg {
2019-06-22 21:20:28 +03:00
p.error('wrong number of arguments for $i,$arg.name fn `$f.name`: expected $f.args.len, but got less')
}
if p.tok == .comma {
2019-06-22 21:20:28 +03:00
p.fgen(', ')
}
if !is_vararg {
p.next()
p.gen(',')
}
}
}
// varargs
if f.args.len > 0 {
last_arg := f.args.last()
if last_arg.name == '..' {
for p.tok != .rpar {
if p.tok == .comma {
2019-06-22 21:20:28 +03:00
p.gen(',')
p.check(.comma)
2019-06-22 21:20:28 +03:00
}
p.bool_expression()
}
}
}
if p.tok == .comma {
2019-06-22 21:20:28 +03:00
p.error('wrong number of arguments for fn `$f.name`: expected $f.args.len, but got more')
}
p.check(.rpar)
return f // TODO is return f right?
2019-06-22 21:20:28 +03:00
}
// "fn (int, string) int"
fn (f Fn) typ_str() string {
mut sb := strings.new_builder(50)
2019-06-22 21:20:28 +03:00
sb.write('fn (')
for i, arg in f.args {
sb.write(arg.typ)
if i < f.args.len - 1 {
sb.write(',')
}
}
sb.write(')')
if f.typ != 'void' {
sb.write(' $f.typ')
}
return sb.str()
}
// f.args => "int a, string b"
2019-09-01 22:51:16 +03:00
fn (f &Fn) str_args(table &Table) string {
2019-06-22 21:20:28 +03:00
mut s := ''
for i, arg in f.args {
// Interfaces are a special case. We need to pass the object + pointers
// to all methods:
// fn handle(r Runner) { =>
// void handle(void *r, void (*Runner_run)(void*)) {
if table.is_interface(arg.typ) {
// First the object (same name as the interface argument)
s += ' void* $arg.name'
// Now all methods
interface_type := table.find_type(arg.typ)
for method in interface_type.methods {
s += ', $method.typ (*${arg.typ}_${method.name})(void*'
if method.args.len > 1 {
for a in method.args.right(1) {
s += ', $a.typ'
}
}
s += ')'
2019-06-22 21:20:28 +03:00
}
}
else if arg.name == '..' {
s += '...'
}
else {
// s += '$arg.typ $arg.name'
s += table.cgen_name_type_pair(arg.name, arg.typ)// '$arg.typ $arg.name'
}
if i < f.args.len - 1 {
s += ', '
}
}
return s
}
// find local function variable with closest name to `name`
2019-09-23 20:34:08 +03:00
fn (p &Parser) find_misspelled_local_var(name string, min_match f32) string {
2019-09-13 16:15:30 +03:00
mut closest := f32(0)
mut closest_var := ''
2019-09-23 20:34:08 +03:00
for var in p.local_vars {
if var.scope_level > p.cur_fn.scope_level {
continue
}
2019-09-15 20:07:12 +03:00
n := name.all_after('.')
if var.name == '' || (n.len - var.name.len > 2 || var.name.len - n.len > 2) { continue }
2019-09-23 20:34:08 +03:00
coeff := strings.dice_coefficient(var.name, n)
if coeff > closest {
closest = coeff
2019-09-15 20:07:12 +03:00
closest_var = var.name
}
}
2019-09-13 16:15:30 +03:00
return if closest >= min_match { closest_var } else { '' }
}