From 01c2d25ae5c59cf9d9e008f0d869dbfddaae8ae4 Mon Sep 17 00:00:00 2001 From: joe-conigliaro Date: Mon, 5 Aug 2019 17:49:52 +1000 Subject: [PATCH] compiler: rename pkg to mod and auto save file import table --- compiler/fn.v | 28 +++++------ compiler/jsgen.v | 4 +- compiler/main.v | 20 +++----- compiler/parser.v | 122 +++++++++++++++++++++++----------------------- compiler/table.v | 48 +++++++++--------- 5 files changed, 110 insertions(+), 112 deletions(-) diff --git a/compiler/fn.v b/compiler/fn.v index daae71da7a..c65043473f 100644 --- a/compiler/fn.v +++ b/compiler/fn.v @@ -14,7 +14,7 @@ struct Fn { // addr int mut: name string - pkg string + mod string local_vars []Var var_idx int args []Var @@ -97,9 +97,9 @@ fn (p mut Parser) is_sig() bool { (p.file_path.contains(ModPath)) } -fn new_fn(pkg string, is_public bool) *Fn { +fn new_fn(mod string, is_public bool) *Fn { return &Fn { - pkg: pkg + mod: mod local_vars: [Var{} ; MaxLocalVars] is_public: is_public } @@ -137,13 +137,13 @@ fn (p mut Parser) fn_decl() { p.error('invalid receiver type `$receiver_typ` (`$receiver_typ` is an interface)') } // Don't allow modifying types from a different module - if !p.first_pass() && !p.builtin_pkg && T.mod != p.mod { + if !p.first_pass() && !p.builtin_mod && T.mod != p.mod { println('T.mod=$T.mod') println('p.mod=$p.mod') p.error('cannot define new methods on non-local type `$receiver_typ`') } // (a *Foo) instead of (a mut Foo) is a common mistake - if !p.builtin_pkg && receiver_typ.contains('*') { + if !p.builtin_mod && receiver_typ.contains('*') { t := receiver_typ.replace('*', '') p.error('use `($receiver_name mut $t)` instead of `($receiver_name *$t)`') } @@ -175,10 +175,10 @@ fn (p mut Parser) fn_decl() { // C function header def? (fn C.NSMakeRect(int,int,int,int)) is_c := f.name == 'C' && p.tok == .dot // Just fn signature? only builtin.v + default build mode - // is_sig := p.builtin_pkg && p.pref.build_mode == default_mode - // is_sig := p.pref.build_mode == default_mode && (p.builtin_pkg || p.file.contains(LANG_TMP)) + // 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)) is_sig := p.is_sig() - // println('\n\nfn decl !!is_sig=$is_sig name=$f.name $p.builtin_pkg') + // println('\n\nfn decl !!is_sig=$is_sig name=$f.name $p.builtin_mod') if is_c { p.check(.dot) f.name = p.check_name() @@ -199,10 +199,10 @@ fn (p mut Parser) fn_decl() { if receiver_typ != '' { // f.name = '${receiver_typ}_${f.name}' } - // full pkg function name + // full mod function name // os.exit ==> os__exit() - if !is_c && !p.builtin_pkg && p.mod != 'main' && receiver_typ.len == 0 { - f.name = p.prepend_pkg(f.name) + if !is_c && !p.builtin_mod && p.mod != 'main' && receiver_typ.len == 0 { + f.name = p.prepend_mod(f.name) } if p.first_pass() && p.table.known_fn(f.name) && receiver_typ.len == 0 { existing_fn := p.table.find_fn(f.name) @@ -471,7 +471,7 @@ _thread_so = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)&reload_so, 0, 0, 0); // p.error('unclosed {') } // Make sure all vars in this function are used (only in main for now) - // if p.builtin_pkg || p.mod == 'os' ||p.mod=='http'{ + // if p.builtin_mod || p.mod == 'os' ||p.mod=='http'{ if p.mod != 'main' { if !is_generic { p.genln('}') @@ -580,11 +580,11 @@ fn (p mut Parser) async_fn_call(f Fn, method_ph int, receiver_var, receiver_type } fn (p mut Parser) fn_call(f Fn, method_ph int, receiver_var, receiver_type string) { - if !f.is_public && !f.is_c && !p.pref.is_test && !f.is_interface && f.pkg != p.mod { + if !f.is_public && !f.is_c && !p.pref.is_test && !f.is_interface && f.mod != p.mod { p.error('function `$f.name` is private') } p.calling_c = f.is_c - if f.is_c && !p.builtin_pkg { + if f.is_c && !p.builtin_mod { if f.name == 'free' { p.error('use `free()` instead of `C.free()`') } else if f.name == 'malloc' { diff --git a/compiler/jsgen.v b/compiler/jsgen.v index 55b5758101..9fc9a7b246 100644 --- a/compiler/jsgen.v +++ b/compiler/jsgen.v @@ -28,7 +28,7 @@ fn (p mut Parser) gen_json_for_type(typ Type) { // println('gen_json_for_type( $typ.name )') // Register decoder fn mut dec_fn := Fn { - pkg: p.mod + mod: p.mod typ: 'Option_$typ.name' name: js_dec_name(t) } @@ -45,7 +45,7 @@ fn (p mut Parser) gen_json_for_type(typ Type) { p.table.register_fn(dec_fn) // Register encoder fn mut enc_fn := Fn { - pkg: p.mod + mod: p.mod typ: 'cJSON*' name: js_enc_name(t) } diff --git a/compiler/main.v b/compiler/main.v index 466f90445c..f2306f1744 100644 --- a/compiler/main.v +++ b/compiler/main.v @@ -946,19 +946,15 @@ fn (v mut V) add_v_files_to_compile() { v.log('user_files:') println(user_files) } - // import tables for user/lib files - mut file_imports := []FileImportTable // Parse builtin imports for file in v.files { mut p := v.new_parser(file, Pass.imports) p.parse() - file_imports << *p.import_table } // Parse user imports for file in user_files { mut p := v.new_parser(file, Pass.imports) p.parse() - file_imports << *p.import_table } // Parse lib imports /* @@ -977,7 +973,6 @@ fn (v mut V) add_v_files_to_compile() { for file in vfiles { mut p := v.new_parser(file, Pass.imports) p.parse() - file_imports << *p.import_table } } } @@ -996,7 +991,6 @@ fn (v mut V) add_v_files_to_compile() { for file in vfiles { mut p := v.new_parser(file, Pass.imports) p.parse() - file_imports << *p.import_table } } if v.pref.is_verbose { @@ -1005,7 +999,7 @@ fn (v mut V) add_v_files_to_compile() { } // graph deps mut dep_graph := new_mod_dep_graph() - dep_graph.from_import_tables(file_imports) + dep_graph.from_import_tables(v.table.file_imports) deps_resolved := dep_graph.resolve() if !deps_resolved.acyclic { deps_resolved.display() @@ -1034,7 +1028,7 @@ fn (v mut V) add_v_files_to_compile() { } } // add remaining files (not modules) - for fit in file_imports { + for fit in v.table.file_imports { //println('fit $fit.file_path') if !fit.file_path in v.files { v.files << fit.file_path @@ -1058,13 +1052,13 @@ fn get_arg(joined_args, arg, def string) string { return res } -fn (v &V) module_path(pkg string) string { +fn (v &V) module_path(mod string) string { // submodule support - if pkg.contains('.') { - //return pkg.replace('.', path_sep) - return pkg.replace('.', '/') + if mod.contains('.') { + //return mod.replace('.', path_sep) + return mod.replace('.', '/') } - return pkg + return mod } fn (v &V) log(s string) { diff --git a/compiler/parser.v b/compiler/parser.v index d9e44a2bd0..097bc1ac39 100644 --- a/compiler/parser.v +++ b/compiler/parser.v @@ -62,7 +62,7 @@ mut: tmp_cnt int is_script bool pref *Preferences // Setting and Preferences shared from V struct - builtin_pkg bool + builtin_mod bool vh_lines []string inside_if_expr bool is_struct_init bool @@ -184,13 +184,13 @@ fn (p mut Parser) parse() { p.mod = p.check_name() } p.fgenln('\n') - p.builtin_pkg = p.mod == 'builtin' + p.builtin_mod = p.mod == 'builtin' p.can_chash = p.mod == 'ft' || p.mod == 'glfw' || p.mod=='glfw2' || p.mod=='ui' // TODO tmp remove // Import pass - the first and the smallest pass that only analyzes imports // fully qualify the module name, eg base64 to encoding.base64 fq_mod := p.table.qualify_module(p.mod, p.file_path) p.import_table.module_name = fq_mod - p.table.register_package(fq_mod) + p.table.register_module(fq_mod) // replace "." with "_dot_" in module name for C variable names p.mod = fq_mod.replace('.', '_dot_') if p.pass == .imports { @@ -199,7 +199,9 @@ fn (p mut Parser) parse() { } if p.table.imports.contains('builtin') { p.error('module `builtin` cannot be imported') - } + } + // save file import table + p.table.file_imports << *p.import_table return } // Go through every top level token or throw a compilation error if a non-top level token is met @@ -264,7 +266,7 @@ fn (p mut Parser) parse() { p.comp_time() case Token.key_global: if !p.pref.translated && !p.pref.is_live && - !p.builtin_pkg && !p.building_v { + !p.builtin_mod && !p.building_v { p.error('__global is only allowed in translated code') } p.next() @@ -362,18 +364,18 @@ fn (p mut Parser) import_statement() { if p.peek() == .number && p.scanner.text[p.scanner.pos + 1] == `.` { p.error('bad import format. module/submodule names cannot begin with a number.') } - mut pkg := p.check_name().trim_space() - mut mod_alias := pkg + mut mod := p.check_name().trim_space() + mut mod_alias := mod // submodule support mut depth := 1 for p.tok == .dot { p.check(.dot) submodule := p.check_name() mod_alias = submodule - pkg += '.' + submodule + mod += '.' + submodule depth++ if depth > MaxModuleDepth { - p.error('module depth of $MaxModuleDepth exceeded: $pkg') + p.error('module depth of $MaxModuleDepth exceeded: $mod') } } // aliasing (import encoding.base64 as b64) @@ -382,16 +384,16 @@ fn (p mut Parser) import_statement() { mod_alias = p.check_name() } // add import to file scope import table - p.import_table.register_alias(mod_alias, pkg) + p.import_table.register_alias(mod_alias, mod) // Make sure there are no duplicate imports - if p.table.imports.contains(pkg) { + if p.table.imports.contains(mod) { return } - p.log('adding import $pkg') - p.table.imports << pkg - p.table.register_package(pkg) + p.log('adding import $mod') + p.table.imports << mod + p.table.register_module(mod) - p.fgenln(' ' + pkg) + p.fgenln(' ' + mod) } fn (p mut Parser) const_decl() { @@ -411,9 +413,9 @@ fn (p mut Parser) const_decl() { //if ! (name[0] >= `A` && name[0] <= `Z`) { //p.error('const name must be capitalized') //} - // Imported consts (like GL_TRIANG.leS) dont need pkg prepended (gl__GL_TRIANG.leS) + // Imported consts (like GL_TRIANG.leS) dont need mod prepended (gl__GL_TRIANG.leS) if !is_import { - name = p.prepend_pkg(name) + name = p.prepend_mod(name) } mut typ := 'int' if !is_import { @@ -525,8 +527,8 @@ fn (p mut Parser) struct_decl() { p.error('bad struct name, e.g. use `HttpRequest` instead of `HTTPRequest`') } // Specify full type name - if !is_c && !p.builtin_pkg && p.mod != 'main' { - name = p.prepend_pkg(name) + if !is_c && !p.builtin_mod && p.mod != 'main' { + name = p.prepend_mod(name) } if p.pass == .decl && p.table.known_type(name) { p.error('`$name` redeclared') @@ -682,8 +684,8 @@ fn (p mut Parser) struct_decl() { fn (p mut Parser) enum_decl(_enum_name string) { mut enum_name := _enum_name // Specify full type name - if !p.builtin_pkg && p.mod != 'main' { - enum_name = p.prepend_pkg(enum_name) + if !p.builtin_mod && p.mod != 'main' { + enum_name = p.prepend_mod(enum_name) } // Skip empty enums if enum_name != 'int' { @@ -822,7 +824,7 @@ fn (p mut Parser) get_type() string { if debug { println('\nget_type() .key_goT FN TYP line=$p.scanner.line_nr') } - mut f := Fn{name: '_', pkg: p.mod} + mut f := Fn{name: '_', mod: p.mod} p.next() line_nr := p.scanner.line_nr p.fn_args(mut f) @@ -883,7 +885,7 @@ fn (p mut Parser) get_type() string { } } // map[string]int - if !p.builtin_pkg && p.tok == .name && p.lit == 'map' { + if !p.builtin_mod && p.tok == .name && p.lit == 'map' { p.next() p.check(.lsbr) key_type := p.check_name() @@ -919,19 +921,19 @@ fn (p mut Parser) get_type() string { typ = p.lit } else { - // Package specified? (e.g. gx.Image) + // Module specified? (e.g. gx.Image) if p.peek() == .dot { p.next() p.check(.dot) typ += '__$p.lit' } mut t := p.table.find_type(typ) - // "typ" not found? try "pkg__typ" - if t.name == '' && !p.builtin_pkg { + // "typ" not found? try "mod__typ" + if t.name == '' && !p.builtin_mod { // && !p.first_pass() { if !typ.contains('array_') && p.mod != 'main' && !typ.contains('__') && !typ.starts_with('[') { - typ = p.prepend_pkg(typ) + typ = p.prepend_mod(typ) } t = p.table.find_type(typ) if t.name == '' && !p.pref.translated && !p.first_pass() && !typ.starts_with('[') { @@ -974,7 +976,7 @@ fn (p mut Parser) get_type() string { return 'byte*' } if typ == 'voidptr' { - //if !p.builtin_pkg && p.mod != 'os' && p.mod != 'gx' && p.mod != 'gg' && !p.pref.translated { + //if !p.builtin_mod && p.mod != 'os' && p.mod != 'gx' && p.mod != 'gg' && !p.pref.translated { //p.error('voidptr can only be used in unsafe code') //} return 'void*' @@ -1225,7 +1227,7 @@ fn (p mut Parser) assign_statement(v Var, ph int, is_map bool) { //p.cgen.cur_line = left + 'opt_ok($expr)' p.cgen.resetln(left + 'opt_ok($expr, sizeof($expr_type))') } - else if !p.builtin_pkg && !p.check_types_no_throw(expr_type, p.assigned_type) { + else if !p.builtin_mod && !p.check_types_no_throw(expr_type, p.assigned_type) { p.scanner.line_nr-- p.error('cannot use type `$expr_type` as type `$p.assigned_type` in assignment') } @@ -1256,7 +1258,7 @@ fn (p mut Parser) var_decl() { p.var_decl_name = name // Don't allow declaring a variable with the same name. Even in a child scope // (shadowing is not allowed) - if !p.builtin_pkg && p.cur_fn.known_var(name) { + if !p.builtin_mod && p.cur_fn.known_var(name) { v := p.cur_fn.find_var(name) p.error('redefinition of `$name`') } @@ -1395,7 +1397,7 @@ fn (p mut Parser) name_expr() string { p.next() } if deref { - if p.pref.is_play && !p.builtin_pkg { + if p.pref.is_play && !p.builtin_mod { p.error('dereferencing is temporarily disabled on the playground, will be fixed soon') } } @@ -1433,23 +1435,23 @@ fn (p mut Parser) name_expr() string { // ////////////////////////// // module ? // Allow shadowing (gg = gg.newcontext(); gg.draw_triangle()) - if ((name == p.mod && p.table.known_pkg(name)) || p.import_table.known_alias(name)) + if ((name == p.mod && p.table.known_mod(name)) || p.import_table.known_alias(name)) && !p.cur_fn.known_var(name) && !is_c { - mut pkg := name + mut mod := name // must be aliased module if name != p.mod && p.import_table.known_alias(name) { // we replaced "." with "_dot_" in p.mod for C variable names, do same here. - pkg = p.import_table.resolve_alias(name).replace('.', '_dot_') + mod = p.import_table.resolve_alias(name).replace('.', '_dot_') } p.next() p.check(.dot) name = p.lit p.fgen(name) - name = prepend_pkg(pkg, name) + name = prepend_mod(mod, name) } else if !p.table.known_type(name) && !p.cur_fn.known_var(name) && !p.table.known_fn(name) && !p.table.known_const(name) && !is_c { - name = p.prepend_pkg(name) + name = p.prepend_mod(name) } // Variable mut v := p.cur_fn.find_var(name) @@ -1517,7 +1519,7 @@ fn (p mut Parser) name_expr() string { return enum_type.name } else if p.peek() == .lcbr { - // go back to name start (pkg.name) + // go back to name start (mod.name) /* p.scanner.pos = hack_pos p.tok = hack_tok @@ -1582,9 +1584,9 @@ fn (p mut Parser) name_expr() string { f = p.table.find_fn(name) } if f.name == '' { - // If orig_name is a pkg, then printing undefined: `pkg` tells us nothing - // if p.table.known_pkg(orig_name) { - if p.table.known_pkg(orig_name) || p.import_table.known_alias(orig_name) { + // If orig_name is a mod, then printing undefined: `mod` tells us nothing + // if p.table.known_mod(orig_name) { + if p.table.known_mod(orig_name) || p.import_table.known_alias(orig_name) { name = name.replace('__', '.').replace('_dot_', '.') p.error('undefined: `$name`') } @@ -1750,21 +1752,21 @@ fn (p mut Parser) dot(str_typ string, method_ph int) string { next := p.peek() modifying := next.is_assign() || next == .inc || next == .dec is_vi := p.fileis('vi') - if !p.builtin_pkg && !p.pref.translated && modifying && !field.is_mut && !is_vi { + if !p.builtin_mod && !p.pref.translated && modifying && !field.is_mut && !is_vi { p.error('cannot modify immutable field `$field_name` (type `$typ.name`)') } - if !p.builtin_pkg && p.mod != typ.mod { + if !p.builtin_mod && p.mod != typ.mod { } - // if p.pref.is_play && field.access_mod ==.private && !p.builtin_pkg && p.mod != typ.mod { + // if p.pref.is_play && field.access_mod ==.private && !p.builtin_mod && p.mod != typ.mod { // Don't allow `arr.data` - if field.access_mod == .private && !p.builtin_pkg && !p.pref.translated && p.mod != typ.mod { + if field.access_mod == .private && !p.builtin_mod && !p.pref.translated && p.mod != typ.mod { // println('$typ.name :: $field.name ') // println(field.access_mod) p.error('cannot refer to unexported field `$field_name` (type `$typ.name`)') } - // if field.access_mod ==.public && p.peek() == .assign && !p.builtin_pkg && p.mod != typ.mod { + // if field.access_mod ==.public && p.peek() == .assign && !p.builtin_mod && p.mod != typ.mod { // Don't allow `str.len = 0` - if field.access_mod == .public && !p.builtin_pkg && p.mod != typ.mod { + if field.access_mod == .public && !p.builtin_mod && p.mod != typ.mod { if !field.is_mut && !p.pref.translated && modifying { p.error('cannot modify public immutable field `$field_name` (type `$typ.name`)') } @@ -1815,8 +1817,8 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string { if is_str { typ = 'byte' p.fgen('[') - // Direct faster access to .str[i] in builtin package - if p.builtin_pkg { + // Direct faster access to .str[i] in builtin modules + if p.builtin_mod { p.gen('.str[') close_bracket = true } @@ -1866,7 +1868,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string { typ = 'void*' } // No bounds check in translated from C code - if p.pref.translated && !p.builtin_pkg{ + if p.pref.translated && !p.builtin_mod{ // Cast void* to typ*: add (typ*) to the beginning of the assignment : // ((int*)a.data = ... p.cgen.set_placeholder(fn_ph, '(($typ*)(') @@ -1898,7 +1900,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string { p.expression() } p.check(.rsbr) - // if (is_str && p.builtin_pkg) || is_ptr || is_fixed_arr && ! (is_ptr && is_arr) { + // if (is_str && p.builtin_mod) || is_ptr || is_fixed_arr && ! (is_ptr && is_arr) { if close_bracket { p.gen(']/*r$typ $v.is_mut*/') } @@ -1910,7 +1912,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string { p.tok == .mult_assign || p.tok == .div_assign || p.tok == .xor_assign || p.tok == .mod_assign || p.tok == .or_assign || p.tok == .and_assign || p.tok == .righ_shift_assign || p.tok == .left_shift_assign { - if is_indexer && is_str && !p.builtin_pkg { + if is_indexer && is_str && !p.builtin_mod { p.error('strings are immutable') } assign_pos := p.cgen.cur_line.len @@ -1948,7 +1950,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string { // p.error('didnt assign') // } // m[key]. no =, just a getter - else if (is_map || is_arr || (is_str && !p.builtin_pkg)) && is_indexer { + else if (is_map || is_arr || (is_str && !p.builtin_mod)) && is_indexer { // Erase var name we generated earlier: "int a = m, 0" // "m, 0" gets killed since we need to start from scratch. It's messy. // "m, 0" is an index expression, save it before deleting and insert later in map_get() @@ -1966,7 +1968,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string { p.cgen.insert_before('$typ $tmp = $def; bool $tmp_ok = map_get($index_expr, & $tmp);') } else if is_arr { - if p.pref.translated && !p.builtin_pkg { + if p.pref.translated && !p.builtin_mod { p.gen('$index_expr ]') } else { @@ -1977,7 +1979,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string { } } } - else if is_str && !p.builtin_pkg { + else if is_str && !p.builtin_mod { p.gen('string_at($index_expr)') } // Zero the string after map_get() if it's nil, numbers are automatically 0 @@ -2536,7 +2538,7 @@ fn (p mut Parser) array_init() string { // fixed length arrays with a const len: `nums := [N]int`, same as `[10]int` basically mut is_const_len := false if p.tok == .name { - c := p.table.find_const(p.prepend_pkg(p.lit)) + c := p.table.find_const(p.prepend_mod(p.lit)) if c.name != '' && c.typ == 'int' && p.peek() == .rsbr && !p.inside_const { is_integer = true is_const_len = true @@ -2733,7 +2735,7 @@ fn (p mut Parser) struct_init(typ string, is_c_struct_init bool) string { continue } field_typ := field.typ - if !p.builtin_pkg && field_typ.ends_with('*') && field_typ.contains('Cfg') { + if !p.builtin_mod && field_typ.ends_with('*') && field_typ.contains('Cfg') { p.error('pointer field `${typ}.${field.name}` must be initialized') } def_val := type_default(field_typ) @@ -3255,12 +3257,12 @@ fn (p mut Parser) return_st() { p.returns = true } -fn prepend_pkg(pkg, name string) string { - return '${pkg}__${name}' +fn prepend_mod(mod, name string) string { + return '${mod}__${name}' } -fn (p &Parser) prepend_pkg(name string) string { - return prepend_pkg(p.mod, name) +fn (p &Parser) prepend_mod(name string) string { + return prepend_mod(p.mod, name) } fn (p mut Parser) go_statement() { diff --git a/compiler/table.v b/compiler/table.v index 9d0f197f2d..80ac06f90b 100644 --- a/compiler/table.v +++ b/compiler/table.v @@ -9,16 +9,17 @@ import strings struct Table { mut: - types []Type - consts []Var - fns map[string]Fn - generic_fns []GenTable //map[string]GenTable // generic_fns['listen_and_serve'] == ['Blog', 'Forum'] - obf_ids map[string]int // obf_ids['myfunction'] == 23 - packages []string // List of all modules registered by the application - imports []string // List of all imports - flags []string // ['-framework Cocoa', '-lglfw3'] - fn_cnt int atomic - obfuscate bool + types []Type + consts []Var + fns map[string]Fn + generic_fns []GenTable //map[string]GenTable // generic_fns['listen_and_serve'] == ['Blog', 'Forum'] + obf_ids map[string]int // obf_ids['myfunction'] == 23 + modules []string // List of all modules registered by the application + imports []string // List of all imports + file_imports []FileImportTable // List of imports for file + flags []string // ['-framework Cocoa', '-lglfw3'] + fn_cnt int atomic + obfuscate bool } struct GenTable { @@ -140,6 +141,7 @@ fn new_table(obfuscate bool) *Table { //generic_fns: map[string]GenTable{} generic_fns: []GenTable obfuscate: obfuscate + file_imports: []FileImportTable } t.register_type('int') t.register_type('size_t') @@ -181,11 +183,11 @@ fn (t mut Table) var_cgen_name(name string) string { } } -fn (t mut Table) register_package(pkg string) { - if t.packages.contains(pkg) { +fn (t mut Table) register_module(mod string) { + if t.modules.contains(mod) { return } - t.packages << pkg + t.modules << mod } fn (p mut Parser) register_array(typ string) { @@ -210,8 +212,8 @@ fn (p mut Parser) register_map(typ string) { } } -fn (table &Table) known_pkg(pkg string) bool { - return pkg in table.packages +fn (table &Table) known_mod(mod string) bool { + return mod in table.modules } fn (t mut Table) register_const(name, typ, mod string, is_imported bool) { @@ -308,9 +310,9 @@ fn (t mut Table) register_type_with_parent(typ, parent string) { } } /* -mut pkg := '' +mut mod := '' if parent == 'array' { -pkg = 'builtin' +mod = 'builtin' } */ t.types << Type { @@ -433,7 +435,7 @@ fn (t mut Type) add_gen_type(type_name string) { fn (p &Parser) find_type(name string) *Type { typ := p.table.find_type(name) if typ.name.len == 0 { - return p.table.find_type(p.prepend_pkg(name)) + return p.table.find_type(p.prepend_mod(name)) } return typ } @@ -481,7 +483,7 @@ fn (p mut Parser) _check_types(got, expected string, throw bool) bool { } // Todo void* allows everything right now if got=='void*' || expected=='void*' { - // if !p.builtin_pkg { + // if !p.builtin_mod { if p.pref.is_play { return false } @@ -655,14 +657,14 @@ fn (table mut Table) cgen_name(f &Fn) string { // Avoid name conflicts (with things like abs(), print() etc). // Generate b_abs(), b_print() // TODO duplicate functionality - if f.pkg == 'builtin' && CReserved.contains(f.name) { + if f.mod == 'builtin' && CReserved.contains(f.name) { return 'v_$name' } // Obfuscate but skip certain names // TODO ugly, fix - if table.obfuscate && f.name != 'main' && f.name != 'WinMain' && f.pkg != 'builtin' && !f.is_c && - f.pkg != 'darwin' && f.pkg != 'os' && !f.name.contains('window_proc') && f.name != 'gg__vec2' && - f.name != 'build_token_str' && f.name != 'build_keys' && f.pkg != 'json' && + if table.obfuscate && f.name != 'main' && f.name != 'WinMain' && f.mod != 'builtin' && !f.is_c && + f.mod != 'darwin' && f.mod != 'os' && !f.name.contains('window_proc') && f.name != 'gg__vec2' && + f.name != 'build_token_str' && f.name != 'build_keys' && f.mod != 'json' && !name.ends_with('_str') && !name.contains('contains') { mut idx := table.obf_ids[name] // No such function yet, register it