v/compiler/parser.v

3737 lines
89 KiB
V
Raw Normal View History

2019-06-23 04:21:30 +02: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 20:20:28 +02:00
module main
2019-07-29 18:21:36 +02:00
import (
os
rand
strings
2019-08-17 21:19:37 +02:00
)
2019-06-22 20:20:28 +02:00
struct Parser {
file_path string // "/home/user/hello.v"
file_name string // "hello.v"
file_platform string // ".v", "_win.v", "_nix.v", "_mac.v", "_lin.v" ...
2019-08-17 21:19:37 +02:00
file_pcguard string // When p.file_pcguard != '', it contains a
// C ifdef guard clause that must be put before
// the #include directives in the parsed .v file
2019-09-01 21:51:16 +02:00
v &V
2019-09-19 16:25:00 +02:00
pref &Preferences // Preferences shared from V struct
mut:
2019-09-01 21:51:16 +02:00
scanner &Scanner
2019-06-22 20:20:28 +02:00
// tokens []Token // TODO cache all tokens, right now they have to be scanned twice
token_idx int
tok Token
prev_tok Token
prev_tok2 Token // TODO remove these once the tokens are cached
lit string
2019-09-01 21:51:16 +02:00
cgen &CGen
table &Table
import_table &FileImportTable // Holds imports for just the file being parsed
2019-08-17 21:19:37 +02:00
pass Pass
os OS
mod string
2019-06-22 20:20:28 +02:00
inside_const bool
expr_var Var
has_immutable_field bool
first_immutable_field Var
2019-06-22 20:20:28 +02:00
assigned_type string
expected_type string
2019-06-22 20:20:28 +02:00
tmp_cnt int
is_script bool
builtin_mod bool
2019-06-22 20:20:28 +02:00
vh_lines []string
inside_if_expr bool
2019-08-26 23:39:11 +02:00
inside_unwrapping_match_statement bool
inside_return_expr bool
2019-06-22 20:20:28 +02:00
is_struct_init bool
if_expr_cnt int
for_expr_cnt int // to detect whether `continue` can be used
ptr_cast bool
calling_c bool
cur_fn Fn
2019-06-22 20:20:28 +02:00
returns bool
vroot string
2019-06-27 17:48:49 +02:00
is_c_struct_init bool
is_empty_c_struct_init bool
is_c_fn_call bool
can_chash bool
2019-08-17 21:19:37 +02:00
attr string
v_script bool // "V bash", import all os functions into global space
var_decl_name string // To allow declaring the variable so that it can be used in the struct initialization
is_alloc bool // Whether current expression resulted in an allocation
cur_gen_type string // "App" to replace "T" in current generic function
is_vweb bool
is_sql bool
2019-09-14 22:48:30 +02:00
is_js bool
2019-08-17 21:19:37 +02:00
sql_i int // $1 $2 $3
sql_params []string // ("select * from users where id = $1", ***"100"***)
sql_types []string // int, string and so on; see sql_params
2019-06-22 20:20:28 +02:00
}
const (
EmptyFn = Fn { }
MainFn= Fn{name:'main'}
2019-06-22 20:20:28 +02:00
)
const (
MaxModuleDepth = 4
2019-08-17 21:19:37 +02:00
)
fn (v mut V) new_parser(path string) Parser {
//println('new_parser("$path")')
mut path_pcguard := ''
mut path_platform := '.v'
for path_ending in ['_lin.v', '_mac.v', '_win.v', '_nix.v'] {
if path.ends_with(path_ending) {
path_platform = path_ending
path_pcguard = platform_postfix_to_ifdefguard( path_ending )
break
}
}
2019-06-22 20:20:28 +02:00
mut p := Parser {
2019-08-17 21:19:37 +02:00
v: v
2019-06-22 20:20:28 +02:00
file_path: path
file_name: path.all_after('/')
file_platform: path_platform
file_pcguard: path_pcguard
2019-06-22 20:20:28 +02:00
scanner: new_scanner(path)
2019-07-29 18:21:36 +02:00
table: v.table
2019-07-12 07:37:54 +02:00
import_table: new_file_import_table(path)
2019-06-22 20:20:28 +02:00
cur_fn: EmptyFn
2019-07-29 18:21:36 +02:00
cgen: v.cgen
is_script: (v.pref.is_script && path == v.dir)
pref: v.pref
os: v.os
vroot: v.vroot
2019-08-17 21:19:37 +02:00
2019-06-22 20:20:28 +02:00
}
2019-09-14 22:48:30 +02:00
$if js {
p.is_js = true
}
2019-07-26 16:45:16 +02:00
if p.pref.is_repl {
p.scanner.should_print_line_on_error = false
}
2019-07-29 18:21:36 +02:00
v.cgen.line_directives = v.pref.is_debuggable
v.cgen.file = path
2019-07-26 16:45:16 +02:00
2019-06-22 20:20:28 +02:00
p.next()
// p.scanner.debug_tokens()
return p
}
fn (p mut Parser) set_current_fn(f Fn) {
2019-09-07 12:44:41 +02:00
p.cur_fn = f
//p.cur_fn = p.table.fns[f.name]
2019-09-07 12:44:41 +02:00
p.scanner.fn_name = '${f.mod}.${f.name}'
}
2019-06-22 20:20:28 +02:00
fn (p mut Parser) next() {
p.prev_tok2 = p.prev_tok
p.prev_tok = p.tok
2019-08-17 21:19:37 +02:00
p.scanner.prev_tok = p.tok
2019-06-22 20:20:28 +02:00
res := p.scanner.scan()
p.tok = res.tok
p.lit = res.lit
}
fn (p &Parser) log(s string) {
2019-08-17 21:19:37 +02:00
/*
if !p.pref.is_verbose {
2019-06-22 20:20:28 +02:00
return
}
println(s)
2019-08-17 21:19:37 +02:00
*/
2019-06-22 20:20:28 +02:00
}
fn (p mut Parser) parse(pass Pass) {
p.pass = pass
2019-07-29 18:21:36 +02:00
p.log('\nparse() run=$p.pass file=$p.file_name tok=${p.strtok()}')// , "script_file=", script_file)
2019-06-22 20:20:28 +02:00
// `module main` is not required if it's a single file program
if p.is_script || p.pref.is_test {
p.mod = 'main'
2019-06-22 20:20:28 +02:00
// User may still specify `module main`
if p.tok == .key_module {
2019-06-22 20:20:28 +02:00
p.next()
p.fgen('module ')
p.mod = p.check_name()
2019-06-22 20:20:28 +02:00
}
}
else {
p.check(.key_module)
2019-08-17 21:19:37 +02:00
p.fspace()
p.mod = p.check_name()
2019-06-22 20:20:28 +02:00
}
p.fgenln('\n')
p.builtin_mod = p.mod == 'builtin'
p.can_chash = p.mod=='ui' || p.mod == 'darwin'// TODO tmp remove
2019-06-22 20:20:28 +02:00
// Import pass - the first and the smallest pass that only analyzes imports
2019-07-12 07:37:54 +02:00
// fully qualify the module name, eg base64 to encoding.base64
fq_mod := p.table.qualify_module(p.mod, p.file_path)
2019-07-21 17:53:35 +02:00
p.import_table.module_name = fq_mod
p.table.register_module(fq_mod)
2019-07-13 15:11:32 +02:00
// replace "." with "_dot_" in module name for C variable names
p.mod = fq_mod.replace('.', '_dot_')
2019-07-29 18:21:36 +02:00
if p.pass == .imports {
for p.tok == .key_import && p.peek() != .key_const {
2019-07-16 17:59:07 +02:00
p.imports()
2019-06-22 20:20:28 +02:00
}
if 'builtin' in p.table.imports {
2019-08-17 21:19:37 +02:00
p.error('module `builtin` cannot be imported')
}
// save file import table
p.table.file_imports << *p.import_table
2019-06-22 20:20:28 +02:00
return
}
// Go through every top level token or throw a compilation error if a non-top level token is met
for {
switch p.tok {
case .key_import:
if p.peek() == .key_const {
2019-06-22 20:20:28 +02:00
p.const_decl()
}
else {
// TODO remove imported consts from the language
2019-07-16 17:59:07 +02:00
p.imports()
2019-08-17 21:19:37 +02:00
if p.tok != .key_import {
p.fgenln('')
}
2019-06-22 20:20:28 +02:00
}
case Token.key_enum:
2019-06-22 20:20:28 +02:00
p.next()
if p.tok == .name {
2019-06-22 20:20:28 +02:00
p.fgen('enum ')
name := p.check_name()
p.fgen(' ')
p.enum_decl(name)
}
// enum without a name, only allowed in code, translated from C
// it's a very bad practice in C as well, but is used unfortunately (for example, by DOOM)
// such fields are basically int consts
else if p.pref.translated {
2019-06-22 20:20:28 +02:00
p.enum_decl('int')
}
else {
p.check(.name)
2019-06-22 20:20:28 +02:00
}
case Token.key_pub:
if p.peek() == .func {
2019-06-22 20:20:28 +02:00
p.fn_decl()
} else if p.peek() == .key_struct {
p.error('structs can\'t be declared public *yet*')
// TODO public structs
} else {
p.error('wrong pub keyword usage')
2019-06-22 20:20:28 +02:00
}
case Token.func:
2019-06-22 20:20:28 +02:00
p.fn_decl()
2019-07-16 12:17:17 +02:00
case Token.key_type:
2019-06-22 20:20:28 +02:00
p.type_decl()
case Token.lsbr:
2019-07-07 21:46:21 +02:00
// `[` can only mean an [attribute] before a function
// or a struct definition
2019-08-17 21:19:37 +02:00
p.attribute()
case Token.key_struct, Token.key_interface, Token.key_union, Token.lsbr:
2019-06-22 20:20:28 +02:00
p.struct_decl()
case Token.key_const:
2019-06-22 20:20:28 +02:00
p.const_decl()
case Token.hash:
2019-06-22 20:20:28 +02:00
// insert C code, TODO this is going to be removed ASAP
// some libraries (like UI) still have lots of C code
// # puts("hello");
p.chash()
case Token.dollar:
2019-06-22 20:20:28 +02:00
// $if, $else
p.comp_time()
case Token.key_global:
2019-08-17 21:19:37 +02:00
if !p.pref.translated && !p.pref.is_live &&
2019-09-08 16:19:42 +02:00
!p.builtin_mod && !p.pref.building_v && !os.getwd().contains('/volt') {
p.error('__global is only allowed in translated code')
2019-06-22 20:20:28 +02:00
}
p.next()
name := p.check_name()
typ := p.get_type()
p.register_global(name, typ)
// p.genln(p.table.cgen_name_type_pair(name, typ))
mut g := p.table.cgen_name_type_pair(name, typ)
if p.tok == .assign {
2019-06-22 20:20:28 +02:00
p.next()
// p.gen(' = ')
g += ' = '
p.cgen.start_tmp()
p.bool_expression()
// g += '<<< ' + p.cgen.end_tmp() + '>>>'
g += p.cgen.end_tmp()
}
// p.genln('; // global')
2019-08-17 21:19:37 +02:00
g += '; // global'
2019-06-22 20:20:28 +02:00
p.cgen.consts << g
case Token.eof:
2019-06-22 20:20:28 +02:00
p.log('end of parse()')
if p.is_script && !p.pref.is_test {
2019-09-07 12:44:41 +02:00
p.set_current_fn( MainFn )
p.check_unused_variables()
}
2019-07-29 18:21:36 +02:00
if false && !p.first_pass() && p.fileis('main.v') {
out := os.create('/var/tmp/fmt.v') or {
2019-08-29 02:30:17 +02:00
cerror('failed to create fmt.v')
return
2019-08-17 21:19:37 +02:00
}
2019-06-30 16:11:55 +02:00
out.writeln(p.scanner.fmt_out.str())
2019-06-22 20:20:28 +02:00
out.close()
}
return
default:
// no `fn main`, add this "global" statement to cgen.fn_main
if p.is_script && !p.pref.is_test {
// cur_fn is empty since there was no fn main declared
2019-08-17 21:19:37 +02:00
// we need to set it to save and find variables
2019-07-29 18:21:36 +02:00
if p.first_pass() {
if p.cur_fn.name == '' {
2019-09-07 12:44:41 +02:00
p.set_current_fn( MainFn )
2019-08-17 21:19:37 +02:00
}
return
}
if p.cur_fn.name == '' {
2019-09-07 12:44:41 +02:00
p.set_current_fn( MainFn )
if p.pref.is_repl {
p.cur_fn.clear_vars()
}
2019-08-17 21:19:37 +02:00
}
mut start := p.cgen.lines.len
2019-06-22 20:20:28 +02:00
p.statement(true)
if p.cgen.lines[start - 1] != '' && p.cgen.fn_main != '' {
start--
}
2019-08-17 21:19:37 +02:00
p.genln('')
2019-06-22 20:20:28 +02:00
end := p.cgen.lines.len
lines := p.cgen.lines.slice(start, end)
2019-08-17 21:19:37 +02:00
//mut line := p.cgen.fn_main + lines.join('\n')
//line = line.trim_space()
2019-06-22 20:20:28 +02:00
p.cgen.fn_main = p.cgen.fn_main + lines.join('\n')
p.cgen.resetln('')
2019-06-22 20:20:28 +02:00
for i := start; i < end; i++ {
p.cgen.lines[i] = ''
}
}
else {
p.error('unexpected token `${p.strtok()}`')
}
}
}
}
2019-07-16 17:59:07 +02:00
fn (p mut Parser) imports() {
p.check(.key_import)
2019-06-22 20:20:28 +02:00
// `import ()`
if p.tok == .lpar {
p.check(.lpar)
for p.tok != .rpar && p.tok != .eof {
2019-07-30 03:49:47 +02:00
p.import_statement()
2019-06-22 20:20:28 +02:00
}
p.check(.rpar)
2019-06-22 20:20:28 +02:00
return
}
// `import foo`
2019-07-30 03:49:47 +02:00
p.import_statement()
}
fn (p mut Parser) import_statement() {
if p.tok != .name {
p.error('bad import format')
}
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 mod := p.check_name().trim_space()
mut mod_alias := mod
2019-07-30 03:49:47 +02:00
// submodule support
mut depth := 1
for p.tok == .dot {
2019-08-17 21:19:37 +02:00
p.check(.dot)
2019-07-30 03:49:47 +02:00
submodule := p.check_name()
mod_alias = submodule
mod += '.' + submodule
2019-07-30 03:49:47 +02:00
depth++
2019-08-17 21:19:37 +02:00
if depth > MaxModuleDepth {
p.error('module depth of $MaxModuleDepth exceeded: $mod')
2019-07-30 03:49:47 +02:00
}
}
// aliasing (import encoding.base64 as b64)
if p.tok == .key_as && p.peek() == .name {
2019-08-17 21:19:37 +02:00
p.check(.key_as)
2019-07-30 03:49:47 +02:00
mod_alias = p.check_name()
}
// add import to file scope import table
p.import_table.register_alias(mod_alias, mod)
2019-07-30 03:49:47 +02:00
// Make sure there are no duplicate imports
if mod in p.table.imports {
2019-07-30 03:49:47 +02:00
return
}
p.log('adding import $mod')
p.table.imports << mod
p.table.register_module(mod)
2019-07-30 03:49:47 +02:00
p.fgenln(' ' + mod)
}
2019-06-22 20:20:28 +02:00
fn (p mut Parser) const_decl() {
2019-08-22 22:19:31 +02:00
if p.tok == .key_import {
p.error('`import const` was removed from the language, ' +
'use `foo(C.CONST_NAME)` instead')
2019-06-22 20:20:28 +02:00
}
2019-08-22 22:19:31 +02:00
p.inside_const = true
p.check(.key_const)
2019-06-22 20:20:28 +02:00
p.fspace()
p.check(.lpar)
2019-06-22 20:20:28 +02:00
p.fgenln('')
2019-08-17 21:19:37 +02:00
p.fmt_inc()
for p.tok == .name {
2019-06-22 20:20:28 +02:00
// `Age = 20`
mut name := p.check_name()
2019-07-29 18:21:36 +02:00
//if ! (name[0] >= `A` && name[0] <= `Z`) {
//p.error('const name must be capitalized')
//}
2019-08-22 22:19:31 +02:00
name = p.prepend_mod(name)
p.check_space(.assign)
typ := p.expression()
if p.first_pass() && p.table.known_const(name) {
2019-06-22 20:20:28 +02:00
p.error('redefinition of `$name`')
}
2019-08-22 22:19:31 +02:00
p.table.register_const(name, typ, p.mod)
if p.pass == .main {
2019-06-22 20:20:28 +02:00
// TODO hack
// cur_line has const's value right now. if it's just a number, then optimize generation:
// output a #define so that we don't pollute the binary with unnecessary global vars
if is_compile_time_const(p.cgen.cur_line) {
2019-08-17 21:19:37 +02:00
p.cgen.consts << '#define $name $p.cgen.cur_line'
p.cgen.resetln('')
2019-06-22 20:20:28 +02:00
p.fgenln('')
continue
}
if typ.starts_with('[') {
p.cgen.consts << p.table.cgen_name_type_pair(name, typ) +
' = $p.cgen.cur_line;'
}
else {
p.cgen.consts << p.table.cgen_name_type_pair(name, typ) + ';'
p.cgen.consts_init << '$name = $p.cgen.cur_line;'
}
p.cgen.resetln('')
2019-06-22 20:20:28 +02:00
}
p.fgenln('')
}
2019-08-17 21:19:37 +02:00
p.fmt_dec()
p.check(.rpar)
2019-06-22 20:20:28 +02:00
p.fgenln('\n')
p.inside_const = false
}
// `type myint int`
// `type onclickfn fn(voidptr) int`
fn (p mut Parser) type_decl() {
2019-07-16 12:17:17 +02:00
p.check(.key_type)
2019-06-22 20:20:28 +02:00
name := p.check_name()
2019-08-10 13:08:59 +02:00
// V used to have 'type Foo struct', many Go users might use this syntax
if p.tok == .key_struct {
p.error('use `struct $name {` instead of `type $name struct {`')
}
parent := p.get_type2()
nt_pair := p.table.cgen_name_type_pair(name, parent.name)
2019-06-22 20:20:28 +02:00
// TODO dirty C typedef hacks for DOOM
// Unknown type probably means it's a struct, and it's used before the struct is defined,
// so specify "struct"
_struct := if parent.cat != .array && parent.cat != .func &&
!p.table.known_type(parent.name) {
'struct'
} else {
''
}
p.gen_typedef('typedef $_struct $nt_pair; //type alias name="$name" parent=`$parent.name`')
p.register_type_with_parent(name, parent.name)
2019-06-22 20:20:28 +02:00
}
fn (p mut Parser) interface_method(field_name, receiver string) &Fn {
mut method := &Fn {
name: field_name
is_interface: true
is_method: true
receiver_typ: receiver
}
2019-07-29 18:21:36 +02:00
p.log('is interface. field=$field_name run=$p.pass')
p.fn_args(mut method)
if p.scanner.has_gone_over_line_end() {
method.typ = 'void'
} else {
method.typ = p.get_type()// method return type
p.fspace()
p.fgenln('')
}
return method
}
fn key_to_type_cat(tok Token) TypeCategory {
switch tok {
case Token.key_interface: return TypeCategory.interface_
case Token.key_struct: return TypeCategory.struct_
case Token.key_union: return TypeCategory.union_
//Token.key_ => return .interface_
}
2019-08-29 02:30:17 +02:00
cerror('Unknown token: $tok')
return TypeCategory.builtin
}
2019-06-22 20:20:28 +02:00
// also unions and interfaces
fn (p mut Parser) struct_decl() {
// V can generate Objective C for integration with Cocoa
// `[interface:ParentInterface]`
2019-08-28 16:35:44 +02:00
//is_objc := p.attr.starts_with('interface')
//objc_parent := if is_objc { p.attr.right(10) } else { '' }
// interface, union, struct
2019-08-17 21:19:37 +02:00
is_interface := p.tok == .key_interface
is_union := p.tok == .key_union
is_struct := p.tok == .key_struct
mut cat := key_to_type_cat(p.tok)
2019-06-22 20:20:28 +02:00
p.fgen(p.tok.str() + ' ')
// Get type name
p.next()
mut name := p.check_name()
if name.contains('_') && !p.pref.translated {
2019-06-22 20:20:28 +02:00
p.error('type names cannot contain `_`')
}
if is_interface && !name.ends_with('er') {
p.error('interface names temporarily have to end with `er` (e.g. `Speaker`, `Reader`)')
}
2019-08-17 21:19:37 +02:00
is_c := name == 'C' && p.tok == .dot
2019-06-22 20:20:28 +02:00
if is_c {
p.check(.dot)
2019-06-22 20:20:28 +02:00
name = p.check_name()
cat = .c_struct
if p.attr == 'typedef' {
cat = .c_typedef
}
2019-06-22 20:20:28 +02:00
}
2019-08-04 09:36:21 +02:00
if !is_c && !good_type_name(name) {
2019-08-17 21:19:37 +02:00
p.error('bad struct name, e.g. use `HttpRequest` instead of `HTTPRequest`')
}
2019-06-22 20:20:28 +02:00
// Specify full type name
if !is_c && !p.builtin_mod && p.mod != 'main' {
name = p.prepend_mod(name)
2019-06-22 20:20:28 +02:00
}
2019-08-25 23:08:06 +02:00
mut typ := p.table.find_type(name)
if p.pass == .decl && p.table.known_type_fast(typ) {
2019-06-22 20:20:28 +02:00
p.error('`$name` redeclared')
}
2019-08-28 16:35:44 +02:00
if !is_c {
kind := if is_union {'union'} else {'struct'}
p.gen_typedef('typedef $kind $name $name;')
2019-06-22 20:20:28 +02:00
}
// Register the type
mut is_ph := false
if typ.is_placeholder {
2019-08-31 15:38:13 +02:00
// Update the placeholder
2019-06-22 20:20:28 +02:00
is_ph = true
typ.name = name
typ.mod = p.mod
2019-06-22 20:20:28 +02:00
typ.is_c = is_c
typ.is_placeholder = false
typ.cat = cat
2019-08-31 15:38:13 +02:00
p.table.rewrite_type(typ)
2019-06-22 20:20:28 +02:00
}
else {
2019-08-31 15:38:13 +02:00
typ = Type {
2019-06-22 20:20:28 +02:00
name: name
mod: p.mod
2019-06-22 20:20:28 +02:00
is_c: is_c
cat: cat
2019-06-22 20:20:28 +02:00
}
}
// Struct `C.Foo` declaration, no body
if is_c && is_struct && p.tok != .lcbr {
2019-06-22 20:20:28 +02:00
p.table.register_type2(typ)
return
}
p.fgen(' ')
p.check(.lcbr)
2019-06-22 20:20:28 +02:00
// Struct fields
mut is_pub := false
mut is_mut := false
mut names := []string// to avoid dup names TODO alloc perf
2019-08-17 21:19:37 +02:00
/*
mut fmt_max_len := 0
2019-07-16 17:59:07 +02:00
for field in typ.fields {
if field.name.len > max_len {
2019-08-17 21:19:37 +02:00
fmt_max_len = field.name.len
}
}
println('fmt max len = $max_len nrfields=$typ.fields.len pass=$p.pass')
*/
2019-08-31 15:38:13 +02:00
if !is_ph && p.first_pass() {
p.table.register_type2(typ)
//println('registering 1 nrfields=$typ.fields.len')
}
mut did_gen_something := false
for p.tok != .rcbr {
if p.tok == .key_pub {
2019-06-22 20:20:28 +02:00
if is_pub {
p.error('structs can only have one `pub:`, all public fields have to be grouped')
}
is_pub = true
2019-08-17 21:19:37 +02:00
p.fmt_dec()
p.check(.key_pub)
if p.tok != .key_mut {
p.check(.colon)
2019-06-24 23:34:39 +02:00
}
2019-08-17 21:19:37 +02:00
p.fmt_inc()
2019-06-22 20:20:28 +02:00
p.fgenln('')
}
if p.tok == .key_mut {
2019-06-22 20:20:28 +02:00
if is_mut {
p.error('structs can only have one `mut:`, all private key_mut fields have to be grouped')
2019-06-22 20:20:28 +02:00
}
is_mut = true
2019-08-17 21:19:37 +02:00
p.fmt_dec()
p.check(.key_mut)
if p.tok != .key_mut {
p.check(.colon)
2019-06-24 23:34:39 +02:00
}
2019-08-17 21:19:37 +02:00
p.fmt_inc()
2019-06-22 20:20:28 +02:00
p.fgenln('')
}
// if is_pub {
// }
// (mut) user *User
// if p.tok == .plus {
2019-06-22 20:20:28 +02:00
// p.next()
// }
// Check if reserved name
field_name := if name != 'Option' { p.table.var_cgen_name(p.check_name()) } else { p.check_name() }
2019-06-22 20:20:28 +02:00
// Check dups
if field_name in names {
p.error('duplicate field `$field_name`')
}
2019-08-04 09:36:21 +02:00
if !is_c && p.mod != 'os' && contains_capital(field_name) {
2019-08-04 09:16:44 +02:00
p.error('struct fields cannot contain uppercase letters, use snake_case instead')
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
names << field_name
// We are in an interface?
// `run() string` => run is a method, not a struct field
2019-09-03 13:57:04 +02:00
if is_interface {
f := p.interface_method(field_name, name)
if p.first_pass() {
2019-09-18 14:37:34 +02:00
p.add_method(typ.name, f)
2019-09-03 13:57:04 +02:00
}
2019-06-22 20:20:28 +02:00
continue
}
// `pub` access mod
access_mod := if is_pub{AccessMod.public} else { AccessMod.private}
2019-06-22 20:20:28 +02:00
p.fgen(' ')
field_type := p.get_type()
is_atomic := p.tok == .key_atomic
2019-06-22 20:20:28 +02:00
if is_atomic {
p.next()
}
// [ATTR]
mut attr := ''
if p.tok == .lsbr {
2019-06-22 20:20:28 +02:00
p.next()
attr = p.check_name()
if p.tok == .colon {
p.check(.colon)
attr += ':' + p.check_name()
}
p.check(.rsbr)
2019-06-22 20:20:28 +02:00
}
if attr == 'raw' && field_type != 'string' {
p.error('struct field with attribute "raw" should be of type "string" but got "$field_type"')
}
did_gen_something = true
2019-08-31 15:38:13 +02:00
if p.first_pass() {
p.table.add_field(typ.name, field_name, field_type, is_mut, attr, access_mod)
}
2019-06-22 20:20:28 +02:00
p.fgenln('')
}
p.check(.rcbr)
if !is_c {
if !did_gen_something {
if p.first_pass() {
p.table.add_field(typ.name, '', 'EMPTY_STRUCT_DECLARATION', false, '', .private)
}
}
}
2019-06-22 20:20:28 +02:00
p.fgenln('\n')
}
fn (p mut Parser) enum_decl(_enum_name string) {
mut enum_name := _enum_name
// Specify full type name
if !p.builtin_mod && p.mod != 'main' {
enum_name = p.prepend_mod(enum_name)
2019-06-22 20:20:28 +02:00
}
// Skip empty enums
2019-08-27 01:48:55 +02:00
if enum_name != 'int' && !p.first_pass() {
p.cgen.typedefs << 'typedef int $enum_name;'
2019-06-22 20:20:28 +02:00
}
p.check(.lcbr)
2019-06-22 20:20:28 +02:00
mut val := 0
2019-08-17 21:19:37 +02:00
mut fields := []string
for p.tok == .name {
2019-06-22 20:20:28 +02:00
field := p.check_name()
2019-08-17 21:19:37 +02:00
fields << field
2019-06-22 20:20:28 +02:00
p.fgenln('')
2019-07-16 17:59:07 +02:00
name := '${p.mod}__${enum_name}_$field'
2019-07-29 18:21:36 +02:00
if p.pass == .main {
2019-08-17 21:19:37 +02:00
p.cgen.consts << '#define $name $val'
2019-06-22 20:20:28 +02:00
}
if p.tok == .comma {
2019-06-22 20:20:28 +02:00
p.next()
}
2019-08-22 22:19:31 +02:00
p.table.register_const(name, enum_name, p.mod)
2019-06-22 20:20:28 +02:00
val++
}
2019-08-31 15:38:13 +02:00
p.table.register_type2(Type {
name: enum_name
mod: p.mod
parent: 'int'
cat: TypeCategory.enum_
2019-09-08 01:53:33 +02:00
enum_vals: fields.clone()
})
p.check(.rcbr)
2019-06-22 20:20:28 +02:00
p.fgenln('\n')
}
// check_name checks for a name token and returns its literal
fn (p mut Parser) check_name() string {
name := p.lit
p.check(.name)
2019-06-22 20:20:28 +02:00
return name
}
fn (p mut Parser) check_string() string {
s := p.lit
2019-07-16 17:59:07 +02:00
p.check(.str)
2019-06-22 20:20:28 +02:00
return s
}
fn (p &Parser) strtok() string {
if p.tok == .name {
2019-06-22 20:20:28 +02:00
return p.lit
}
2019-07-16 17:59:07 +02:00
if p.tok == .str {
2019-06-22 20:20:28 +02:00
return '"$p.lit"'
}
res := p.tok.str()
if res == '' {
n := int(p.tok)
return n.str()
}
return res
}
2019-07-14 16:30:04 +02:00
// same as check(), but adds a space to the formatter output
2019-06-22 20:20:28 +02:00
// TODO bad name
fn (p mut Parser) check_space(expected Token) {
p.fspace()
p.check(expected)
p.fspace()
}
fn (p mut Parser) check(expected Token) {
if p.tok != expected {
println('check()')
s := 'expected `${expected.str()}` but got `${p.strtok()}`'
2019-06-22 20:20:28 +02:00
p.next()
println('next token = `${p.strtok()}`')
print_backtrace()
p.error(s)
}
if expected == .rcbr {
2019-08-17 21:19:37 +02:00
p.fmt_dec()
2019-06-22 20:20:28 +02:00
}
p.fgen(p.strtok())
// vfmt: increase indentation on `{` unless it's `{}`
if expected == .lcbr && p.scanner.pos + 1 < p.scanner.text.len && p.scanner.text[p.scanner.pos + 1] != `}` {
2019-06-22 20:20:28 +02:00
p.fgenln('')
2019-08-17 21:19:37 +02:00
p.fmt_inc()
2019-06-22 20:20:28 +02:00
}
p.next()
2019-07-16 17:59:07 +02:00
2019-08-17 21:19:37 +02:00
if p.scanner.line_comment != '' {
2019-07-16 17:59:07 +02:00
//p.fgenln('// ! "$p.scanner.line_comment"')
2019-08-17 21:19:37 +02:00
//p.scanner.line_comment = ''
}
2019-06-22 20:20:28 +02:00
}
fn (p &Parser) warn(s string) {
println('warning: $p.scanner.file_path:${p.scanner.line_nr+1}: $s')
2019-09-01 21:45:06 +02:00
}
fn (p mut Parser) error_with_position(e string, sp ScannerPos) {
p.scanner.goto_scanner_position( sp )
p.error( e )
}
fn (p mut Parser) production_error(e string, sp ScannerPos) {
if p.pref.is_prod {
p.scanner.goto_scanner_position( sp )
p.error( e )
}else {
// on a warning, restore the scanner state after printing the warning:
cpos := p.scanner.get_scanner_pos()
p.scanner.goto_scanner_position( sp )
p.warn(e)
p.scanner.goto_scanner_position( cpos )
}
}
2019-06-22 20:20:28 +02:00
fn (p mut Parser) error(s string) {
// Dump all vars and types for debugging
2019-07-29 18:21:36 +02:00
if p.pref.is_debug {
2019-06-22 20:20:28 +02:00
// os.write_to_file('/var/tmp/lang.types', '')//pes(p.table.types))
2019-08-17 21:19:37 +02:00
os.write_file('fns.txt', p.table.debug_fns())
2019-06-22 20:20:28 +02:00
}
2019-08-17 21:19:37 +02:00
if p.pref.is_verbose || p.pref.is_debug {
println('pass=$p.pass fn=`$p.cur_fn.name`\n')
}
2019-06-22 20:20:28 +02:00
p.cgen.save()
// V git pull hint
cur_path := os.getwd()
2019-08-10 23:02:48 +02:00
if !p.pref.is_repl && !p.pref.is_test && ( p.file_path.contains('v/compiler') || cur_path.contains('v/compiler') ){
2019-06-26 14:53:55 +02:00
println('\n=========================')
2019-08-17 21:19:37 +02:00
println('It looks like you are building V. It is being frequently updated every day.')
2019-08-31 15:38:13 +02:00
println('If you didn\'t modify V\'s code, most likely there was a change that ')
2019-06-26 14:53:55 +02:00
println('lead to this error.')
2019-08-31 15:38:13 +02:00
println('\nRun `v up`, that will most likely fix it.')
//println('\nIf this doesn\'t help, re-install V from source or download a precompiled' + ' binary from\nhttps://vlang.io.')
println('\nIf this doesn\'t help, please create a GitHub issue.')
2019-06-26 14:53:55 +02:00
println('=========================\n')
}
2019-08-31 15:38:13 +02:00
if p.pref.is_debug {
print_backtrace()
}
2019-06-22 20:20:28 +02:00
// p.scanner.debug_tokens()
// Print `[]int` instead of `array_int` in errors
2019-08-17 21:19:37 +02:00
p.scanner.error(s.replace('array_', '[]').replace('__', '.').replace('Option_', '?'))
2019-06-22 20:20:28 +02:00
}
2019-07-29 18:21:36 +02:00
fn (p &Parser) first_pass() bool {
return p.pass == .decl
2019-06-22 20:20:28 +02:00
}
// TODO return Type instead of string?
fn (p mut Parser) get_type() string {
mut mul := false
mut nr_muls := 0
mut typ := ''
2019-06-22 20:20:28 +02:00
// fn type
if p.tok == .func {
mut f := Fn{name: '_', mod: p.mod}
2019-06-22 20:20:28 +02:00
p.next()
line_nr := p.scanner.line_nr
p.fn_args(mut f)
// Same line, it's a return type
if p.scanner.line_nr == line_nr {
2019-08-17 21:19:37 +02:00
if p.tok == .name {
2019-07-16 14:31:08 +02:00
f.typ = p.get_type()
2019-08-17 21:19:37 +02:00
}
else {
2019-07-16 14:31:08 +02:00
f.typ = 'void'
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
// println('fn return typ=$f.typ')
}
else {
f.typ = 'void'
}
// Register anon fn type
fn_typ := Type {
name: f.typ_str()// 'fn (int, int) string'
mod: p.mod
2019-06-22 20:20:28 +02:00
func: f
}
p.table.register_type2(fn_typ)
return f.typ_str()
}
// arrays ([]int)
mut is_arr := false
mut is_arr2 := false// [][]int TODO remove this and allow unlimited levels of arrays
is_question := p.tok == .question
2019-06-22 20:20:28 +02:00
if is_question {
p.check(.question)
2019-06-22 20:20:28 +02:00
}
if p.tok == .lsbr {
p.check(.lsbr)
2019-06-22 20:20:28 +02:00
// [10]int
2019-07-24 00:06:48 +02:00
if p.tok == .number {
2019-06-22 20:20:28 +02:00
typ = '[$p.lit]'
p.next()
}
else {
is_arr = true
}
p.check(.rsbr)
2019-06-22 20:20:28 +02:00
// [10][3]int
if p.tok == .lsbr {
2019-06-22 20:20:28 +02:00
p.next()
2019-07-24 00:06:48 +02:00
if p.tok == .number {
2019-06-22 20:20:28 +02:00
typ += '[$p.lit]'
2019-07-24 00:06:48 +02:00
p.check(.number)
2019-06-22 20:20:28 +02:00
}
else {
is_arr2 = true
}
p.check(.rsbr)
2019-06-22 20:20:28 +02:00
}
}
2019-08-17 21:19:37 +02:00
// map[string]int
if !p.builtin_mod && p.tok == .name && p.lit == 'map' {
p.next()
2019-08-17 21:19:37 +02:00
p.check(.lsbr)
key_type := p.check_name()
if key_type != 'string' {
2019-08-17 21:19:37 +02:00
p.error('maps only support string keys for now')
}
p.check(.rsbr)
val_type := p.get_type()// p.check_name()
typ = 'map_$val_type'
p.register_map(typ)
2019-08-17 21:19:37 +02:00
return typ
}
//
mut warn := false
for p.tok == .mul {
2019-09-01 21:51:16 +02:00
if p.first_pass() {
warn = true
2019-09-01 21:51:16 +02:00
}
2019-06-22 20:20:28 +02:00
mul = true
nr_muls++
2019-08-17 21:19:37 +02:00
p.check(.mul)
2019-06-22 20:20:28 +02:00
}
if p.tok == .amp {
2019-06-22 20:20:28 +02:00
mul = true
nr_muls++
2019-08-17 21:19:37 +02:00
p.check(.amp)
2019-06-22 20:20:28 +02:00
}
typ += p.lit
if !p.is_struct_init {
// Otherwise we get `foo := FooFoo{` because `Foo` was already
// generated in name_expr()
2019-06-22 20:20:28 +02:00
p.fgen(p.lit)
}
// C.Struct import
if p.lit == 'C' && p.peek() == .dot {
2019-06-22 20:20:28 +02:00
p.next()
p.check(.dot)
2019-06-22 20:20:28 +02:00
typ = p.lit
}
else {
if warn {
p.warn('use `&Foo` instead of `*Foo`')
}
// Module specified? (e.g. gx.Image)
if p.peek() == .dot {
// try resolve full submodule
if !p.builtin_mod && p.import_table.known_alias(typ) {
mod := p.import_table.resolve_alias(typ)
if mod.contains('.') {
typ = mod.replace('.', '_dot_')
}
}
2019-06-22 20:20:28 +02:00
p.next()
p.check(.dot)
2019-06-22 20:20:28 +02:00
typ += '__$p.lit'
}
mut t := p.table.find_type(typ)
if typ == 'V' {
//println('QQ V res=$t.name')
}
// "typ" not found? try "mod__typ"
if t.name == '' && !p.builtin_mod {
2019-07-29 18:21:36 +02:00
// && !p.first_pass() {
if !typ.contains('array_') && p.mod != 'main' && !typ.contains('__') &&
2019-08-17 21:19:37 +02:00
!typ.starts_with('[') {
typ = p.prepend_mod(typ)
2019-06-22 20:20:28 +02:00
}
t = p.table.find_type(typ)
2019-07-29 18:21:36 +02:00
if t.name == '' && !p.pref.translated && !p.first_pass() && !typ.starts_with('[') {
2019-06-22 20:20:28 +02:00
println('get_type() bad type')
// println('all registered types:')
// for q in p.table.types {
// println(q.name)
// }
p.error('unknown type `$typ`')
}
}
}
if typ == 'void' {
p.error('unknown type `$typ`')
}
if mul {
typ += strings.repeat(`*`, nr_muls)
2019-06-22 20:20:28 +02:00
}
// Register an []array type
if is_arr2 {
typ = 'array_array_$typ'
p.register_array(typ)
}
else if is_arr {
typ = 'array_$typ'
2019-07-29 18:21:36 +02:00
// p.log('ARR TYPE="$typ" run=$p.pass')
2019-06-22 20:20:28 +02:00
// We come across "[]User" etc ?
p.register_array(typ)
}
p.next()
if p.tok == .question || is_question {
2019-06-22 20:20:28 +02:00
typ = 'Option_$typ'
p.table.register_type_with_parent(typ, 'Option')
if p.tok == .question {
2019-06-22 20:20:28 +02:00
p.next()
}
}
// Because the code uses * to see if it's a pointer
if typ == 'byteptr' {
return 'byte*'
}
if typ == 'voidptr' {
//if !p.builtin_mod && p.mod != 'os' && p.mod != 'gx' && p.mod != 'gg' && !p.pref.translated {
2019-06-22 20:20:28 +02:00
//p.error('voidptr can only be used in unsafe code')
//}
return 'void*'
}
if typ.last_index('__') > typ.index('__') {
p.error('2 __ in gettype(): typ="$typ"')
}
return typ
}
fn (p &Parser) print_tok() {
if p.tok == .name {
2019-06-22 20:20:28 +02:00
println(p.lit)
return
}
2019-07-16 17:59:07 +02:00
if p.tok == .str {
2019-06-22 20:20:28 +02:00
println('"$p.lit"')
return
}
println(p.tok.str())
}
// statements() returns the type of the last statement
fn (p mut Parser) statements() string {
p.log('statements()')
2019-07-24 02:35:25 +02:00
typ := p.statements_no_rcbr()
2019-06-22 20:20:28 +02:00
if !p.inside_if_expr {
p.genln('}')
}
2019-07-24 02:35:25 +02:00
//if p.fileis('if_expr') {
//println('statements() ret=$typ line=$p.scanner.line_nr')
//}
2019-06-22 20:20:28 +02:00
return typ
}
2019-07-24 02:35:25 +02:00
fn (p mut Parser) statements_no_rcbr() string {
p.open_scope()
2019-08-26 23:39:11 +02:00
2019-06-22 20:20:28 +02:00
if !p.inside_if_expr {
p.genln('')
}
mut i := 0
mut last_st_typ := ''
2019-08-17 21:19:37 +02:00
for p.tok != .rcbr && p.tok != .eof && p.tok != .key_case &&
2019-07-17 01:43:59 +02:00
p.tok != .key_default && p.peek() != .arrow {
2019-06-22 20:20:28 +02:00
// println(p.tok.str())
// p.print_tok()
last_st_typ = p.statement(true)
// println('last st typ=$last_st_typ')
if !p.inside_if_expr {
p.genln('')// // end st tok= ${p.strtok()}')
p.fgenln('')
}
i++
if i > 50000 {
p.cgen.save()
p.error('more than 50 000 statements in function `$p.cur_fn.name`')
}
}
2019-07-17 01:43:59 +02:00
if p.tok != .key_case && p.tok != .key_default && p.peek() != .arrow {
2019-06-22 20:20:28 +02:00
// p.next()
p.check(.rcbr)
2019-06-22 20:20:28 +02:00
}
else {
// p.check(.rcbr)
2019-06-22 20:20:28 +02:00
}
2019-08-17 21:19:37 +02:00
//p.fmt_dec()
2019-06-22 20:20:28 +02:00
// println('close scope line=$p.scanner.line_nr')
2019-08-26 23:39:11 +02:00
p.close_scope()
2019-06-22 20:20:28 +02:00
return last_st_typ
}
fn (p mut Parser) close_scope() {
// println('close_scope level=$f.scope_level var_idx=$f.var_idx')
2019-09-08 17:53:40 +02:00
// Move back `var_idx` (pointer to the end of the array) till we reach
// the previous scope level. This effectivly deletes (closes) current
// scope.
mut i := p.cur_fn.var_idx - 1
2019-08-02 05:20:18 +02:00
for ; i >= 0; i-- {
v := p.cur_fn.local_vars[i]
//if p.cur_fn.name == 'main' {
//println('var in main $v.name $v.typ $v.is_alloc ptr=$v.ptr')
//}
2019-08-31 04:03:38 +02:00
if v.scope_level p.cur_fn.scope_level {
// println('breaking. "$v.name" v.scope_level=$v.scope_level')
break
}
2019-09-14 17:54:55 +02:00
// Clean up memory, only do this if -autofree was passed for now
if p.pref.autofree && v.is_alloc && !p.pref.is_test {
mut free_fn := 'free'
2019-08-17 21:19:37 +02:00
if v.typ.starts_with('array_') {
free_fn = 'v_array_free'
} else if v.typ == 'string' {
free_fn = 'v_string_free'
2019-09-19 16:25:00 +02:00
continue
} else if v.ptr || v.typ.ends_with('*') {
free_fn = 'v_ptr_free'
//continue
} else {
continue
}
//if false && p.returns {
if p.returns {
if !v.is_returned && v.typ != 'FILE*' { //!v.is_c {
prev_line := p.cgen.lines[p.cgen.lines.len-2]
p.cgen.lines[p.cgen.lines.len-2] =
'$free_fn($v.name); /* :) close_scope free $v.typ */' + prev_line
2019-09-08 17:53:40 +02:00
}
} else {
p.genln('$free_fn($v.name); // close_scope free')
2019-08-17 21:19:37 +02:00
}
}
}
if p.cur_fn.defer_text.last() != '' {
p.genln(p.cur_fn.defer_text.last())
//p.cur_fn.defer_text[f] = ''
}
p.cur_fn.scope_level--
p.cur_fn.defer_text = p.cur_fn.defer_text.left(p.cur_fn.scope_level + 1)
p.cur_fn.var_idx = i + 1
// println('close_scope new var_idx=$f.var_idx\n')
}
2019-06-22 20:20:28 +02:00
fn (p mut Parser) genln(s string) {
p.cgen.genln(s)
}
fn (p mut Parser) gen(s string) {
p.cgen.gen(s)
}
// Generate V header from V source
fn (p mut Parser) vh_genln(s string) {
p.vh_lines << s
}
fn (p mut Parser) statement(add_semi bool) string {
2019-08-12 16:21:56 +02:00
if p.returns && !p.is_vweb {
p.error('unreachable code')
}
2019-06-22 20:20:28 +02:00
p.cgen.is_tmp = false
tok := p.tok
mut q := ''
switch tok {
case .name:
2019-06-22 20:20:28 +02:00
next := p.peek()
if p.pref.is_verbose {
2019-06-22 20:20:28 +02:00
println(next.str())
}
// goto_label:
if p.peek() == .colon {
2019-06-22 20:20:28 +02:00
p.fmt_dec()
label := p.check_name()
p.fmt_inc()
p.genln(label + ':')
p.check(.colon)
2019-06-22 20:20:28 +02:00
return ''
}
2019-08-17 21:19:37 +02:00
// `a := 777`
else if p.peek() == .decl_assign {
2019-06-22 20:20:28 +02:00
p.var_decl()
}
else {
// panic and exit count as returns since they stop the function
if p.lit == 'panic' || p.lit == 'exit' {
p.returns = true
}
// `a + 3`, `a(7)`, or just `a`
2019-06-22 20:20:28 +02:00
q = p.bool_expression()
}
case Token.key_goto:
p.check(.key_goto)
2019-06-22 20:20:28 +02:00
p.fgen(' ')
label := p.check_name()
p.genln('goto $label;')
return ''
2019-07-15 22:09:34 +02:00
case Token.key_defer:
p.defer_st()
return ''
case Token.hash:
2019-06-22 20:20:28 +02:00
p.chash()
return ''
case Token.dollar:
2019-06-22 20:20:28 +02:00
p.comp_time()
case Token.key_if:
p.if_st(false, 0)
case Token.key_for:
2019-06-22 20:20:28 +02:00
p.for_st()
2019-08-26 23:39:11 +02:00
case Token.key_switch:
2019-06-22 20:20:28 +02:00
p.switch_statement()
2019-08-26 23:39:11 +02:00
case Token.key_match:
p.match_statement(false)
case Token.key_mut, Token.key_static:
2019-06-22 20:20:28 +02:00
p.var_decl()
case Token.key_return:
2019-06-22 20:20:28 +02:00
p.return_st()
case Token.lcbr:// {} block
2019-08-17 21:19:37 +02:00
p.check(.lcbr)
2019-06-22 20:20:28 +02:00
p.genln('{')
p.statements()
return ''
case Token.key_continue:
2019-06-22 20:20:28 +02:00
if p.for_expr_cnt == 0 {
p.error('`continue` statement outside `for`')
}
p.genln('continue')
2019-08-17 21:19:37 +02:00
p.check(.key_continue)
case Token.key_break:
2019-06-22 20:20:28 +02:00
if p.for_expr_cnt == 0 {
p.error('`break` statement outside `for`')
}
p.genln('break')
2019-08-17 21:19:37 +02:00
p.check(.key_break)
case Token.key_go:
2019-06-22 20:20:28 +02:00
p.go_statement()
case Token.key_assert:
2019-06-22 20:20:28 +02:00
p.assert_statement()
default:
// An expression as a statement
typ := p.expression()
if p.inside_if_expr {
}
else {
p.genln('; ')
}
return typ
}
// ? : uses , as statement separators
if p.inside_if_expr && p.tok != .rcbr {
2019-06-22 20:20:28 +02:00
p.gen(', ')
}
if add_semi && !p.inside_if_expr {
p.genln(';')
}
return q
// p.cgen.end_statement()
}
// is_map: are we in map assignment? (m[key] = val) if yes, dont generate '='
// this can be `user = ...` or `user.field = ...`, in both cases `v` is `user`
fn (p mut Parser) assign_statement(v Var, ph int, is_map bool) {
//p.log('assign_statement() name=$v.name tok=')
2019-08-17 21:19:37 +02:00
is_vid := p.fileis('vid') // TODO remove
2019-06-22 20:20:28 +02:00
tok := p.tok
//if !v.is_mut && !v.is_arg && !p.pref.translated && !v.is_global{
2019-08-07 13:00:19 +02:00
if !v.is_mut && !p.pref.translated && !v.is_global && !is_vid {
if v.is_arg {
if p.cur_fn.args.len > 0 && p.cur_fn.args[0].name == v.name {
println('make the receiver `$v.name` mutable:
2019-08-17 21:19:37 +02:00
fn ($v.name mut $v.typ) $p.cur_fn.name (...) {
')
}
}
p.error('`$v.name` is immutable.')
2019-06-22 20:20:28 +02:00
}
if !v.is_changed {
p.mark_var_changed(v)
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
is_str := v.typ == 'string'
is_ustr := v.typ == 'ustring'
2019-06-22 20:20:28 +02:00
switch tok {
case Token.assign:
if !is_map && !p.is_empty_c_struct_init {
2019-06-22 20:20:28 +02:00
p.gen(' = ')
}
case Token.plus_assign:
2019-09-14 22:48:30 +02:00
if is_str && !p.is_js {
2019-06-22 20:20:28 +02:00
p.gen('= string_add($v.name, ')// TODO can't do `foo.bar += '!'`
}
else if is_ustr {
p.gen('= ustring_add($v.name, ')
}
2019-07-03 13:20:43 +02:00
else {
2019-06-22 20:20:28 +02:00
p.gen(' += ')
}
2019-07-03 13:20:43 +02:00
default: p.gen(' ' + p.tok.str() + ' ')
2019-06-22 20:20:28 +02:00
}
2019-07-03 13:20:43 +02:00
p.fspace()
2019-08-17 21:19:37 +02:00
p.fgen(tok.str())
2019-07-03 13:20:43 +02:00
p.fspace()
2019-06-22 20:20:28 +02:00
p.next()
pos := p.cgen.cur_line.len
expr_type := p.bool_expression()
//if p.expected_type.starts_with('array_') {
//p.warn('expecting array got $expr_type')
//}
2019-06-22 20:20:28 +02:00
// Allow `num = 4` where `num` is an `?int`
if p.assigned_type.starts_with('Option_') &&
expr_type == p.assigned_type.right('Option_'.len) {
2019-06-22 20:20:28 +02:00
expr := p.cgen.cur_line.right(pos)
left := p.cgen.cur_line.left(pos)
2019-08-17 21:19:37 +02:00
typ := expr_type.replace('Option_', '')
p.cgen.resetln(left + 'opt_ok($expr, sizeof($typ))')
2019-06-22 20:20:28 +02:00
}
else if !p.builtin_mod && !p.check_types_no_throw(expr_type, p.assigned_type) {
2019-06-22 20:20:28 +02:00
p.scanner.line_nr--
p.error('cannot use type `$expr_type` as type `$p.assigned_type` in assignment')
}
if (is_str || is_ustr) && tok == .plus_assign && !p.is_js {
2019-06-22 20:20:28 +02:00
p.gen(')')
}
// p.assigned_var = ''
p.assigned_type = ''
if !v.is_used {
p.mark_var_used(v)
2019-06-22 20:20:28 +02:00
}
}
fn (p mut Parser) var_decl() {
2019-08-17 21:19:37 +02:00
p.is_alloc = false
is_mut := p.tok == .key_mut || p.prev_tok == .key_for
is_static := p.tok == .key_static
if p.tok == .key_mut {
p.check(.key_mut)
2019-06-22 20:20:28 +02:00
p.fspace()
}
if p.tok == .key_static {
p.check(.key_static)
2019-06-22 20:20:28 +02:00
p.fspace()
}
// println('var decl tok=${p.strtok()} ismut=$is_mut')
var_scanner_pos := p.scanner.get_scanner_pos()
2019-06-22 20:20:28 +02:00
name := p.check_name()
2019-08-17 21:19:37 +02:00
p.var_decl_name = name
2019-06-22 20:20:28 +02:00
// Don't allow declaring a variable with the same name. Even in a child scope
// (shadowing is not allowed)
if !p.builtin_mod && p.cur_fn.known_var(name) {
2019-06-22 20:20:28 +02:00
v := p.cur_fn.find_var(name)
p.error('redefinition of `$name`')
}
2019-07-15 22:44:26 +02:00
if name.len > 1 && contains_capital(name) {
p.error('variable names cannot contain uppercase letters, use snake_case instead')
}
2019-08-17 21:19:37 +02:00
p.check_space(.decl_assign) // :=
2019-09-14 22:48:30 +02:00
typ := p.gen_var_decl(name, is_static)
2019-06-22 20:20:28 +02:00
p.register_var(Var {
name: name
typ: typ
is_mut: is_mut
is_alloc: p.is_alloc || typ.starts_with('array_')
scanner_pos: var_scanner_pos
line_nr: var_scanner_pos.line_nr
2019-06-22 20:20:28 +02:00
})
//if p.is_alloc { println('REG VAR IS ALLOC $name') }
2019-08-17 21:19:37 +02:00
p.var_decl_name = ''
p.is_empty_c_struct_init = false
2019-06-22 20:20:28 +02:00
}
const (
and_or_error = 'use `()` to make the boolean expression clear\n' +
'for example: `(a && b) || c` instead of `a && b || c`'
2019-08-17 21:19:37 +02:00
)
2019-06-22 20:20:28 +02:00
fn (p mut Parser) bool_expression() string {
tok := p.tok
typ := p.bterm()
2019-08-17 21:19:37 +02:00
mut got_and := false // to catch `a && b || c` in one expression without ()
mut got_or := false
2019-07-14 11:01:32 +02:00
for p.tok == .and || p.tok == .logical_or {
if p.tok == .and {
2019-08-17 21:19:37 +02:00
got_and = true
if got_or { p.error(and_or_error) }
}
if p.tok == .logical_or {
2019-08-17 21:19:37 +02:00
got_or = true
if got_and { p.error(and_or_error) }
}
2019-08-09 18:10:59 +02:00
if p.is_sql {
if p.tok == .and {
2019-08-17 21:19:37 +02:00
p.gen(' and ')
}
2019-08-09 18:10:59 +02:00
else if p.tok == .logical_or {
2019-08-17 21:19:37 +02:00
p.gen(' or ')
}
} else {
2019-08-09 18:10:59 +02:00
p.gen(' ${p.tok.str()} ')
2019-08-17 21:19:37 +02:00
}
p.check_space(p.tok)
2019-06-22 20:20:28 +02:00
p.check_types(p.bterm(), typ)
}
if typ == '' {
println('curline:')
println(p.cgen.cur_line)
println(tok.str())
p.error('expr() returns empty type')
}
return typ
}
fn (p mut Parser) bterm() string {
ph := p.cgen.add_placeholder()
mut typ := p.expression()
2019-08-17 21:19:37 +02:00
p.expected_type = typ
is_str := typ=='string' && !p.is_sql
is_ustr := typ=='ustring'
2019-06-22 20:20:28 +02:00
tok := p.tok
// if tok in [ .eq, .gt, .lt, .le, .ge, .ne] {
if tok == .eq || tok == .gt || tok == .lt || tok == .le || tok == .ge || tok == .ne {
2019-06-22 20:20:28 +02:00
p.fgen(' ${p.tok.str()} ')
if (is_str || is_ustr) && !p.is_js {
2019-06-22 20:20:28 +02:00
p.gen(',')
}
2019-08-09 18:10:59 +02:00
else if p.is_sql && tok == .eq {
2019-08-17 21:19:37 +02:00
p.gen('=')
}
2019-06-22 20:20:28 +02:00
else {
p.gen(tok.str())
}
p.next()
2019-08-17 21:19:37 +02:00
// `id == user.id` => `id == $1`, `user.id`
2019-08-13 13:50:19 +02:00
if p.is_sql {
2019-08-17 21:19:37 +02:00
p.sql_i++
p.gen('$' + p.sql_i.str())
p.cgen.start_cut()
2019-08-13 13:50:19 +02:00
p.check_types(p.expression(), typ)
sql_param := p.cgen.cut()
p.sql_params << sql_param
p.sql_types << typ
//println('*** sql type: $typ | param: $sql_param')
2019-08-17 21:19:37 +02:00
} else {
2019-08-13 13:50:19 +02:00
p.check_types(p.expression(), typ)
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
typ = 'bool'
2019-09-14 22:48:30 +02:00
if is_str && !p.is_js { //&& !p.is_sql {
2019-06-22 22:12:38 +02:00
p.gen(')')
2019-06-22 20:20:28 +02:00
switch tok {
case Token.eq: p.cgen.set_placeholder(ph, 'string_eq(')
case Token.ne: p.cgen.set_placeholder(ph, 'string_ne(')
case Token.le: p.cgen.set_placeholder(ph, 'string_le(')
case Token.ge: p.cgen.set_placeholder(ph, 'string_ge(')
case Token.gt: p.cgen.set_placeholder(ph, 'string_gt(')
case Token.lt: p.cgen.set_placeholder(ph, 'string_lt(')
2019-06-22 20:20:28 +02:00
}
2019-08-17 21:19:37 +02:00
/*
2019-07-17 10:54:24 +02:00
Token.eq => p.cgen.set_placeholder(ph, 'string_eq(')
Token.ne => p.cgen.set_placeholder(ph, 'string_ne(')
Token.le => p.cgen.set_placeholder(ph, 'string_le(')
Token.ge => p.cgen.set_placeholder(ph, 'string_ge(')
Token.gt => p.cgen.set_placeholder(ph, 'string_gt(')
Token.lt => p.cgen.set_placeholder(ph, 'string_lt(')
2019-08-17 21:19:37 +02:00
*/
2019-06-22 20:20:28 +02:00
}
if is_ustr {
p.gen(')')
switch tok {
case Token.eq: p.cgen.set_placeholder(ph, 'ustring_eq(')
case Token.ne: p.cgen.set_placeholder(ph, 'ustring_ne(')
case Token.le: p.cgen.set_placeholder(ph, 'ustring_le(')
case Token.ge: p.cgen.set_placeholder(ph, 'ustring_ge(')
case Token.gt: p.cgen.set_placeholder(ph, 'ustring_gt(')
case Token.lt: p.cgen.set_placeholder(ph, 'ustring_lt(')
}
}
2019-06-22 20:20:28 +02:00
}
return typ
}
2019-08-17 21:19:37 +02:00
// also called on *, &, @, . (enum)
2019-06-22 20:20:28 +02:00
fn (p mut Parser) name_expr() string {
p.has_immutable_field = false
2019-07-06 02:22:29 +02:00
ph := p.cgen.add_placeholder()
2019-06-22 20:20:28 +02:00
// amp
ptr := p.tok == .amp
deref := p.tok == .mul
2019-06-22 20:20:28 +02:00
if ptr || deref {
p.next()
}
mut name := p.lit
p.fgen(name)
// known_type := p.table.known_type(name)
orig_name := name
2019-08-17 21:19:37 +02:00
is_c := name == 'C' && p.peek() == .dot
2019-06-22 20:20:28 +02:00
mut is_c_struct_init := is_c && ptr// a := &C.mycstruct{}
if is_c {
p.next()
p.check(.dot)
2019-06-22 20:20:28 +02:00
name = p.lit
p.fgen(name)
// Currently struct init is set to true only we have `&C.Foo{}`, handle `C.Foo{}`:
if !is_c_struct_init && p.peek() == .lcbr {
2019-06-22 20:20:28 +02:00
is_c_struct_init = true
}
}
2019-08-17 21:19:37 +02:00
// enum value? (`color == .green`)
if p.tok == .dot {
2019-08-17 21:19:37 +02:00
//println('got enum dot val $p.left_type pass=$p.pass $p.scanner.line_nr left=$p.left_type')
T := p.find_type(p.expected_type)
if T.cat == .enum_ {
2019-08-17 21:19:37 +02:00
p.check(.dot)
val := p.check_name()
// Make sure this enum value exists
if !T.has_enum_val(val) {
2019-08-17 21:19:37 +02:00
p.error('enum `$T.name` does not have value `$val`')
}
p.gen(T.mod + '__' + p.expected_type + '_' + val)
}
return p.expected_type
}
2019-06-22 20:20:28 +02:00
// //////////////////////////
// module ?
2019-08-25 23:08:06 +02:00
// (Allow shadowing `gg = gg.newcontext(); gg.draw_triangle();` )
if p.peek() == .dot && ((name == p.mod && p.table.known_mod(name)) || p.import_table.known_alias(name))
2019-07-12 07:37:54 +02:00
&& !p.cur_fn.known_var(name) && !is_c {
mut mod := name
2019-07-12 07:37:54 +02:00
// must be aliased module
if name != p.mod && p.import_table.known_alias(name) {
2019-07-13 15:11:32 +02:00
// we replaced "." with "_dot_" in p.mod for C variable names, do same here.
mod = p.import_table.resolve_alias(name).replace('.', '_dot_')
2019-07-12 07:37:54 +02:00
}
2019-06-22 20:20:28 +02:00
p.next()
p.check(.dot)
2019-06-22 20:20:28 +02:00
name = p.lit
p.fgen(name)
name = prepend_mod(mod, name)
2019-06-22 20:20:28 +02:00
}
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_mod(name)
2019-06-22 20:20:28 +02:00
}
// Variable
for { // TODO remove
mut v := p.find_var_check_new_var(name) or { break }
if ptr {
2019-09-18 14:06:34 +02:00
p.gen('& /*v*/ ')
}
else if deref {
p.gen('*')
}
mut typ := p.var_expr(v)
// *var
if deref {
if !typ.contains('*') && !typ.ends_with('ptr') {
println('name="$name", t=$v.typ')
p.error('dereferencing requires a pointer, but got `$typ`')
}
typ = typ.replace('ptr', '')// TODO
typ = typ.replace('*', '')// TODO
}
// &var
else if ptr {
typ += '*'
}
if p.inside_return_expr {
//println('marking $v.name returned')
p.mark_var_returned(v)
// v.is_returned = true // TODO modifying a local variable
// that's not used afterwards, this should be a compilation
// error
}
return typ
} // TODO REMOVE for{}
2019-07-29 18:21:36 +02:00
// if known_type || is_c_struct_init || (p.first_pass() && p.peek() == .lcbr) {
2019-06-22 20:20:28 +02:00
// known type? int(4.5) or Color.green (enum)
if p.table.known_type(name) {
// float(5), byte(0), (*int)(ptr) etc
if !is_c && ( p.peek() == .lpar || (deref && p.peek() == .rpar) ) {
2019-06-22 20:20:28 +02:00
if deref {
name += '*'
}
else if ptr {
name += '*'
}
p.gen('(')
2019-09-14 22:48:30 +02:00
mut typ := name
p.cast(name)
2019-06-22 20:20:28 +02:00
p.gen(')')
for p.tok == .dot {
2019-07-06 02:22:29 +02:00
typ = p.dot(typ, ph)
2019-06-22 20:20:28 +02:00
}
return typ
}
// Color.green
else if p.peek() == .dot {
2019-06-22 20:20:28 +02:00
enum_type := p.table.find_type(name)
if enum_type.cat != .enum_ {
2019-06-22 20:20:28 +02:00
p.error('`$name` is not an enum')
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
p.next()
p.check(.dot)
2019-06-22 20:20:28 +02:00
val := p.lit
// println('enum val $val')
p.gen(enum_type.mod + '__' + enum_type.name + '_' + val)// `color = main__Color_green`
2019-06-22 20:20:28 +02:00
p.next()
return enum_type.name
}
// struct initialization
else if p.peek() == .lcbr {
2019-07-29 18:21:36 +02:00
if ptr {
name += '*' // `&User{}` => type `User*`
}
if name == 'T' {
2019-08-17 21:19:37 +02:00
name = p.cur_gen_type
}
2019-09-14 22:48:30 +02:00
p.is_c_struct_init = is_c_struct_init
return p.struct_init(name)
2019-06-22 20:20:28 +02:00
}
}
if is_c {
2019-08-17 21:19:37 +02:00
// C const (`C.GLFW_KEY_LEFT`)
if p.peek() != .lpar {
2019-08-17 21:19:37 +02:00
p.gen(name)
p.next()
return 'int'
}
2019-09-18 14:06:34 +02:00
// C function
2019-06-22 20:20:28 +02:00
f := Fn {
2019-09-18 14:06:34 +02:00
name: name
2019-06-22 20:20:28 +02:00
is_c: true
}
p.is_c_fn_call = true
2019-06-22 20:20:28 +02:00
p.fn_call(f, 0, '', '')
p.is_c_fn_call = false
2019-06-22 20:20:28 +02:00
// Try looking it up. Maybe its defined with "C.fn_name() fn_type",
// then we know what type it returns
2019-09-18 14:06:34 +02:00
cfn := p.table.find_fn(name) or {
// Not Found? Return 'void*'
//return 'cvoid' //'void*'
if false {
p.warn('\ndefine imported C function with ' +
'`fn C.$name([args]) [return_type]`\n')
}
2019-06-22 20:20:28 +02:00
return 'void*'
}
return cfn.typ
}
// Constant
2019-09-19 13:19:44 +02:00
for {
c := p.table.find_const(name) or { break }
if ptr && !c.is_global {
p.error('cannot take the address of constant `$c.name`')
} else if ptr && c.is_global {
2019-06-22 20:20:28 +02:00
// c.ptr = true
p.gen('& /*const*/ ')
}
mut typ := p.var_expr(c)
if ptr {
typ += '*'
}
return typ
}
// Function (not method btw, methods are handled in dot())
2019-09-18 14:06:34 +02:00
mut f := p.table.find_fn(name) or {
// We are in the second pass, that means this function was not defined, throw an error.
2019-07-29 18:21:36 +02:00
if !p.first_pass() {
2019-08-17 21:19:37 +02:00
// V script? Try os module.
2019-09-18 14:06:34 +02:00
// TODO
2019-08-17 21:19:37 +02:00
if p.v_script {
2019-09-18 14:06:34 +02:00
//name = name.replace('main__', 'os__')
//f = p.table.find_fn(name)
}
// check for misspelled function / variable / module
suggested := p.table.identify_typo(name, p.cur_fn, p.import_table)
if suggested != '' {
p.error('undefined: `$name`. did you mean:$suggested')
}
// 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`')
}
else {
if orig_name == 'i32' {
println('`i32` alias was removed, use `int` instead')
2019-07-17 10:54:24 +02:00
}
2019-09-18 14:06:34 +02:00
if orig_name == 'u8' {
println('`u8` alias was removed, use `byte` instead')
2019-07-17 10:54:24 +02:00
}
2019-09-18 14:06:34 +02:00
p.error('undefined: `$orig_name`')
2019-08-17 21:19:37 +02:00
}
} else {
2019-07-17 10:54:24 +02:00
p.next()
2019-08-17 21:19:37 +02:00
// First pass, the function can be defined later.
2019-07-17 10:54:24 +02:00
return 'void'
2019-08-17 21:19:37 +02:00
}
2019-09-18 14:06:34 +02:00
return 'void'
2019-06-22 20:20:28 +02:00
}
// no () after func, so func is an argument, just gen its name
// TODO verify this and handle errors
2019-08-17 21:19:37 +02:00
peek := p.peek()
2019-07-29 18:21:36 +02:00
if peek != .lpar && peek != .lt {
2019-09-05 11:09:41 +02:00
// Register anon fn type
fn_typ := Type {
name: f.typ_str()// 'fn (int, int) string'
mod: p.mod
func: f
}
p.table.register_type2(fn_typ)
2019-09-14 22:48:30 +02:00
p.gen(p.table.fn_gen_name(f))
2019-06-22 20:20:28 +02:00
p.next()
2019-09-05 11:09:41 +02:00
return f.typ_str() //'void*'
2019-06-22 20:20:28 +02:00
}
// TODO bring back
if f.typ == 'void' && !p.inside_if_expr {
// p.error('`$f.name` used as value')
}
p.log('calling function')
p.fn_call(f, 0, '', '')
// dot after a function call: `get_user().age`
if p.tok == .dot {
2019-06-22 20:20:28 +02:00
mut typ := ''
for p.tok == .dot {
2019-06-22 20:20:28 +02:00
// println('dot #$dc')
2019-07-06 02:22:29 +02:00
typ = p.dot(f.typ, ph)
2019-06-22 20:20:28 +02:00
}
return typ
}
p.log('end of name_expr')
if f.typ.ends_with('*') {
p.is_alloc = true
}
2019-06-22 20:20:28 +02:00
return f.typ
}
fn (p mut Parser) var_expr(v Var) string {
p.log('\nvar_expr() v.name="$v.name" v.typ="$v.typ"')
// println('var expr is_tmp=$p.cgen.is_tmp\n')
p.mark_var_used(v)
2019-06-22 20:20:28 +02:00
fn_ph := p.cgen.add_placeholder()
p.expr_var = v
p.gen(p.table.var_cgen_name(v.name))
p.next()
mut typ := v.typ
2019-08-17 21:19:37 +02:00
// Function pointer?
2019-09-01 00:40:53 +02:00
//println('CALLING FN PTR')
//p.print_tok()
if typ.starts_with('fn ') && p.tok == .lpar {
2019-06-22 20:20:28 +02:00
T := p.table.find_type(typ)
p.gen('(')
2019-07-29 18:21:36 +02:00
p.fn_call_args(mut T.func)
2019-06-22 20:20:28 +02:00
p.gen(')')
typ = T.func.typ
}
// users[0].name
if p.tok == .lsbr {
2019-06-22 20:20:28 +02:00
typ = p.index_expr(typ, fn_ph)
}
// a.b.c().d chain
// mut dc := 0
for p.tok ==.dot {
2019-08-09 18:10:59 +02:00
if p.peek() == .key_select {
2019-08-17 21:19:37 +02:00
p.next()
return p.select_query(fn_ph)
}
2019-08-12 11:06:17 +02:00
if typ == 'pg__DB' && !p.fileis('pg.v') && p.peek() == .name {
2019-08-17 21:19:37 +02:00
p.next()
p.insert_query(fn_ph)
return 'void'
}
2019-06-22 20:20:28 +02:00
// println('dot #$dc')
typ = p.dot(typ, fn_ph)
p.log('typ after dot=$typ')
// print('tok after dot()')
// p.print_tok()
// dc++
if p.tok == .lsbr {
2019-06-22 20:20:28 +02:00
// typ = p.index_expr(typ, fn_ph, v)
}
}
// a++ and a--
if p.tok == .inc || p.tok == .dec {
if !v.is_mut && !v.is_arg && !p.pref.translated {
2019-07-10 14:18:21 +02:00
p.error('`$v.name` is immutable')
2019-06-22 20:20:28 +02:00
}
if !v.is_changed {
p.mark_var_changed(v)
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
if typ != 'int' {
if !p.pref.translated && !is_number_type(typ) {
2019-06-22 20:20:28 +02:00
p.error('cannot ++/-- value of type `$typ`')
}
}
p.gen(p.tok.str())
p.fgen(p.tok.str())
2019-08-17 21:19:37 +02:00
p.next()// ++/--
// allow `a := c++` in translated code
if p.pref.translated {
//return p.index_expr(typ, fn_ph)
2019-06-22 20:20:28 +02:00
}
else {
return 'void'
}
}
typ = p.index_expr(typ, fn_ph)
2019-08-17 21:19:37 +02:00
// TODO hack to allow `foo.bar[0] = 2`
if p.tok == .dot {
for p.tok == .dot {
typ = p.dot(typ, fn_ph)
2019-08-17 21:19:37 +02:00
}
typ = p.index_expr(typ, fn_ph)
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
return typ
}
2019-08-17 21:19:37 +02:00
// for debugging only
2019-06-22 20:20:28 +02:00
fn (p &Parser) fileis(s string) bool {
return p.scanner.file_path.contains(s)
}
// user.name => `str_typ` is `User`
// user.company.name => `str_typ` is `Company`
fn (p mut Parser) dot(str_typ string, method_ph int) string {
2019-08-17 21:19:37 +02:00
//if p.fileis('orm_test') {
//println('ORM dot $str_typ')
//}
p.check(.dot)
2019-09-18 14:37:34 +02:00
mut typ := p.find_type(str_typ)
2019-07-29 18:21:36 +02:00
if typ.name.len == 0 {
p.error('dot(): cannot find type `$str_typ`')
}
if p.tok == .dollar {
2019-08-17 21:19:37 +02:00
p.comptime_method_call(typ)
return 'void'
}
field_name := p.lit
2019-08-17 21:19:37 +02:00
p.fgen(field_name)
2019-09-18 14:37:34 +02:00
//p.log('dot() field_name=$field_name typ=$str_typ')
//if p.fileis('main.v') {
2019-08-17 21:19:37 +02:00
//println('dot() field_name=$field_name typ=$str_typ prev_tok=${prev_tok.str()}')
//}
has_field := p.table.type_has_field(typ, p.table.var_cgen_name(field_name))
2019-08-10 23:02:48 +02:00
mut has_method := p.table.type_has_method(typ, field_name)
2019-08-17 21:19:37 +02:00
// generate `.str()`
if !has_method && field_name == 'str' && typ.name.starts_with('array_') {
2019-08-31 15:38:13 +02:00
p.gen_array_str(typ)
2019-08-17 21:19:37 +02:00
has_method = true
}
if !typ.is_c && !p.is_c_fn_call && !has_field && !has_method && !p.first_pass() {
2019-06-22 20:20:28 +02:00
if typ.name.starts_with('Option_') {
2019-08-17 21:19:37 +02:00
opt_type := typ.name.right(7)
2019-09-18 14:37:34 +02:00
p.error('unhandled option type: `?$opt_type`')
2019-06-22 20:20:28 +02:00
}
//println('error in dot():')
//println('fields:')
//for field in typ.fields {
//println(field.name)
//}
//println('methods:')
//for field in typ.methods {
//println(field.name)
//}
//println('str_typ=="$str_typ"')
p.error('type `$typ.name` has no field or method `$field_name`')
2019-06-22 20:20:28 +02:00
}
mut dot := '.'
if str_typ.ends_with('*') || str_typ == 'FT_Face' { // TODO fix C ptr typedefs
2019-09-14 22:48:30 +02:00
dot = dot_ptr
2019-06-22 20:20:28 +02:00
}
// field
if has_field {
struct_field := if typ.name != 'Option' { p.table.var_cgen_name(field_name) } else { field_name }
2019-09-18 13:28:11 +02:00
field := p.table.find_field(typ, struct_field) or { panic('field') }
if !field.is_mut && !p.has_immutable_field {
p.has_immutable_field = true
p.first_immutable_field = field
}
2019-06-22 20:20:28 +02:00
// Is the next token `=`, `+=` etc? (Are we modifying the field?)
next := p.peek()
modifying := next.is_assign() || next == .inc || next == .dec ||
(field.typ.starts_with('array_') && next == .left_shift)
2019-08-07 13:00:19 +02:00
is_vi := p.fileis('vid')
if !p.builtin_mod && !p.pref.translated && modifying && !is_vi
&& p.has_immutable_field {
f := p.first_immutable_field
p.error('cannot modify immutable field `$f.name` (type `$f.parent_fn`)\n' +
'declare the field with `mut:`
struct $f.parent_fn {
mut:
$f.name $f.typ
2019-08-17 21:19:37 +02:00
}
')
2019-06-22 20:20:28 +02:00
}
if !p.builtin_mod && p.mod != typ.mod {
2019-06-22 20:20:28 +02:00
}
// Don't allow `arr.data`
if field.access_mod == .private && !p.builtin_mod && !p.pref.translated && p.mod != typ.mod {
2019-06-22 20:20:28 +02:00
// println('$typ.name :: $field.name ')
// println(field.access_mod)
p.error('cannot refer to unexported field `$struct_field` (type `$typ.name`)')
2019-06-22 20:20:28 +02:00
}
p.gen(dot + struct_field)
2019-06-22 20:20:28 +02:00
p.next()
return field.typ
}
// method
2019-09-18 14:37:34 +02:00
method := p.table.find_method(typ, field_name) or {
p.error('could not find method `$field_name`') // should never happen
exit(1)
}
2019-06-22 20:20:28 +02:00
p.fn_call(method, method_ph, '', str_typ)
2019-08-17 21:19:37 +02:00
// Methods returning `array` should return `array_string`
2019-06-22 20:20:28 +02:00
if method.typ == 'array' && typ.name.starts_with('array_') {
return typ.name
}
// Array methods returning `voidptr` (like `last()`) should return element type
2019-06-22 20:20:28 +02:00
if method.typ == 'void*' && typ.name.starts_with('array_') {
return typ.name.right(6)
}
//if false && p.tok == .lsbr {
2019-06-22 20:20:28 +02:00
// if is_indexer {
//return p.index_expr(method.typ, method_ph)
//}
if method.typ.ends_with('*') {
p.is_alloc = true
}
2019-06-22 20:20:28 +02:00
return method.typ
}
2019-09-14 22:48:30 +02:00
enum IndexType {
noindex
2019-09-14 22:48:30 +02:00
str
map
array
array0
fixed_array
ptr
}
fn get_index_type(typ string) IndexType {
if typ.starts_with('map_') { return IndexType.map }
if typ == 'string' { return IndexType.str }
if typ.starts_with('array_') || typ == 'array' { return IndexType.array }
if typ == 'byte*' || typ == 'byteptr' || typ.contains('*') {
return IndexType.ptr
}
if typ[0] == `[` { return IndexType.fixed_array }
return IndexType.noindex
2019-09-14 22:48:30 +02:00
}
fn (p mut Parser) index_expr(typ_ string, fn_ph int) string {
2019-08-17 21:19:37 +02:00
mut typ := typ_
2019-06-22 20:20:28 +02:00
// a[0]
v := p.expr_var
2019-07-24 13:04:57 +02:00
//if p.fileis('fn_test.v') {
//println('index expr typ=$typ')
2019-08-17 21:19:37 +02:00
//println(v.name)
2019-07-24 13:04:57 +02:00
//}
2019-06-22 20:20:28 +02:00
is_map := typ.starts_with('map_')
is_str := typ == 'string'
is_arr0 := typ.starts_with('array_')
is_arr := is_arr0 || typ == 'array'
is_ptr := typ == 'byte*' || typ == 'byteptr' || typ.contains('*')
is_indexer := p.tok == .lsbr
2019-06-22 20:20:28 +02:00
mut close_bracket := false
if is_indexer {
is_fixed_arr := typ[0] == `[`
if !is_str && !is_arr && !is_map && !is_ptr && !is_fixed_arr {
p.error('Cant [] non-array/string/map. Got type "$typ"')
}
p.check(.lsbr)
2019-06-22 20:20:28 +02:00
// Get element type (set `typ` to it)
if is_str {
typ = 'byte'
p.fgen('[')
// Direct faster access to .str[i] in builtin modules
if p.builtin_mod {
2019-06-22 20:20:28 +02:00
p.gen('.str[')
close_bracket = true
}
else {
// Bounds check everywhere else
p.gen(',')
}
}
if is_fixed_arr {
// `[10]int` => `int`, `[10][3]int` => `[3]int`
if typ.contains('][') {
pos := typ.index_after('[', 1)
typ = typ.right(pos)
}
else {
typ = typ.all_after(']')
}
p.gen('[')
close_bracket = true
}
else if is_ptr {
// typ = 'byte'
typ = typ.replace('*', '')
// modify(mut []string) fix
if !is_arr {
p.gen('[/*ptr*/')
close_bracket = true
}
}
if is_arr {
if is_arr0 {
typ = typ.right(6)
2019-09-14 22:48:30 +02:00
}
p.gen_array_at(typ, is_arr0, fn_ph)
2019-06-22 20:20:28 +02:00
}
// map is tricky
// need to replace "m[key] = val" with "tmp = val; map_set(&m, key, &tmp)"
// need to replace "m[key]" with "tmp = val; map_get(&m, key, &tmp)"
// can only do that later once we know whether there's an "=" or not
if is_map {
typ = typ.replace('map_', '')
if typ == 'map' {
typ = 'void*'
}
p.gen(',')
}
// expression inside [ ]
if is_arr {
index_pos := p.cgen.cur_line.len
2019-06-22 20:20:28 +02:00
T := p.table.find_type(p.expression())
// Allows only i8-64 and byte-64 to be used when accessing an array
if T.parent != 'int' && T.parent != 'u32' {
2019-06-22 20:20:28 +02:00
p.check_types(T.name, 'int')
}
if p.cgen.cur_line.right(index_pos).replace(' ', '').int() < 0 {
p.error('cannot access negative array index')
}
2019-06-22 20:20:28 +02:00
}
else {
T := p.table.find_type(p.expression())
// TODO: Get the key type of the map instead of only string.
if is_map && T.parent != 'string' {
p.check_types(T.name, 'string')
}
2019-06-22 20:20:28 +02:00
}
p.check(.rsbr)
// if (is_str && p.builtin_mod) || is_ptr || is_fixed_arr && ! (is_ptr && is_arr) {
2019-06-22 20:20:28 +02:00
if close_bracket {
p.gen(']/*r$typ $v.is_mut*/')
}
p.expr_var = v
2019-06-22 20:20:28 +02:00
}
2019-08-17 21:19:37 +02:00
// TODO move this from index_expr()
2019-06-22 20:20:28 +02:00
// TODO if p.tok in ...
// if p.tok in [.assign, .plus_assign, .minus_assign]
2019-08-09 18:10:59 +02:00
if (p.tok == .assign && !p.is_sql) || p.tok == .plus_assign || p.tok == .minus_assign ||
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_mod {
2019-07-10 14:18:21 +02:00
p.error('strings are immutable')
2019-06-22 20:20:28 +02:00
}
p.assigned_type = typ
p.expected_type = typ
2019-09-14 22:48:30 +02:00
assign_pos := p.cgen.cur_line.len
is_cao := p.tok .assign
2019-06-22 20:20:28 +02:00
p.assign_statement(v, fn_ph, is_indexer && (is_map || is_arr))
2019-09-14 22:48:30 +02:00
// `m[key] = val`
2019-06-22 20:20:28 +02:00
if is_indexer && (is_map || is_arr) {
2019-09-14 22:48:30 +02:00
p.gen_array_set(typ, is_ptr, is_map, fn_ph, assign_pos, is_cao)
2019-06-22 20:20:28 +02:00
}
return typ
}
// else if p.pref.is_verbose && p.assigned_var != '' {
2019-06-22 20:20:28 +02:00
// p.error('didnt assign')
// }
// m[key]. no =, just a getter
else if (is_map || is_arr || (is_str && !p.builtin_mod)) && is_indexer {
2019-09-14 22:48:30 +02:00
p.index_get(typ, fn_ph, IndexCfg{
is_arr: is_arr
is_map: is_map
is_ptr: is_ptr
is_str: is_str
})
2019-06-22 20:20:28 +02:00
}
// else if is_arr && is_indexer{}
return typ
}
2019-09-14 22:48:30 +02:00
struct IndexCfg {
is_map bool
is_str bool
is_ptr bool
is_arr bool
is_arr0 bool
}
2019-09-21 17:21:45 +02:00
// in and dot have higher priority than `!`
fn (p mut Parser) indot_expr() string {
ph := p.cgen.add_placeholder()
mut typ := p.term()
if p.tok == .dot {
for p.tok == .dot {
typ = p.dot(typ, ph)
}
}
// `a in [1, 2, 3]`
// `key in map`
if p.tok == .key_in {
p.fgen(' ')
p.check(.key_in)
p.fgen(' ')
p.gen('), ')
arr_typ := p.expression()
is_map := arr_typ.starts_with('map_')
if !arr_typ.starts_with('array_') && !is_map {
p.error('`in` requires an array/map')
}
T := p.table.find_type(arr_typ)
if !is_map && !T.has_method('contains') {
p.error('$arr_typ has no method `contains`')
}
// `typ` is element's type
if is_map {
p.cgen.set_placeholder(ph, '_IN_MAP( (')
}
else {
p.cgen.set_placeholder(ph, '_IN($typ, (')
}
p.gen(')')
return 'bool'
}
return typ
}
2019-06-22 20:20:28 +02:00
// returns resulting type
fn (p mut Parser) expression() string {
if p.scanner.file_path.contains('test_test') {
2019-07-29 18:21:36 +02:00
println('expression() pass=$p.pass tok=')
2019-06-22 20:20:28 +02:00
p.print_tok()
}
ph := p.cgen.add_placeholder()
2019-09-21 17:21:45 +02:00
mut typ := p.indot_expr()
2019-08-17 21:19:37 +02:00
is_str := typ=='string'
is_ustr := typ=='ustring'
2019-09-14 22:48:30 +02:00
// `a << b` ==> `array_push(&a, b)`
if p.tok == .left_shift {
2019-06-22 20:20:28 +02:00
if typ.contains('array_') {
// Can't pass integer literal, because push requires a void*
// a << 7 => int tmp = 7; array_push(&a, &tmp);
// _PUSH(&a, expression(), tmp, string)
tmp := p.get_tmp()
tmp_typ := typ.right(6)// skip "array_"
2019-08-17 21:19:37 +02:00
p.check_space(.left_shift)
2019-06-22 20:20:28 +02:00
// Get the value we are pushing
p.gen(', (')
// Immutable? Can we push?
if !p.expr_var.is_mut && !p.pref.translated {
2019-07-10 14:18:21 +02:00
p.error('`$p.expr_var.name` is immutable (can\'t <<)')
2019-06-22 20:20:28 +02:00
}
if !p.expr_var.is_changed {
p.mark_var_changed(p.expr_var)
2019-08-17 21:19:37 +02:00
}
expr_type := p.expression()
// Two arrays of the same type?
2019-09-14 22:48:30 +02:00
p.gen_array_push(ph, typ, expr_type, tmp, tmp_typ)
2019-06-22 20:20:28 +02:00
return 'void'
}
else {
p.next()
p.gen(' << ')
p.check_types(p.expression(), typ)
return 'int'
}
}
if p.tok == .righ_shift {
2019-06-22 20:20:28 +02:00
p.next()
p.gen(' >> ')
p.check_types(p.expression(), typ)
return 'int'
}
2019-09-15 18:07:40 +02:00
// + - | ^
for p.tok == .plus || p.tok == .minus || p.tok == .pipe || p.tok == .amp ||
p.tok == .xor {
// for p.tok in [.plus, .minus, .pipe, .amp, .xor] {
2019-06-22 20:20:28 +02:00
tok_op := p.tok
2019-09-15 18:07:40 +02:00
if typ == 'bool' {
p.error('operator ${p.tok.str()} not defined on bool ')
}
2019-06-22 20:20:28 +02:00
is_num := typ == 'void*' || typ == 'byte*' || is_number_type(typ)
2019-08-17 21:19:37 +02:00
p.check_space(p.tok)
2019-09-14 22:48:30 +02:00
if is_str && tok_op == .plus && !p.is_js {
2019-06-22 20:20:28 +02:00
p.cgen.set_placeholder(ph, 'string_add(')
p.gen(',')
}
else if is_ustr && tok_op == .plus {
p.cgen.set_placeholder(ph, 'ustring_add(')
p.gen(',')
}
2019-06-22 20:20:28 +02:00
// 3 + 4
2019-09-14 22:48:30 +02:00
else if is_num || p.is_js {
if typ == 'void*' {
// Msvc errors on void* pointer arithmatic
// ... So cast to byte* and then do the add
p.cgen.set_placeholder(ph, '(byte*)')
}
2019-06-22 20:20:28 +02:00
p.gen(tok_op.str())
}
// Vec + Vec
else {
if p.pref.translated {
2019-06-22 20:20:28 +02:00
p.gen(tok_op.str() + ' /*doom hack*/')// TODO hack to fix DOOM's angle_t
}
else {
p.gen(',')
}
}
p.check_types(p.term(), typ)
if (is_str || is_ustr) && tok_op == .plus && !p.is_js {
2019-06-22 20:20:28 +02:00
p.gen(')')
}
// Make sure operators are used with correct types
if !p.pref.translated && !is_str && !is_ustr && !is_num {
2019-06-22 20:20:28 +02:00
T := p.table.find_type(typ)
if tok_op == .plus {
2019-06-22 20:20:28 +02:00
if T.has_method('+') {
p.cgen.set_placeholder(ph, typ + '_plus(')
p.gen(')')
}
else {
p.error('operator + not defined on `$typ`')
}
}
else if tok_op == .minus {
2019-06-22 20:20:28 +02:00
if T.has_method('-') {
p.cgen.set_placeholder(ph, '${typ}_minus(')
p.gen(')')
}
else {
p.error('operator - not defined on `$typ`')
}
}
}
}
return typ
}
fn (p mut Parser) term() string {
line_nr := p.scanner.line_nr
2019-07-24 13:04:57 +02:00
//if p.fileis('fn_test') {
//println('\nterm() $line_nr')
//}
2019-06-22 20:20:28 +02:00
typ := p.unary()
2019-07-24 13:04:57 +02:00
//if p.fileis('fn_test') {
//println('2: $line_nr')
//}
2019-06-22 20:20:28 +02:00
// `*` on a newline? Can't be multiplication, only dereference
if p.tok == .mul && line_nr != p.scanner.line_nr {
2019-06-22 20:20:28 +02:00
return typ
}
for p.tok == .mul || p.tok == .div || p.tok == .mod {
2019-06-22 20:20:28 +02:00
tok := p.tok
is_div := tok == .div
is_mod := tok == .mod
// is_mul := tok == .mod
2019-06-22 20:20:28 +02:00
p.next()
p.gen(tok.str())// + ' /*op2*/ ')
p.fgen(' ' + tok.str() + ' ')
2019-08-11 13:47:34 +02:00
if (is_div || is_mod) && p.tok == .number && p.lit == '0' {
2019-06-22 20:20:28 +02:00
p.error('division by zero')
}
if is_mod && (is_float_type(typ) || !is_number_type(typ)) {
p.error('operator .mod requires integer types')
2019-06-22 20:20:28 +02:00
}
p.check_types(p.unary(), typ)
}
return typ
}
fn (p mut Parser) unary() string {
mut typ := ''
tok := p.tok
switch tok {
case Token.not:
2019-06-22 20:20:28 +02:00
p.gen('!')
2019-08-17 21:19:37 +02:00
p.check(.not)
2019-09-21 17:21:45 +02:00
// typ should be bool type
typ = p.indot_expr()
if typ != 'bool' {
p.error('operator ! requires bool type, not `$typ`')
}
case Token.bit_not:
2019-06-22 20:20:28 +02:00
p.gen('~')
2019-08-17 21:19:37 +02:00
p.check(.bit_not)
2019-06-22 20:20:28 +02:00
typ = p.bool_expression()
default:
typ = p.factor()
}
return typ
}
fn (p mut Parser) factor() string {
mut typ := ''
tok := p.tok
switch tok {
case .key_none:
if !p.expected_type.starts_with('Option_') {
p.error('need "$p.expected_type" got none')
}
p.gen('opt_none()')
p.check(.key_none)
return p.expected_type
case Token.number:
2019-06-22 20:20:28 +02:00
typ = 'int'
2019-06-26 21:44:08 +02:00
// Check if float (`1.0`, `1e+3`) but not if is hexa
2019-08-17 21:19:37 +02:00
if (p.lit.contains('.') || (p.lit.contains('e') || p.lit.contains('E'))) &&
2019-07-18 10:55:39 +02:00
!(p.lit[0] == `0` && (p.lit[1] == `x` || p.lit[1] == `X`)) {
2019-06-25 21:36:44 +02:00
typ = 'f32'
2019-08-17 21:19:37 +02:00
// typ = 'f64' // TODO
2019-07-18 10:55:39 +02:00
} else {
v_u64 := p.lit.u64()
if u64(u32(v_u64)) < v_u64 {
typ = 'u64'
}
2019-06-25 21:36:44 +02:00
}
2019-08-17 21:19:37 +02:00
if p.expected_type != '' && !is_valid_int_const(p.lit, p.expected_type) {
p.error('constant `$p.lit` overflows `$p.expected_type`')
}
2019-06-25 21:36:44 +02:00
p.gen(p.lit)
2019-06-22 20:20:28 +02:00
p.fgen(p.lit)
case Token.minus:
2019-06-22 20:20:28 +02:00
p.gen('-')
p.fgen('-')
p.next()
return p.factor()
// Variable
case Token.key_sizeof:
2019-06-22 20:20:28 +02:00
p.gen('sizeof(')
p.fgen('sizeof(')
p.next()
p.check(.lpar)
2019-09-21 17:21:45 +02:00
mut sizeof_typ := p.get_type()
p.check(.rpar)
2019-06-22 20:20:28 +02:00
p.gen('$sizeof_typ)')
p.fgen('$sizeof_typ)')
return 'int'
2019-08-17 21:19:37 +02:00
case Token.amp, Token.dot, Token.mul:
// (dot is for enum vals: `.green`)
2019-06-22 20:20:28 +02:00
return p.name_expr()
case Token.name:
2019-06-22 20:20:28 +02:00
// map[string]int
if p.lit == 'map' && p.peek() == .lsbr {
2019-06-22 20:20:28 +02:00
return p.map_init()
}
if p.lit == 'json' && p.peek() == .dot {
if !('json' in p.table.imports) {
2019-08-17 21:19:37 +02:00
p.error('undefined: `json`, use `import json`')
}
2019-06-22 20:20:28 +02:00
return p.js_decode()
}
2019-08-17 21:19:37 +02:00
//if p.fileis('orm_test') {
//println('ORM name: $p.lit')
//}
2019-06-22 20:20:28 +02:00
typ = p.name_expr()
return typ
2019-08-17 21:19:37 +02:00
case Token.key_default:
2019-06-22 20:20:28 +02:00
p.next()
p.next()
name := p.check_name()
if name != 'T' {
p.error('default needs T')
}
p.gen('default(T)')
p.next()
return 'T'
case Token.lpar:
//p.gen('(/*lpar*/')
p.gen('(')
2019-08-17 21:19:37 +02:00
p.check(.lpar)
2019-06-22 20:20:28 +02:00
typ = p.bool_expression()
// Hack. If this `)` referes to a ptr cast `(*int__)__`, it was already checked
// TODO: fix parser so that it doesn't think it's a par expression when it sees `(` in
// __(__*int)(
if !p.ptr_cast {
p.check(.rpar)
2019-06-22 20:20:28 +02:00
}
p.ptr_cast = false
p.gen(')')
return typ
case Token.chartoken:
2019-06-22 20:20:28 +02:00
p.char_expr()
typ = 'byte'
return typ
2019-07-16 17:59:07 +02:00
case Token.str:
2019-06-22 20:20:28 +02:00
p.string_expr()
typ = 'string'
return typ
case Token.key_false:
2019-06-22 20:20:28 +02:00
typ = 'bool'
p.gen('0')
p.fgen('false')
case Token.key_true:
2019-06-22 20:20:28 +02:00
typ = 'bool'
p.gen('1')
p.fgen('true')
case Token.lsbr:
2019-06-22 20:20:28 +02:00
// `[1,2,3]` or `[]` or `[20]byte`
// TODO have to return because arrayInit does next()
// everything should do next()
return p.array_init()
case Token.lcbr:
2019-08-17 21:19:37 +02:00
// `m := { 'one': 1 }`
2019-08-03 09:44:08 +02:00
if p.peek() == .str {
2019-08-17 21:19:37 +02:00
return p.map_init()
}
2019-06-22 20:20:28 +02:00
// { user | name :'new name' }
return p.assoc()
case Token.key_if:
typ = p.if_st(true, 0)
2019-06-22 20:20:28 +02:00
return typ
2019-08-26 23:39:11 +02:00
case Token.key_match:
typ = p.match_statement(true)
return typ
2019-06-22 20:20:28 +02:00
default:
2019-08-17 21:19:37 +02:00
if p.pref.is_verbose || p.pref.is_debug {
next := p.peek()
println('prev=${p.prev_tok.str()}')
println('next=${next.str()}')
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
p.error('unexpected token: `${p.tok.str()}`')
}
p.next()// TODO everything should next()
return typ
}
// { user | name: 'new name' }
fn (p mut Parser) assoc() string {
// println('assoc()')
p.next()
name := p.check_name()
var := p.cur_fn.find_var(name) or {
2019-06-22 20:20:28 +02:00
p.error('unknown variable `$name`')
exit(1)
}
p.check(.pipe)
2019-06-22 20:20:28 +02:00
p.gen('($var.typ){')
mut fields := []string// track the fields user is setting, the rest will be copied from the old object
for p.tok != .rcbr {
2019-06-22 20:20:28 +02:00
field := p.check_name()
fields << field
p.gen('.$field = ')
p.check(.colon)
2019-06-22 20:20:28 +02:00
p.bool_expression()
p.gen(',')
if p.tok != .rcbr {
p.check(.comma)
2019-06-22 20:20:28 +02:00
}
}
// Copy the rest of the fields
T := p.table.find_type(var.typ)
for ffield in T.fields {
f := ffield.name
if f in fields {
continue
}
p.gen('.$f = $name . $f,')
}
p.check(.rcbr)
2019-06-22 20:20:28 +02:00
p.gen('}')
return var.typ
}
fn (p mut Parser) char_expr() {
p.gen('\'$p.lit\'')
p.next()
}
fn format_str(_str string) string {
mut str := _str.replace('"', '\\"')
2019-07-04 21:51:59 +02:00
$if windows {
str = str.replace('\r\n', '\\n')
2019-08-17 21:19:37 +02:00
}
2019-07-04 21:51:59 +02:00
str = str.replace('\n', '\\n')
return str
}
2019-06-22 20:20:28 +02:00
fn (p mut Parser) string_expr() {
str := p.lit
2019-07-16 17:59:07 +02:00
// No ${}, just return a simple string
if p.peek() != .dollar {
2019-07-16 17:59:07 +02:00
p.fgen('\'$str\'')
2019-06-22 20:20:28 +02:00
f := format_str(str)
2019-08-17 21:19:37 +02:00
// `C.puts('hi')` => `puts("hi");`
/*
Calling a C function sometimes requires a call to a string method
C.fun('ssss'.to_wide()) => fun(string_to_wide(tos2((byte*)('ssss'))))
*/
if (p.calling_c && p.peek() != .dot) || (p.pref.translated && p.mod == 'main') {
2019-06-22 20:20:28 +02:00
p.gen('"$f"')
}
2019-08-09 18:10:59 +02:00
else if p.is_sql {
2019-08-17 21:19:37 +02:00
p.gen('\'$str\'')
}
2019-09-14 22:48:30 +02:00
else if p.is_js {
p.gen('"$f"')
}
2019-06-22 20:20:28 +02:00
else {
2019-08-17 21:19:37 +02:00
p.gen('tos2((byte*)"$f")')
2019-06-22 20:20:28 +02:00
}
p.next()
return
}
2019-09-14 22:48:30 +02:00
$if js {
p.error('js backend does not support string formatting yet')
}
2019-06-22 20:20:28 +02:00
// tmp := p.get_tmp()
2019-08-17 21:19:37 +02:00
p.is_alloc = true // $ interpolation means there's allocation
2019-06-22 20:20:28 +02:00
mut args := '"'
mut format := '"'
2019-08-17 21:19:37 +02:00
p.fgen('\'')
mut complex_inter := false // for vfmt
2019-07-16 17:59:07 +02:00
for p.tok == .str {
2019-06-22 20:20:28 +02:00
// Add the string between %d's
2019-08-17 21:19:37 +02:00
p.fgen(p.lit)
p.lit = p.lit.replace('%', '%%')
2019-06-22 20:20:28 +02:00
format += format_str(p.lit)
p.next()// skip $
if p.tok != .dollar {
2019-06-22 20:20:28 +02:00
continue
}
// Handle .dollar
2019-08-17 21:19:37 +02:00
p.check(.dollar)
2019-07-16 17:59:07 +02:00
// If there's no string after current token, it means we are in
2019-08-17 21:19:37 +02:00
// a complex expression (`${...}`)
2019-07-16 17:59:07 +02:00
if p.peek() != .str {
2019-08-17 21:19:37 +02:00
p.fgen('{')
complex_inter = true
}
2019-06-22 20:20:28 +02:00
// Get bool expr inside a temp var
p.cgen.start_tmp()
typ := p.bool_expression()
mut val := p.cgen.end_tmp()
val = val.trim_space()
args += ', $val'
if typ == 'string' {
// args += '.str'
// printf("%.*s", a.len, a.str) syntax
args += '.len, ${val}.str'
}
if typ == 'ustring' {
args += '.len, ${val}.s.str'
}
2019-08-17 21:19:37 +02:00
if typ == 'bool' {
2019-08-09 18:10:59 +02:00
//args += '.len, ${val}.str'
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
// Custom format? ${t.hour:02d}
custom := p.tok == .colon
2019-06-22 20:20:28 +02:00
if custom {
2019-09-07 12:44:41 +02:00
mut cformat := ''
2019-06-22 20:20:28 +02:00
p.next()
if p.tok == .dot {
2019-09-07 12:44:41 +02:00
cformat += '.'
p.next()
}
if p.tok == .minus { // support for left aligned formatting
cformat += '-'
2019-06-22 20:20:28 +02:00
p.next()
}
2019-09-07 12:44:41 +02:00
cformat += p.lit// 02
2019-06-22 20:20:28 +02:00
p.next()
2019-09-07 12:44:41 +02:00
fspec := p.lit // f
cformat += fspec
if fspec == 's' {
//println('custom str F=$cformat | format_specifier: "$fspec" | typ: $typ ')
if typ != 'string' {
2019-09-14 22:48:30 +02:00
p.error('only V strings can be formatted with a :${cformat} format, but you have given "${val}", which has type ${typ}.')
2019-09-07 12:44:41 +02:00
}
args = args.all_before_last('${val}.len, ${val}.str') + '${val}.str'
}
format += '%$cformat'
2019-06-22 20:20:28 +02:00
p.next()
}
else {
2019-08-17 21:19:37 +02:00
f := p.typ_to_fmt(typ, 0)
if f == '' {
is_array := typ.starts_with('array_')
2019-08-31 15:38:13 +02:00
typ2 := p.table.find_type(typ)
has_str_method := p.table.type_has_method(typ2, 'str')
if is_array || has_str_method {
if is_array && !has_str_method {
2019-08-31 15:38:13 +02:00
p.gen_array_str(typ2)
}
args = args.all_before_last(val) + '${typ}_str(${val}).len, ${typ}_str(${val}).str'
format += '%.*s '
}
else {
p.error('unhandled sprintf format "$typ" ')
}
2019-08-17 21:19:37 +02:00
}
format += f
2019-06-22 20:20:28 +02:00
}
2019-09-07 12:44:41 +02:00
//println('interpolation format is: |${format}| args are: |${args}| ')
2019-06-22 20:20:28 +02:00
}
2019-07-16 17:59:07 +02:00
if complex_inter {
2019-08-17 21:19:37 +02:00
p.fgen('}')
}
p.fgen('\'')
2019-06-22 20:20:28 +02:00
// println("hello %d", num) optimization.
if p.cgen.nogen {
return
}
2019-08-17 21:19:37 +02:00
// println: don't allocate a new string, just print it.
$if !windows {
cur_line := p.cgen.cur_line.trim_space()
if cur_line == 'println (' && p.tok != .plus {
p.cgen.resetln(cur_line.replace('println (', 'printf('))
p.gen('$format\\n$args')
return
}
2019-06-22 20:20:28 +02:00
}
// '$age'! means the user wants this to be a tmp string (uses global buffer, no allocation,
// won't be used again)
if p.tok == .not {
2019-08-17 21:19:37 +02:00
p.check(.not)
2019-06-22 20:20:28 +02:00
p.gen('_STR_TMP($format$args)')
}
else {
// Otherwise do ugly len counting + allocation + sprintf
p.gen('_STR($format$args)')
}
}
// m := map[string]int{}
2019-08-17 21:19:37 +02:00
// m := { 'one': 1 }
2019-06-22 20:20:28 +02:00
fn (p mut Parser) map_init() string {
2019-08-17 21:19:37 +02:00
// m := { 'one': 1, 'two': 2 }
mut keys_gen := '' // (string[]){tos2("one"), tos2("two")}
mut vals_gen := '' // (int[]){1, 2}
mut val_type := '' // 'int'
2019-08-03 09:44:08 +02:00
if p.tok == .lcbr {
p.check(.lcbr)
2019-08-17 21:19:37 +02:00
mut i := 0
for {
key := p.lit
keys_gen += 'tos2((byte*)"$key"), '
2019-08-17 21:19:37 +02:00
p.check(.str)
p.check(.colon)
p.cgen.start_tmp()
t := p.bool_expression()
if i == 0 {
val_type = t
}
i++
2019-08-03 09:44:08 +02:00
if val_type != t {
if !p.check_types_no_throw(val_type, t) {
p.error('bad map element type `$val_type` instead of `$t`')
}
}
2019-08-17 21:19:37 +02:00
val_expr := p.cgen.end_tmp()
vals_gen += '$val_expr, '
2019-08-03 09:44:08 +02:00
if p.tok == .rcbr {
2019-08-17 21:19:37 +02:00
p.check(.rcbr)
break
}
2019-08-03 09:44:08 +02:00
if p.tok == .comma {
p.check(.comma)
2019-08-17 21:19:37 +02:00
}
}
2019-08-03 10:26:36 +02:00
p.gen('new_map_init($i, sizeof($val_type), ' +
'(string[$i]){ $keys_gen }, ($val_type [$i]){ $vals_gen } )')
2019-08-17 21:19:37 +02:00
typ := 'map_$val_type'
2019-08-26 16:42:18 +02:00
p.register_map(typ)
2019-08-17 21:19:37 +02:00
return typ
}
2019-06-22 20:20:28 +02:00
p.next()
p.check(.lsbr)
2019-06-22 20:20:28 +02:00
key_type := p.check_name()
if key_type != 'string' {
p.error('only string key maps allowed for now')
}
p.check(.rsbr)
2019-08-16 17:44:35 +02:00
val_type = p.get_type()/// p.check_name()
//if !p.table.known_type(val_type) {
//p.error('map init unknown type "$val_type"')
//}
2019-07-15 12:33:18 +02:00
typ := 'map_$val_type'
p.register_map(typ)
2019-06-22 20:20:28 +02:00
p.gen('new_map(1, sizeof($val_type))')
2019-08-16 17:44:35 +02:00
if p.tok == .lcbr {
p.check(.lcbr)
p.check(.rcbr)
println('warning: $p.file_name:$p.scanner.line_nr ' +
2019-08-17 21:19:37 +02:00
'initializaing maps no longer requires `{}`')
}
2019-07-15 12:33:18 +02:00
return typ
2019-06-22 20:20:28 +02:00
}
2019-08-17 21:19:37 +02:00
// `nums := [1, 2, 3]`
2019-06-22 20:20:28 +02:00
fn (p mut Parser) array_init() string {
2019-08-17 21:19:37 +02:00
p.is_alloc = true
p.check(.lsbr)
2019-08-17 21:19:37 +02:00
mut is_integer := p.tok == .number // for `[10]int`
// fixed length arrays with a const len: `nums := [N]int`, same as `[10]int` basically
mut is_const_len := false
2019-09-19 13:19:44 +02:00
if p.tok == .name && !p.inside_const {
const_name := p.prepend_mod(p.lit)
if p.table.known_const(const_name) {
c := p.table.find_const(const_name) or {
//p.error('unknown const `$p.lit`')
exit(1)
}
if c.typ == 'int' && p.peek() == .rsbr { //&& !p.inside_const {
is_integer = true
is_const_len = true
} else {
p.error('bad fixed size array const `$p.lit`')
}
2019-08-17 21:19:37 +02:00
}
}
2019-06-22 20:20:28 +02:00
lit := p.lit
mut typ := ''
new_arr_ph := p.cgen.add_placeholder()
mut i := 0
2019-09-14 22:48:30 +02:00
pos := p.cgen.cur_line.len// remember cur line to fetch first number in cgen for [0; 10]
for p.tok != .rsbr {
2019-06-22 20:20:28 +02:00
val_typ := p.bool_expression()
2019-09-14 22:48:30 +02:00
// Get the type of the first expression
2019-06-22 20:20:28 +02:00
if i == 0 {
typ = val_typ
// fixed width array initialization? (`arr := [20]byte`)
if is_integer && p.tok == .rsbr && p.peek() == .name {
2019-06-22 20:20:28 +02:00
nextc := p.scanner.text[p.scanner.pos + 1]
// TODO whitespace hack
// Make sure there's no space in `[10]byte`
if !nextc.is_space() {
p.check(.rsbr)
2019-08-31 02:28:20 +02:00
array_elem_typ := p.get_type()
2019-09-14 22:48:30 +02:00
if !p.table.known_type(array_elem_typ) {
2019-08-31 02:28:20 +02:00
p.error('bad type `$array_elem_typ`')
2019-06-22 20:20:28 +02:00
}
2019-09-14 22:48:30 +02:00
p.cgen.resetln('')
//p.gen('{0}')
p.is_alloc = false
if is_const_len {
return '[${p.mod}__$lit]$array_elem_typ'
}
return '[$lit]$array_elem_typ'
2019-06-22 20:20:28 +02:00
}
}
}
if val_typ != typ {
if !p.check_types_no_throw(val_typ, typ) {
p.error('bad array element type `$val_typ` instead of `$typ`')
}
}
if p.tok != .rsbr && p.tok != .semicolon {
2019-07-03 13:20:43 +02:00
p.gen(', ')
p.check(.comma)
2019-08-17 21:19:37 +02:00
p.fspace()
2019-06-22 20:20:28 +02:00
}
i++
// Repeat (a = [0;5] )
if i == 1 && p.tok == .semicolon {
2019-09-14 22:48:30 +02:00
p.warn('`[0 ; len]` syntax was removed. Use `[0].repeat(len)` instead')
p.check_space(.semicolon)
2019-06-22 20:20:28 +02:00
val := p.cgen.cur_line.right(pos)
p.cgen.resetln(p.cgen.cur_line.left(pos))
2019-09-14 22:48:30 +02:00
p.gen('array_repeat_old(& ($typ[]){ $val }, ')
2019-06-22 20:20:28 +02:00
p.check_types(p.bool_expression(), 'int')
p.gen(', sizeof($typ) )')
p.check(.rsbr)
2019-06-22 20:20:28 +02:00
return 'array_$typ'
}
}
p.check(.rsbr)
2019-06-22 20:20:28 +02:00
// type after `]`? (e.g. "[]string")
if p.tok != .name && i == 0 {
2019-06-22 20:20:28 +02:00
p.error('specify array type: `[]typ` instead of `[]`')
}
if p.tok == .name && i == 0 {
2019-06-22 20:20:28 +02:00
// vals.len == 0 {
typ = p.get_type()
}
// ! after array => no malloc and no copy
2019-08-17 21:19:37 +02:00
no_alloc := p.tok == .not
2019-06-23 13:17:33 +02:00
if no_alloc {
2019-06-22 20:20:28 +02:00
p.next()
}
2019-06-22 20:20:28 +02:00
// [1,2,3]!! => [3]int{1,2,3}
2019-08-17 21:19:37 +02:00
is_fixed_size := p.tok == .not
2019-06-22 20:20:28 +02:00
if is_fixed_size {
p.next()
p.gen(' }')
2019-07-29 18:21:36 +02:00
if !p.first_pass() {
2019-06-22 20:20:28 +02:00
// If we are defining a const array, we don't need to specify the type:
// `a = {1,2,3}`, not `a = (int[]) {1,2,3}`
if p.inside_const {
p.cgen.set_placeholder(new_arr_ph, '{')
2019-06-22 20:20:28 +02:00
}
else {
p.cgen.set_placeholder(new_arr_ph, '($typ[]) {')
2019-06-22 20:20:28 +02:00
}
}
return '[$i]$typ'
}
// if ptr {
// typ += '_ptr"
// }
2019-09-14 22:48:30 +02:00
p.gen_array_init(typ, no_alloc, new_arr_ph, i)
2019-06-22 20:20:28 +02:00
typ = 'array_$typ'
p.register_array(typ)
return typ
}
2019-09-14 22:48:30 +02:00
fn (p mut Parser) struct_init(typ string) string {
//p.gen('/* struct init */')
2019-06-22 20:20:28 +02:00
p.is_struct_init = true
t := p.table.find_type(typ)
2019-09-14 22:48:30 +02:00
if p.gen_struct_init(typ, t) { return typ }
2019-06-22 20:20:28 +02:00
p.scanner.fmt_out.cut(typ.len)
ptr := typ.contains('*')
2019-09-14 22:48:30 +02:00
/*
2019-06-22 20:20:28 +02:00
if !ptr {
2019-06-27 17:48:49 +02:00
if p.is_c_struct_init {
// `face := C.FT_Face{}` => `FT_Face face;`
if p.tok == .rcbr {
p.is_empty_c_struct_init = true
p.check(.rcbr)
return typ
}
p.gen('(struct $typ) {')
2019-06-27 17:48:49 +02:00
p.is_c_struct_init = false
2019-06-22 20:20:28 +02:00
}
else {
2019-09-14 22:48:30 +02:00
p.gen('($typ /*str init */) {')
2019-06-22 20:20:28 +02:00
}
}
else {
// TODO tmp hack for 0 pointers init
// &User{!} ==> 0
if p.tok == .not {
2019-06-22 20:20:28 +02:00
p.next()
p.gen('0')
p.check(.rcbr)
2019-06-22 20:20:28 +02:00
return typ
}
p.is_alloc = true
//println('setting is_alloc=true (ret $typ)')
2019-09-14 22:48:30 +02:00
p.gen('($t.name*)memdup(&($t.name) {')
2019-06-22 20:20:28 +02:00
}
2019-09-14 22:48:30 +02:00
*/
mut did_gen_something := false
2019-06-22 20:20:28 +02:00
// Loop thru all struct init keys and assign values
// u := User{age:20, name:'bob'}
// Remember which fields were set, so that we dont have to zero them later
mut inited_fields := []string
peek := p.peek()
if peek == .colon || p.tok == .rcbr {
for p.tok != .rcbr {
field := if typ != 'Option' { p.table.var_cgen_name( p.check_name() ) } else { p.check_name() }
2019-08-31 15:38:13 +02:00
if !p.first_pass() && !t.has_field(field) {
2019-06-22 20:20:28 +02:00
p.error('`$t.name` has no field `$field`')
}
if field in inited_fields {
p.error('already initialized field `$field` in `$t.name`')
}
2019-09-18 13:28:11 +02:00
f := t.find_field(field) or { panic('field') }
2019-06-22 20:20:28 +02:00
inited_fields << field
2019-09-14 22:48:30 +02:00
p.gen_struct_field_init(field)
p.check(.colon)
2019-06-22 20:20:28 +02:00
p.fspace()
2019-08-17 21:19:37 +02:00
p.check_types(p.bool_expression(), f.typ)
if p.tok == .comma {
2019-06-22 20:20:28 +02:00
p.next()
}
if p.tok != .rcbr {
2019-06-22 20:20:28 +02:00
p.gen(',')
}
p.fgenln('')
did_gen_something = true
2019-06-22 20:20:28 +02:00
}
// If we already set some fields, need to prepend a comma
if t.fields.len != inited_fields.len && inited_fields.len > 0 {
p.gen(',')
}
// Zero values: init all fields (ints to 0, strings to '' etc)
for i, field in t.fields {
// println('### field.name')
// Skip if this field has already been assigned to
if field.name in inited_fields {
2019-06-22 20:20:28 +02:00
continue
}
field_typ := field.typ
if !p.builtin_mod && field_typ.ends_with('*') && field_typ.contains('Cfg') {
2019-06-22 20:20:28 +02:00
p.error('pointer field `${typ}.${field.name}` must be initialized')
}
2019-08-14 11:35:51 +02:00
// init map fields
if field_typ.starts_with('map_') {
2019-09-14 22:48:30 +02:00
p.gen_struct_field_init(field.name)
p.gen_empty_map(field_typ.right(4))
2019-08-14 11:35:51 +02:00
inited_fields << field.name
if i != t.fields.len - 1 {
p.gen(',')
}
did_gen_something = true
continue
}
2019-06-22 20:20:28 +02:00
def_val := type_default(field_typ)
if def_val != '' && def_val != '{0}' {
2019-09-14 22:48:30 +02:00
p.gen_struct_field_init(field.name)
p.gen(def_val)
2019-06-22 20:20:28 +02:00
if i != t.fields.len - 1 {
p.gen(',')
}
did_gen_something = true
2019-06-22 20:20:28 +02:00
}
}
}
// Point{3,4} syntax
else {
mut T := p.table.find_type(typ)
// Aliases (TODO Hack, implement proper aliases)
if T.fields.len == 0 && T.parent != '' {
T = p.table.find_type(T.parent)
}
for i, ffield in T.fields {
expr_typ := p.bool_expression()
if !p.check_types_no_throw(expr_typ, ffield.typ) {
p.error('field value #${i+1} `$ffield.name` has type `$ffield.typ`, got `$expr_typ` ')
}
if i < T.fields.len - 1 {
if p.tok != .comma {
2019-06-22 20:20:28 +02:00
p.error('too few values in `$typ` literal (${i+1} instead of $T.fields.len)')
}
p.gen(',')
p.next()
}
}
// Allow `user := User{1,2,3,}`
// The final comma will be removed by vfmt, since we are not calling `p.fgen()`
if p.tok == .comma {
2019-06-22 20:20:28 +02:00
p.next()
}
if p.tok != .rcbr {
2019-06-22 20:20:28 +02:00
p.error('too many fields initialized: `$typ` has $T.fields.len field(s)')
}
did_gen_something = true
2019-06-22 20:20:28 +02:00
}
if !did_gen_something {
p.gen('EMPTY_STRUCT_INITIALIZATION')
}
2019-06-22 20:20:28 +02:00
p.gen('}')
2019-09-14 22:48:30 +02:00
if ptr && !p.is_js {
p.gen(', sizeof($t.name))')
2019-06-22 20:20:28 +02:00
}
p.check(.rcbr)
2019-06-22 20:20:28 +02:00
p.is_struct_init = false
2019-09-14 22:48:30 +02:00
p.is_c_struct_init = false
2019-06-22 20:20:28 +02:00
return typ
}
// `f32(3)`
// tok is `f32` or `)` if `(*int)(ptr)`
fn (p mut Parser) get_tmp() string {
p.tmp_cnt++
return 'tmp$p.tmp_cnt'
}
fn (p mut Parser) get_tmp_counter() int {
p.tmp_cnt++
return p.tmp_cnt
}
fn (p mut Parser) if_st(is_expr bool, elif_depth int) string {
2019-06-22 20:20:28 +02:00
if is_expr {
2019-08-09 18:10:59 +02:00
//if p.fileis('if_expr') {
//println('IF EXPR')
//}
2019-06-22 20:20:28 +02:00
p.inside_if_expr = true
p.gen('(')
}
else {
p.gen('if (')
p.fgen('if ')
}
p.next()
p.check_types(p.bool_expression(), 'bool')
if is_expr {
p.gen(') ? (')
}
else {
p.genln(') {')
}
p.fgen(' ')
p.check(.lcbr)
2019-06-22 20:20:28 +02:00
mut typ := ''
// if { if hack
if p.tok == .key_if && p.inside_if_expr {
2019-06-22 20:20:28 +02:00
typ = p.factor()
p.next()
}
else {
typ = p.statements()
}
if_returns := p.returns
p.returns = false
2019-06-22 20:20:28 +02:00
// println('IF TYp=$typ')
if p.tok == .key_else {
2019-08-17 21:19:37 +02:00
p.fgenln('')
p.check(.key_else)
p.fspace()
if p.tok == .key_if {
2019-07-12 05:43:21 +02:00
if is_expr {
p.gen(') : (')
nested := p.if_st(is_expr, elif_depth + 1)
nested_returns := p.returns
p.returns = if_returns && nested_returns
return nested
2019-07-12 05:43:21 +02:00
}
else {
p.gen(' else ')
nested := p.if_st(is_expr, 0)
nested_returns := p.returns
p.returns = if_returns && nested_returns
return nested
2019-07-12 05:43:21 +02:00
}
2019-06-22 20:20:28 +02:00
// return ''
}
if is_expr {
p.gen(') : (')
}
else {
p.genln(' else { ')
}
p.check(.lcbr)
2019-06-22 20:20:28 +02:00
// statements() returns the type of the last statement
first_typ := typ
2019-06-22 20:20:28 +02:00
typ = p.statements()
p.inside_if_expr = false
if is_expr {
p.check_types(first_typ, typ)
p.gen(strings.repeat(`)`, elif_depth + 1))
2019-06-22 20:20:28 +02:00
}
else_returns := p.returns
p.returns = if_returns && else_returns
2019-06-22 20:20:28 +02:00
return typ
}
p.inside_if_expr = false
if p.fileis('test_test') {
println('if ret typ="$typ" line=$p.scanner.line_nr')
}
return typ
}
fn (p mut Parser) for_st() {
p.check(.key_for)
2019-06-22 20:20:28 +02:00
p.fgen(' ')
p.for_expr_cnt++
next_tok := p.peek()
2019-07-12 07:23:16 +02:00
//debug := p.scanner.file_path.contains('r_draw')
p.open_scope()
if p.tok == .lcbr {
2019-06-22 20:20:28 +02:00
// Infinite loop
p.gen('while (1) {')
}
else if p.tok == .key_mut {
2019-06-22 20:20:28 +02:00
p.error('`mut` is not required in for loops')
}
// for i := 0; i < 10; i++ {
else if next_tok == .decl_assign || next_tok == .assign || p.tok == .semicolon {
2019-06-22 20:20:28 +02:00
p.genln('for (')
if next_tok == .decl_assign {
2019-06-22 20:20:28 +02:00
p.var_decl()
}
else if p.tok != .semicolon {
2019-06-22 20:20:28 +02:00
// allow `for ;; i++ {`
// Allow `for i = 0; i < ...`
p.statement(false)
}
p.check(.semicolon)
2019-06-22 20:20:28 +02:00
p.gen(' ; ')
p.fgen(' ')
if p.tok != .semicolon {
2019-06-22 20:20:28 +02:00
p.bool_expression()
}
p.check(.semicolon)
2019-06-22 20:20:28 +02:00
p.gen(' ; ')
p.fgen(' ')
if p.tok != .lcbr {
2019-06-22 20:20:28 +02:00
p.statement(false)
}
p.genln(') { ')
}
// for i, val in array
else if p.peek() == .comma {
2019-09-14 22:48:30 +02:00
/*
`for i, val in array {`
==>
```
array_int tmp = array;
for (int i = 0; i < tmp.len; i++) {
int val = tmp[i];
```
*/
2019-06-22 20:20:28 +02:00
i := p.check_name()
p.check(.comma)
2019-06-22 20:20:28 +02:00
val := p.check_name()
p.fgen(' ')
p.check(.key_in)
2019-06-22 20:20:28 +02:00
p.fgen(' ')
tmp := p.get_tmp()
p.cgen.start_tmp()
typ := p.bool_expression()
2019-08-17 21:19:37 +02:00
is_arr := typ.starts_with('array_')
is_map := typ.starts_with('map_')
is_str := typ == 'string'
if !is_arr && !is_str && !is_map {
p.error('cannot range over type `$typ`')
}
2019-06-22 20:20:28 +02:00
expr := p.cgen.end_tmp()
2019-09-14 22:48:30 +02:00
if p.is_js {
p.genln('var $tmp = $expr;')
} else {
p.genln('$typ $tmp = $expr;')
}
2019-08-17 21:19:37 +02:00
pad := if is_arr { 6 } else { 4 }
var_typ := if is_str { 'byte' } else { typ.right(pad) }
2019-06-22 20:20:28 +02:00
// typ = strings.Replace(typ, "_ptr", "*", -1)
// Register temp var
val_var := Var {
name: val
typ: var_typ
ptr: typ.contains('*')
}
p.register_var(val_var)
if is_arr {
2019-07-12 07:23:16 +02:00
i_var := Var {
name: i
typ: 'int'
// parent_fn: p.cur_fn
is_mut: true
2019-08-17 21:19:37 +02:00
is_changed: true
2019-07-12 07:23:16 +02:00
}
2019-09-14 22:48:30 +02:00
//p.genln(';\nfor ($i_type $i = 0; $i < $tmp .len; $i ++) {')
p.gen_for_header(i, tmp, var_typ, val)
2019-07-12 07:23:16 +02:00
p.register_var(i_var)
}
else if is_map {
i_var := Var {
name: i
typ: 'string'
is_mut: true
2019-08-17 21:19:37 +02:00
is_changed: true
2019-07-12 07:23:16 +02:00
}
p.register_var(i_var)
2019-09-14 22:48:30 +02:00
p.gen_for_map_header(i, tmp, var_typ, val, typ)
2019-08-17 21:19:37 +02:00
}
else if is_str {
i_var := Var {
name: i
typ: 'byte'
is_mut: true
is_changed: true
}
p.register_var(i_var)
2019-09-14 22:48:30 +02:00
p.gen_for_str_header(i, tmp, var_typ, val)
}
2019-06-22 20:20:28 +02:00
}
// `for val in vals`
else if p.peek() == .key_in {
2019-06-22 20:20:28 +02:00
val := p.check_name()
p.fgen(' ')
p.check(.key_in)
2019-06-22 20:20:28 +02:00
p.fspace()
tmp := p.get_tmp()
p.cgen.start_tmp()
typ := p.bool_expression()
expr := p.cgen.end_tmp()
is_range := p.tok == .dotdot
2019-06-22 20:20:28 +02:00
mut range_end := ''
if is_range {
p.check_types(typ, 'int')
p.check_space(.dotdot)
2019-06-22 20:20:28 +02:00
p.cgen.start_tmp()
p.check_types(p.bool_expression(), 'int')
range_end = p.cgen.end_tmp()
}
is_arr := typ.contains('array')
is_str := typ == 'string'
if !is_arr && !is_str && !is_range {
2019-08-17 21:19:37 +02:00
p.error('cannot range over type `$typ`')
2019-06-22 20:20:28 +02:00
}
2019-09-14 22:48:30 +02:00
if p.is_js {
p.genln('var $tmp = $expr;')
} else {
p.genln('$typ $tmp = $expr;')
}
2019-06-22 20:20:28 +02:00
// TODO var_type := if...
mut var_type := ''
if is_arr {
var_type = typ.right(6)// all after `array_`
}
else if is_str {
var_type = 'byte'
}
else if is_range {
var_type = 'int'
}
// println('for typ=$typ vartyp=$var_typ')
// Register temp var
val_var := Var {
name: val
typ: var_type
ptr: typ.contains('*')
2019-08-17 21:19:37 +02:00
is_changed: true
2019-06-22 20:20:28 +02:00
}
p.register_var(val_var)
i := p.get_tmp()
if is_arr {
2019-09-14 22:48:30 +02:00
p.gen_for_header(i, tmp, var_type, val)
2019-06-22 20:20:28 +02:00
}
else if is_str {
2019-09-14 22:48:30 +02:00
p.gen_for_str_header(i, tmp, var_type, val)
2019-06-22 20:20:28 +02:00
}
2019-09-17 21:16:16 +02:00
else if is_range {
p.gen_for_range_header(i, range_end, tmp, var_type, val)
2019-06-22 20:20:28 +02:00
}
2019-09-14 22:48:30 +02:00
} else {
2019-06-22 20:20:28 +02:00
// `for a < b {`
p.gen('while (')
p.check_types(p.bool_expression(), 'bool')
p.genln(') {')
}
2019-08-17 21:19:37 +02:00
p.fspace()
p.check(.lcbr)
2019-08-17 21:19:37 +02:00
p.genln('')
2019-06-22 20:20:28 +02:00
p.statements()
p.close_scope()
2019-06-22 20:20:28 +02:00
p.for_expr_cnt--
p.returns = false // TODO handle loops that are guaranteed to return
2019-06-22 20:20:28 +02:00
}
fn (p mut Parser) switch_statement() {
2019-08-17 21:19:37 +02:00
if p.tok == .key_switch {
p.check(.key_switch)
2019-07-17 01:43:59 +02:00
} else {
2019-08-17 21:19:37 +02:00
p.check(.key_match)
}
2019-06-22 20:20:28 +02:00
p.cgen.start_tmp()
typ := p.bool_expression()
is_str := typ == 'string'
2019-06-22 20:20:28 +02:00
expr := p.cgen.end_tmp()
p.check(.lcbr)
2019-06-22 20:20:28 +02:00
mut i := 0
mut all_cases_return := true
2019-08-17 21:19:37 +02:00
for p.tok == .key_case || p.tok == .key_default || p.peek() == .arrow || p.tok == .key_else {
p.returns = false
2019-08-17 21:19:37 +02:00
if p.tok == .key_default || p.tok == .key_else {
2019-06-22 20:20:28 +02:00
p.genln('else { // default:')
2019-08-17 21:19:37 +02:00
if p.tok == .key_default {
p.check(.key_default)
2019-07-17 02:47:45 +02:00
p.check(.colon)
2019-08-17 21:19:37 +02:00
} else {
p.check(.key_else)
2019-07-17 02:47:45 +02:00
p.check(.arrow)
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
p.statements()
p.returns = all_cases_return && p.returns
return
2019-06-22 20:20:28 +02:00
}
if i > 0 {
p.gen('else ')
}
p.gen('if (')
// Multiple checks separated by comma
mut got_comma := false
for {
if got_comma {
if is_str {
p.gen(')')
}
p.gen(' || ')
2019-06-22 20:20:28 +02:00
}
2019-08-17 21:19:37 +02:00
if typ == 'string' {
2019-06-22 20:20:28 +02:00
p.gen('string_eq($expr, ')
}
else {
p.gen('$expr == ')
2019-06-22 20:20:28 +02:00
}
2019-08-17 21:19:37 +02:00
if p.tok == .key_case || p.tok == .key_default {
p.check(p.tok)
2019-06-22 20:20:28 +02:00
}
p.bool_expression()
if p.tok != .comma {
2019-06-22 20:20:28 +02:00
break
}
p.check(.comma)
2019-06-22 20:20:28 +02:00
got_comma = true
}
2019-08-17 21:19:37 +02:00
if p.tok == .colon {
2019-07-17 01:43:59 +02:00
p.check(.colon)
2019-08-17 21:19:37 +02:00
}
else {
p.check(.arrow)
}
if is_str {
p.gen(')')
}
p.gen(') {')
2019-06-22 20:20:28 +02:00
p.genln('/* case */')
p.statements()
all_cases_return = all_cases_return && p.returns
2019-06-22 20:20:28 +02:00
i++
}
p.returns = false // only get here when no default, so return is not guaranteed
2019-06-22 20:20:28 +02:00
}
2019-08-28 16:35:44 +02:00
// Returns typ if used as expession
2019-08-26 23:39:11 +02:00
fn (p mut Parser) match_statement(is_expr bool) string {
p.check(.key_match)
p.cgen.start_tmp()
typ := p.bool_expression()
expr := p.cgen.end_tmp()
// is it safe to use p.cgen.insert_before ???
tmp_var := p.get_tmp()
p.cgen.insert_before('$typ $tmp_var = $expr;')
p.check(.lcbr)
mut i := 0
mut all_cases_return := true
2019-08-28 16:35:44 +02:00
// stores typ of resulting variable
2019-08-26 23:39:11 +02:00
mut res_typ := ''
defer {
p.check(.rcbr)
}
for p.tok != .rcbr {
2019-08-28 16:35:44 +02:00
if p.tok == .key_else {
p.check(.key_else)
2019-08-26 23:39:11 +02:00
p.check(.arrow)
// unwrap match if there is only else
if i == 0 {
if is_expr {
// statements are dissallowed (if match is expression) so user cant declare variables there and so on
// allow braces is else
got_brace := p.tok == .lcbr
if got_brace {
p.check(.lcbr)
}
p.gen('( ')
res_typ = p.bool_expression()
p.gen(' )')
// allow braces in else
if got_brace {
p.check(.rcbr)
}
return res_typ
} else {
p.returns = false
p.check(.lcbr)
p.genln('{ ')
p.statements()
2019-08-26 23:39:11 +02:00
p.returns = all_cases_return && p.returns
return ''
}
}
if is_expr {
// statements are dissallowed (if match is expression) so user cant declare variables there and so on
p.gen(':(')
// allow braces is else
got_brace := p.tok == .lcbr
if got_brace {
p.check(.lcbr)
}
p.check_types(p.bool_expression(), res_typ)
// allow braces in else
if got_brace {
p.check(.rcbr)
}
p.gen(strings.repeat(`)`, i+1))
return res_typ
} else {
p.returns = false
2019-08-26 23:39:11 +02:00
p.genln('else // default:')
p.check(.lcbr)
p.genln('{ ')
p.statements()
2019-08-26 23:39:11 +02:00
p.returns = all_cases_return && p.returns
return ''
}
}
if i > 0 {
if is_expr {
p.gen(': (')
} else {
p.gen('else ')
}
} else if is_expr {
p.gen('(')
}
if is_expr {
p.gen('(')
} else {
p.gen('if (')
}
// Multiple checks separated by comma
mut got_comma := false
for {
if got_comma {
p.gen(') || (')
}
2019-08-28 16:35:44 +02:00
if typ == 'string' {
2019-08-26 23:39:11 +02:00
// TODO: use tmp variable
// p.gen('string_eq($tmp_var, ')
p.gen('string_eq($tmp_var, ')
}
else {
// TODO: use tmp variable
// p.gen('($tmp_var == ')
p.gen('($tmp_var == ')
}
p.expected_type = typ
p.check_types(p.bool_expression(), typ)
p.expected_type = ''
if p.tok != .comma {
if got_comma {
p.gen(') ')
}
2019-08-26 23:39:11 +02:00
break
}
p.check(.comma)
got_comma = true
}
p.gen(') )')
p.check(.arrow)
// statements are dissallowed (if match is expression) so user cant declare variables there and so on
if is_expr {
p.gen('? (')
// braces are required for now
p.check(.lcbr)
if i == 0 {
// on the first iteration we set value of res_typ
res_typ = p.bool_expression()
} else {
// later on we check that the value is of res_typ type
p.check_types(p.bool_expression(), res_typ)
}
// braces are required for now
p.check(.rcbr)
p.gen(')')
}
else {
p.returns = false
p.check(.lcbr)
p.genln('{ ')
p.statements()
all_cases_return = all_cases_return && p.returns
2019-08-26 23:39:11 +02:00
// p.gen(')')
}
i++
}
if is_expr {
// we get here if no else found, ternary requires "else" branch
p.error('Match expession requires "else"')
}
p.returns = false // only get here when no default, so return is not guaranteed
return ''
}
2019-06-22 20:20:28 +02:00
fn (p mut Parser) assert_statement() {
2019-07-29 18:21:36 +02:00
if p.first_pass() {
2019-08-17 21:19:37 +02:00
return
}
p.check(.key_assert)
2019-06-22 20:20:28 +02:00
p.fspace()
tmp := p.get_tmp()
p.gen('bool $tmp = ')
p.check_types(p.bool_expression(), 'bool')
// TODO print "expected: got" for failed tests
2019-07-31 19:01:52 +02:00
filename := p.file_path.replace('\\', '\\\\')
2019-08-17 21:19:37 +02:00
p.genln(';\n
2019-07-31 19:01:52 +02:00
if (!$tmp) {
println(tos2((byte *)"\\x1B[31mFAILED: $p.cur_fn.name() in $filename:$p.scanner.line_nr\\x1B[0m"));
2019-08-17 21:19:37 +02:00
g_test_ok = 0 ;
2019-06-22 20:20:28 +02:00
// TODO
2019-08-17 21:19:37 +02:00
// Maybe print all vars in a test function if it fails?
}
else {
//puts("\\x1B[32mPASSED: $p.cur_fn.name()\\x1B[0m");
2019-06-22 20:20:28 +02:00
}')
}
fn (p mut Parser) return_st() {
2019-07-15 16:15:34 +02:00
p.check(.key_return)
2019-08-17 21:19:37 +02:00
p.fgen(' ')
2019-06-22 20:20:28 +02:00
fn_returns := p.cur_fn.typ != 'void'
if fn_returns {
if p.tok == .rcbr {
2019-06-22 20:20:28 +02:00
p.error('`$p.cur_fn.name` needs to return `$p.cur_fn.typ`')
}
else {
ph := p.cgen.add_placeholder()
p.inside_return_expr = true
is_none := p.tok == .key_none
p.expected_type = p.cur_fn.typ
2019-06-22 20:20:28 +02:00
expr_type := p.bool_expression()
p.inside_return_expr = false
// Automatically wrap an object inside an option if the function
// returns an option
if p.cur_fn.typ.ends_with(expr_type) && !is_none &&
p.cur_fn.typ.starts_with('Option_') {
2019-07-15 16:15:34 +02:00
tmp := p.get_tmp()
ret := p.cgen.cur_line.right(ph)
2019-08-17 21:19:37 +02:00
typ := expr_type.replace('Option_', '')
p.cgen.cur_line = '$expr_type $tmp = OPTION_CAST($typ)($ret);'
p.cgen.resetln('$expr_type $tmp = OPTION_CAST($expr_type)($ret);')
p.gen('return opt_ok(&$tmp, sizeof($typ))')
2019-07-15 16:15:34 +02:00
}
else {
ret := p.cgen.cur_line.right(ph)
// @emily33901: Scoped defer
// Check all of our defer texts to see if there is one at a higher scope level
// The one for our current scope would be the last so any before that need to be
// added.
mut total_text := ''
for text in p.cur_fn.defer_text {
if text != '' {
// In reverse order
total_text = text + total_text
}
}
if total_text == '' || expr_type == 'void*' {
if expr_type == '${p.cur_fn.typ}*' {
p.cgen.resetln('return *$ret')
} else {
p.cgen.resetln('return $ret')
}
2019-08-17 21:19:37 +02:00
} else {
tmp := p.get_tmp()
2019-07-26 16:45:16 +02:00
p.cgen.resetln('$expr_type $tmp = $ret;\n')
p.genln(total_text)
2019-08-17 21:19:37 +02:00
p.genln('return $tmp;')
}
2019-06-22 20:20:28 +02:00
}
p.check_types(expr_type, p.cur_fn.typ)
}
}
else {
// Don't allow `return val` in functions that don't return anything
2019-08-17 21:19:37 +02:00
if !p.is_vweb && (p.tok == .name || p.tok == .number || p.tok == .str) {
p.error('function `$p.cur_fn.name` should not return a value')
2019-06-22 20:20:28 +02:00
}
if p.cur_fn.name == 'main' {
p.gen('return 0')
}
else {
p.gen('return')
}
2019-06-22 20:20:28 +02:00
}
p.returns = true
}
fn prepend_mod(mod, name string) string {
return '${mod}__${name}'
2019-06-22 20:20:28 +02:00
}
fn (p &Parser) prepend_mod(name string) string {
return prepend_mod(p.mod, name)
2019-06-22 20:20:28 +02:00
}
fn (p mut Parser) go_statement() {
p.check(.key_go)
2019-06-22 20:20:28 +02:00
// TODO copypasta of name_expr() ?
// Method
if p.peek() == .dot {
2019-06-22 20:20:28 +02:00
var_name := p.lit
v := p.cur_fn.find_var(var_name) or { return }
p.mark_var_used(v)
2019-06-22 20:20:28 +02:00
p.next()
p.check(.dot)
2019-06-22 20:20:28 +02:00
typ := p.table.find_type(v.typ)
2019-09-18 14:37:34 +02:00
method := p.table.find_method(typ, p.lit) or { panic('go method') }
2019-06-22 20:20:28 +02:00
p.async_fn_call(method, 0, var_name, v.typ)
}
// Normal function
else {
2019-09-18 14:06:34 +02:00
f := p.table.find_fn(p.lit) or { panic('fn') }
2019-09-19 16:25:00 +02:00
if f.name == 'println' || f.name == 'print' {
2019-06-22 20:20:28 +02:00
p.error('`go` cannot be used with `println`')
}
p.async_fn_call(f, 0, '', '')
}
}
fn (p mut Parser) register_var(v Var) {
2019-06-22 20:20:28 +02:00
if v.line_nr == 0 {
spos := p.scanner.get_scanner_pos()
p.cur_fn.register_var({ v | scanner_pos: spos, line_nr: spos.line_nr })
2019-08-17 21:19:37 +02:00
} else {
p.cur_fn.register_var(v)
2019-08-17 21:19:37 +02:00
}
2019-06-22 20:20:28 +02:00
}
// user:=jsdecode(User, user_json_string)
fn (p mut Parser) js_decode() string {
p.check(.name)// json
p.check(.dot)
2019-06-22 20:20:28 +02:00
op := p.check_name()
if op == 'decode' {
// User tmp2; tmp2.foo = 0; tmp2.bar = 0;// I forgot to zero vals before => huge bug
// Option_User tmp3 = jsdecode_User(json_parse( s), &tmp2); ;
// if (!tmp3 .ok) {
// return
// }
// User u = *(User*) tmp3 . data; // TODO remove this (generated in or {} block handler)
p.check(.lpar)
2019-06-22 20:20:28 +02:00
typ := p.get_type()
p.check(.comma)
2019-06-22 20:20:28 +02:00
p.cgen.start_tmp()
p.check_types(p.bool_expression(), 'string')
expr := p.cgen.end_tmp()
p.check(.rpar)
2019-06-22 20:20:28 +02:00
tmp := p.get_tmp()
cjson_tmp := p.get_tmp()
mut decl := '$typ $tmp; '
// Init the struct
T := p.table.find_type(typ)
for field in T.fields {
def_val := type_default(field.typ)
if def_val != '' {
2019-08-04 13:28:59 +02:00
decl += '$tmp . $field.name = OPTION_CAST($field.typ) $def_val;\n'
2019-06-22 20:20:28 +02:00
}
}
p.gen_json_for_type(T)
decl += 'cJSON* $cjson_tmp = json__json_parse($expr);'
p.cgen.insert_before(decl)
// p.gen('jsdecode_$typ(json_parse($expr), &$tmp);')
p.gen('json__jsdecode_$typ($cjson_tmp, &$tmp); cJSON_Delete($cjson_tmp);')
opt_type := 'Option_$typ'
p.cgen.typedefs << 'typedef Option $opt_type;'
p.table.register_type(opt_type)
return opt_type
}
else if op == 'encode' {
p.check(.lpar)
2019-06-22 20:20:28 +02:00
p.cgen.start_tmp()
typ := p.bool_expression()
T := p.table.find_type(typ)
p.gen_json_for_type(T)
expr := p.cgen.end_tmp()
p.check(.rpar)
2019-06-22 20:20:28 +02:00
p.gen('json__json_print(json__jsencode_$typ($expr))')
return 'string'
}
else {
p.error('bad json op "$op"')
}
return ''
}
2019-07-07 21:46:21 +02:00
fn (p mut Parser) attribute() {
p.check(.lsbr)
if p.tok == .key_interface {
p.check(.key_interface)
p.check(.colon)
p.attr = 'interface:' + p.check_name()
} else {
p.attr = p.check_name()
}
2019-08-17 21:19:37 +02:00
p.check(.rsbr)
if p.tok == .func || (p.tok == .key_pub && p.peek() == .func) {
2019-08-17 21:19:37 +02:00
p.fn_decl()
p.attr = ''
return
}
else if p.tok == .key_struct {
2019-08-17 21:19:37 +02:00
p.struct_decl()
p.attr = ''
return
}
p.error('bad attribute usage')
}
2019-07-07 21:46:21 +02:00
2019-07-15 22:09:34 +02:00
fn (p mut Parser) defer_st() {
p.check(.key_defer)
2019-08-17 21:19:37 +02:00
p.check(.lcbr)
2019-07-30 18:05:06 +02:00
2019-08-17 21:19:37 +02:00
pos := p.cgen.lines.len
2019-07-30 18:05:06 +02:00
// Save everything inside the defer block to `defer_text`.
// It will be inserted before every `return`
// Emily: TODO: all variables that are used in this defer statement need to be evaluated when the block
// is defined otherwise they could change over the course of the function
// (make temps out of them)
2019-08-17 21:19:37 +02:00
p.genln('{')
p.statements()
p.cur_fn.defer_text.last() = p.cgen.lines.right(pos).join('\n') + p.cur_fn.defer_text.last()
2019-07-30 18:05:06 +02:00
// Rollback p.cgen.lines
p.cgen.lines = p.cgen.lines.left(pos)
p.cgen.resetln('')
2019-08-17 21:19:37 +02:00
}
2019-07-15 22:09:34 +02:00