v/vlib/v/parser/parser.v

1709 lines
38 KiB
V
Raw Normal View History

2020-01-23 21:04:46 +01:00
// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
2019-12-22 02:34:37 +01:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module parser
2020-04-14 19:32:23 +02:00
import v.scanner
import v.ast
import v.token
import v.table
import v.pref
import v.util
import v.errors
2020-04-14 19:32:23 +02:00
import os
2020-05-22 02:22:56 +02:00
import runtime
import time
import strconv
pub struct Parser {
2020-04-10 12:01:06 +02:00
file_name string // "/home/user/hello.v"
file_name_dir string // "/home/user"
2019-12-22 02:34:37 +01:00
mut:
scanner &scanner.Scanner
comments_mode scanner.CommentsMode = .skip_comments // see comment in parse_file
tok token.Token
2020-04-18 00:22:03 +02:00
prev_tok token.Token
peek_tok token.Token
peek_tok2 token.Token
peek_tok3 token.Token
table &table.Table
language table.Language
inside_if bool
inside_if_expr bool
inside_or_expr bool
2020-04-08 19:08:54 +02:00
inside_for bool
inside_fn bool
inside_str_interp bool
pref &pref.Preferences
builtin_mod bool // are we in the `builtin` module?
mod string // current module name
attrs []string // attributes before next decl stmt
attr_ctdefine string
2020-05-04 16:46:36 +02:00
expr_mod string // for constructing full type names in parse_type()
scope &ast.Scope
global_scope &ast.Scope
2020-05-14 17:14:24 +02:00
imports map[string]string // alias => mod_name
ast_imports []ast.Import // mod_names
used_imports []string // alias
2020-05-09 15:23:48 +02:00
is_amp bool // for generating the right code for `&Foo{}`
returns bool
2020-04-15 16:23:03 +02:00
inside_match bool // to separate `match A { }` from `Struct{}`
inside_match_case bool // to separate `match_expr { }` from `Struct{}`
2020-05-12 00:26:39 +02:00
inside_match_body bool // to fix eval not used TODO
inside_unsafe bool
is_stmt_ident bool // true while the beginning of a statement is an ident/selector
2020-05-05 14:19:31 +02:00
expecting_type bool // `is Type`, expecting type
errors []errors.Error
warnings []errors.Warning
2020-06-06 21:36:24 +02:00
cur_fn_name string
2019-12-22 02:34:37 +01:00
}
// for tests
pub fn parse_stmt(text string, table &table.Table, scope &ast.Scope) ast.Stmt {
s := scanner.new_scanner(text, .skip_comments, false)
mut p := Parser{
2019-12-22 02:34:37 +01:00
scanner: s
table: table
2020-02-07 22:10:48 +01:00
pref: &pref.Preferences{}
scope: scope
global_scope: &ast.Scope{
start_pos: 0
parent: 0
}
2019-12-22 02:34:37 +01:00
}
2020-01-06 16:13:12 +01:00
p.init_parse_fns()
p.read_first_token()
return p.stmt(false)
2019-12-22 02:34:37 +01:00
}
2020-06-09 18:47:51 +02:00
pub fn parse_text(text string, b_table &table.Table, pref &pref.Preferences, scope, global_scope &ast.Scope) ast.File {
s := scanner.new_scanner(text, .skip_comments, pref.is_fmt)
mut p := Parser{
scanner: s
table: b_table
2020-06-09 18:47:51 +02:00
pref: pref
scope: scope
errors: []errors.Error{}
warnings: []errors.Warning{}
global_scope: global_scope
}
return p.parse()
}
pub fn parse_file(path string, b_table &table.Table, comments_mode scanner.CommentsMode, pref &pref.Preferences, global_scope &ast.Scope) ast.File {
// NB: when comments_mode == .toplevel_comments,
// the parser gives feedback to the scanner about toplevel statements, so that the scanner can skip
// all the tricky inner comments. This is needed because we do not have a good general solution
// for handling them, and should be removed when we do (the general solution is also needed for vfmt)
2020-02-29 17:51:35 +01:00
// println('parse_file("$path")')
2020-02-29 17:53:04 +01:00
// text := os.read_file(path) or {
// panic(err)
// }
mut p := Parser{
scanner: scanner.new_scanner_file(path, comments_mode, pref.is_fmt)
comments_mode: comments_mode
table: b_table
2020-01-01 10:15:05 +01:00
file_name: path
file_name_dir: os.dir(path)
2020-04-05 04:05:09 +02:00
pref: pref
2020-02-16 11:48:29 +01:00
scope: &ast.Scope{
start_pos: 0
2020-06-09 09:08:11 +02:00
parent: global_scope
}
errors: []errors.Error{}
warnings: []errors.Warning{}
global_scope: global_scope
}
if pref.is_vet && p.scanner.text.contains('\n ') {
// TODO make this smarter
println(p.scanner.file_path)
println('Looks like you are using spaces for indentation.\n' + 'You can run `v fmt -w file.v` to fix that automatically')
exit(1)
}
return p.parse()
}
fn (mut p Parser) parse() ast.File {
2020-04-05 04:05:09 +02:00
// comments_mode: comments_mode
p.init_parse_fns()
2019-12-28 14:11:05 +01:00
p.read_first_token()
mut stmts := []ast.Stmt{}
for p.tok.kind == .comment {
2020-05-18 17:02:29 +02:00
stmts << p.comment()
}
// module
module_decl := p.module_decl()
stmts << module_decl
// imports
for {
if p.tok.kind == .key_import {
stmts << p.import_stmt()
continue
}
if p.tok.kind == .comment {
stmts << p.comment()
continue
}
break
}
for {
if p.tok.kind == .eof {
p.check_unused_imports()
break
}
2020-01-06 16:13:12 +01:00
// println('stmt at ' + p.tok.str())
stmt := p.top_stmt()
// clear the attribtes at the end of next non Attr top level stmt
if stmt !is ast.Attr {
p.attrs = []
p.attr_ctdefine = ''
}
stmts << stmt
}
// println('nr stmts = $stmts.len')
2019-12-28 14:11:05 +01:00
// println(stmts[0])
p.scope.end_pos = p.tok.pos
//
2019-12-30 12:10:46 +01:00
return ast.File{
path: p.file_name
mod: module_decl
2020-02-29 17:51:35 +01:00
imports: p.ast_imports
stmts: stmts
scope: p.scope
global_scope: p.global_scope
errors: p.errors
warnings: p.warnings
2019-12-28 14:11:05 +01:00
}
}
2020-05-31 10:22:18 +02:00
/*
struct Queue {
mut:
idx int
2020-05-22 02:22:56 +02:00
mu &sync.Mutex
mu2 &sync.Mutex
paths []string
table &table.Table
parsed_ast_files []ast.File
2020-05-22 02:22:56 +02:00
pref &pref.Preferences
global_scope &ast.Scope
}
2020-05-22 02:22:56 +02:00
fn (mut q Queue) run() {
for {
q.mu.lock()
idx := q.idx
if idx >= q.paths.len {
q.mu.unlock()
return
}
q.idx++
q.mu.unlock()
2020-05-22 02:22:56 +02:00
println('run(idx=$idx)')
path := q.paths[idx]
file := parse_file(path, q.table, .skip_comments, q.pref, q.global_scope)
q.mu2.lock()
q.parsed_ast_files << file
q.mu2.unlock()
println('run done(idx=$idx)')
}
}
2020-05-31 10:22:18 +02:00
*/
pub fn parse_files(paths []string, table &table.Table, pref &pref.Preferences, global_scope &ast.Scope) []ast.File {
2020-05-22 02:22:56 +02:00
// println('nr_cpus= $nr_cpus')
$if macos {
2020-05-31 10:22:18 +02:00
/*
if pref.is_parallel && paths[0].contains('/array.v') {
println('\n\n\nparse_files() nr_files=$paths.len')
println(paths)
nr_cpus := runtime.nr_cpus()
mut q := &Queue{
paths: paths
table: table
pref: pref
global_scope: global_scope
mu: sync.new_mutex()
mu2: sync.new_mutex()
}
for _ in 0 .. nr_cpus - 1 {
go q.run()
}
time.sleep_ms(1000)
println('all done')
return q.parsed_ast_files
2020-05-22 02:22:56 +02:00
}
2020-05-31 10:22:18 +02:00
*/
}
if false {
// TODO: remove this; it just prevents warnings about unused time and runtime
2020-05-23 08:51:15 +02:00
time.sleep_ms(1)
println(runtime.nr_cpus())
}
// ///////////////
mut files := []ast.File{}
2019-12-30 12:10:46 +01:00
for path in paths {
2020-03-27 08:46:54 +01:00
// println('parse_files $path')
files << parse_file(path, table, .skip_comments, pref, global_scope)
2019-12-30 12:10:46 +01:00
}
return files
}
pub fn (mut p Parser) init_parse_fns() {
if p.comments_mode == .toplevel_comments {
p.scanner.scan_all_tokens_in_buffer()
}
2020-01-07 01:57:38 +01:00
// p.prefix_parse_fns = make(100, 100, sizeof(PrefixParseFn))
2020-01-06 16:13:12 +01:00
// p.prefix_parse_fns[token.Kind.name] = parse_name
}
pub fn (mut p Parser) read_first_token() {
// need to call next() 4 times to get peek token 1,2,3 and current token
p.next()
p.next()
2019-12-28 14:11:05 +01:00
p.next()
p.next()
}
pub fn (mut p Parser) open_scope() {
p.scope = &ast.Scope{
parent: p.scope
start_pos: p.tok.pos
}
}
pub fn (mut p Parser) close_scope() {
p.scope.end_pos = p.tok.pos
p.scope.parent.children << p.scope
p.scope = p.scope.parent
}
pub fn (mut p Parser) parse_block() []ast.Stmt {
p.open_scope()
// println('parse block')
stmts := p.parse_block_no_scope(false)
p.close_scope()
// println('nr exprs in block = $exprs.len')
return stmts
}
pub fn (mut p Parser) parse_block_no_scope(is_top_level bool) []ast.Stmt {
2019-12-31 19:42:16 +01:00
p.check(.lcbr)
mut stmts := []ast.Stmt{}
2020-01-06 16:13:12 +01:00
if p.tok.kind != .rcbr {
for {
stmts << p.stmt(is_top_level)
2020-01-06 16:13:12 +01:00
// p.warn('after stmt(): tok=$p.tok.str()')
if p.tok.kind in [.eof, .rcbr] {
break
}
2019-12-27 13:57:49 +01:00
}
}
if is_top_level {
p.top_level_statement_end()
}
2019-12-31 19:42:16 +01:00
p.check(.rcbr)
2019-12-28 14:11:05 +01:00
return stmts
2019-12-27 13:57:49 +01:00
}
2020-04-05 02:08:10 +02:00
/*
2020-04-23 01:16:58 +02:00
fn (mut p Parser) next_with_comment() {
2020-04-05 02:08:10 +02:00
p.tok = p.peek_tok
p.peek_tok = p.scanner.scan()
}
*/
fn (mut p Parser) next() {
2020-04-18 00:22:03 +02:00
p.prev_tok = p.tok
p.tok = p.peek_tok
p.peek_tok = p.peek_tok2
p.peek_tok2 = p.peek_tok3
p.peek_tok3 = p.scanner.scan()
2020-04-05 02:08:10 +02:00
/*
if p.tok.kind==.comment {
p.comments << ast.Comment{text:p.tok.lit, line_nr:p.tok.line_nr}
p.next()
}
2020-04-25 17:49:16 +02:00
*/
2019-12-22 02:34:37 +01:00
}
fn (mut p Parser) check(expected token.Kind) {
2020-02-29 17:51:35 +01:00
// for p.tok.kind in [.line_comment, .mline_comment] {
// p.next()
// }
if p.tok.kind != expected {
if p.tok.kind == .name {
p.error('unexpected name `$p.tok.lit`, expecting `$expected.str()`')
} else {
p.error('unexpected `$p.tok.kind.str()`, expecting `$expected.str()`')
}
2019-12-27 13:57:49 +01:00
}
p.next()
}
// JS functions can have multiple dots in their name:
// JS.foo.bar.and.a.lot.more.dots()
fn (mut p Parser) check_js_name() string {
mut name := ''
for p.peek_tok.kind == .dot {
name += '${p.tok.lit}.'
p.next() // .name
p.next() // .dot
}
2020-05-16 16:12:23 +02:00
// last .name
name += p.tok.lit
p.next()
return name
}
fn (mut p Parser) check_name() string {
name := p.tok.lit
2020-05-14 17:14:24 +02:00
if p.peek_tok.kind == .dot && name in p.imports {
p.register_used_import(name)
}
2019-12-27 13:57:49 +01:00
p.check(.name)
return name
}
pub fn (mut p Parser) top_stmt() ast.Stmt {
match p.tok.kind {
2019-12-31 19:42:16 +01:00
.key_pub {
match p.peek_tok.kind {
.key_const {
return p.const_decl()
}
2019-12-31 19:42:16 +01:00
.key_fn {
return p.fn_decl()
}
2020-04-02 12:53:15 +02:00
.key_struct, .key_union {
2019-12-31 19:42:16 +01:00
return p.struct_decl()
}
2020-04-02 12:53:15 +02:00
.key_interface {
return p.interface_decl()
}
.key_enum {
return p.enum_decl()
}
.key_type {
return p.type_decl()
}
2019-12-31 19:42:16 +01:00
else {
p.error('wrong pub keyword usage')
return ast.Stmt{}
}
}
}
.lsbr {
attrs := p.attributes(true)
return attrs[0]
}
.key_interface {
return p.interface_decl()
}
2020-02-29 17:51:35 +01:00
.key_import {
p.error_with_pos('`import x` can only be declared at the beginning of the file',
p.tok.position())
2020-05-07 04:32:29 +02:00
return p.import_stmt()
2020-02-29 17:51:35 +01:00
}
.key_global {
return p.global_decl()
}
.key_const {
return p.const_decl()
2019-12-31 19:42:16 +01:00
}
2019-12-28 09:43:22 +01:00
.key_fn {
return p.fn_decl()
}
.key_struct {
return p.struct_decl()
}
.dollar {
2020-05-27 03:33:37 +02:00
return p.comp_if()
2020-01-07 13:10:05 +01:00
}
2020-02-04 09:54:15 +01:00
.hash {
return p.hash()
}
2020-02-12 01:16:38 +01:00
.key_type {
return p.type_decl()
}
.key_enum {
return p.enum_decl()
}
.key_union {
return p.struct_decl()
}
2020-04-05 02:08:10 +02:00
.comment {
return p.comment()
2020-02-18 20:20:15 +01:00
}
2020-01-06 16:13:12 +01:00
else {
2020-04-09 12:46:16 +02:00
if p.pref.is_script && !p.pref.is_test {
2020-05-13 14:02:04 +02:00
mut stmts := []ast.Stmt{}
for p.tok.kind != .eof {
stmts << p.stmt(false)
2020-05-13 14:02:04 +02:00
}
return ast.FnDecl{
name: 'main.main'
mod: 'main'
2020-05-13 14:02:04 +02:00
stmts: stmts
file: p.file_name
return_type: table.void_type
}
} else {
2020-04-09 12:46:16 +02:00
p.error('bad top level statement ' + p.tok.str())
return ast.Stmt{}
}
2019-12-28 09:43:22 +01:00
}
2020-01-06 16:13:12 +01:00
}
}
2020-04-05 02:08:10 +02:00
// TODO [if vfmt]
pub fn (mut p Parser) check_comment() ast.Comment {
2020-04-05 02:08:10 +02:00
if p.tok.kind == .comment {
return p.comment()
}
return ast.Comment{}
2020-04-05 02:08:10 +02:00
}
pub fn (mut p Parser) comment() ast.Comment {
pos := p.tok.position()
2020-02-29 17:51:35 +01:00
text := p.tok.lit
p.next()
// p.next_with_comment()
2020-04-05 02:08:10 +02:00
return ast.Comment{
is_multi: text.contains('\n')
2020-02-29 17:51:35 +01:00
text: text
pos: pos
2020-02-29 17:51:35 +01:00
}
}
pub fn (mut p Parser) eat_comments() []ast.Comment {
mut comments := []ast.Comment{}
for {
if p.tok.kind != .comment {
break
}
comments << p.check_comment()
}
return comments
}
pub fn (mut p Parser) stmt(is_top_level bool) ast.Stmt {
p.is_stmt_ident = p.tok.kind == .name
2020-01-06 16:13:12 +01:00
match p.tok.kind {
2020-03-24 15:44:17 +01:00
.lcbr {
stmts := p.parse_block()
return ast.Block{
stmts: stmts
}
}
.key_assert {
p.next()
assert_pos := p.tok.position()
expr := p.expr(0)
return ast.AssertStmt{
expr: expr
pos: assert_pos
}
}
.key_for {
2020-04-08 19:08:54 +02:00
return p.for_stmt()
}
.name, .key_mut, .key_static, .mul {
if p.tok.kind == .name {
2020-06-19 16:43:32 +02:00
if p.tok.lit == 'sql' {
return p.sql_stmt()
2020-06-19 16:43:32 +02:00
}
if p.peek_tok.kind == .colon {
// `label:`
name := p.check_name()
p.next()
return ast.GotoLabel{
name: name
}
2020-06-18 20:21:08 +02:00
} else if p.peek_tok.kind == .name {
p.error_with_pos('unexpected name `$p.peek_tok.lit`', p.peek_tok.position())
2020-06-18 20:21:08 +02:00
} else if !p.inside_if_expr && !p.inside_match_body && !p.inside_or_expr &&
p.peek_tok.kind in [.rcbr, .eof] {
p.error_with_pos('`$p.tok.lit` evaluated but not used', p.tok.position())
2020-05-12 17:18:25 +02:00
}
}
return p.parse_multi_expr(is_top_level)
2020-05-12 17:18:25 +02:00
}
2020-04-05 02:08:10 +02:00
.comment {
return p.comment()
2020-02-29 17:51:35 +01:00
}
2020-01-06 16:13:12 +01:00
.key_return {
return p.return_stmt()
}
.dollar {
2020-05-27 03:33:37 +02:00
if p.peek_tok.kind == .key_if {
return p.comp_if()
} else if p.peek_tok.kind == .key_for {
return p.comp_for()
2020-05-27 03:33:37 +02:00
} else if p.peek_tok.kind == .name {
return ast.ExprStmt{
expr: p.vweb()
}
}
}
.key_continue, .key_break {
tok := p.tok
p.next()
return ast.BranchStmt{
2020-02-18 03:28:39 +01:00
tok: tok
}
}
.key_unsafe {
p.next()
p.inside_unsafe = true
2020-02-26 20:45:03 +01:00
stmts := p.parse_block()
p.inside_unsafe = false
2020-02-26 20:45:03 +01:00
return ast.UnsafeStmt{
stmts: stmts
}
}
2020-03-19 07:59:01 +01:00
.hash {
return p.hash()
}
2020-02-11 10:26:46 +01:00
.key_defer {
p.next()
stmts := p.parse_block()
return ast.DeferStmt{
stmts: stmts
}
}
.key_go {
p.next()
2020-04-03 15:18:17 +02:00
expr := p.expr(0)
// mut call_expr := &ast.CallExpr(0) // TODO
2020-04-20 08:44:14 +02:00
// { call_expr = it }
2020-04-03 15:18:17 +02:00
match expr {
2020-04-20 08:44:14 +02:00
ast.CallExpr {}
2020-04-16 12:17:15 +02:00
else {}
2020-04-03 15:18:17 +02:00
}
return ast.GoStmt{
2020-04-03 15:18:17 +02:00
call_expr: expr
}
}
2020-02-17 14:15:42 +01:00
.key_goto {
p.next()
name := p.check_name()
return ast.GotoStmt{
name: name
}
}
2020-05-15 23:14:53 +02:00
.key_const {
2020-05-16 16:12:23 +02:00
p.error_with_pos('const can only be defined at the top level (outside of functions)',
p.tok.position())
2020-05-15 23:14:53 +02:00
}
// literals, 'if', etc. in here
2019-12-28 14:11:05 +01:00
else {
return p.parse_multi_expr(is_top_level)
2019-12-28 14:11:05 +01:00
}
}
}
fn (mut p Parser) expr_list() []ast.Expr {
mut exprs := []ast.Expr{}
for {
exprs << p.expr(0)
if p.tok.kind != .comma {
break
}
p.next()
}
return exprs
}
// when is_top_stmt is true attrs are added to p.attrs
fn (mut p Parser) attributes(is_top_stmt bool) []ast.Attr {
mut attrs := []ast.Attr{}
p.check(.lsbr)
for p.tok.kind != .rsbr {
start_pos := p.tok.position()
attr := p.parse_attr()
if attr in attrs || (is_top_stmt && attr.name in p.attrs) {
p.error_with_pos('duplicate attribute `$attr.name`', start_pos.extend(p.prev_tok.position()))
}
if is_top_stmt {
p.attrs << attr.name
}
attrs << attr
if p.tok.kind != .semicolon {
expected := `;`
if p.tok.kind == .rsbr {
p.next()
break
}
2020-06-18 20:21:08 +02:00
p.error('unexpected `$p.tok.kind.str()`, expecting `$expected.str()`')
}
p.next()
}
if attrs.len == 0 {
p.error_with_pos('attributes cannot be empty', p.prev_tok.position().extend(p.tok.position()))
}
return attrs
}
fn (mut p Parser) parse_attr() ast.Attr {
mut is_if_attr := false
if p.tok.kind == .key_if {
p.next()
is_if_attr = true
}
mut name := ''
if p.tok.kind == .string {
name = p.tok.lit
p.next()
} else {
mut name = p.check_name()
if p.tok.kind == .colon {
name += ':'
p.next()
if p.tok.kind == .name {
name += p.check_name()
} else if p.tok.kind == .string {
name += p.tok.lit
p.next()
}
}
}
if is_if_attr {
p.attr_ctdefine = name
}
return ast.Attr{
name: name
}
}
/*
2020-04-23 01:16:58 +02:00
fn (mut p Parser) range_expr(low ast.Expr) ast.Expr {
2020-02-02 14:31:54 +01:00
// ,table.Type) {
if p.tok.kind != .dotdot {
p.next()
}
p.check(.dotdot)
2020-02-07 07:34:18 +01:00
mut high := ast.Expr{}
if p.tok.kind != .rsbr {
high = p.expr(0)
2020-02-07 07:34:18 +01:00
// if typ.typ.kind != .int {
// p.error('non-integer index `$typ.typ.name`')
// }
2020-02-02 14:31:54 +01:00
}
node := ast.RangeExpr{
low: low
high: high
}
return node
}
*/
pub fn (mut p Parser) error(s string) {
p.error_with_pos(s, p.tok.position())
}
pub fn (mut p Parser) warn(s string) {
p.warn_with_pos(s, p.tok.position())
}
pub fn (mut p Parser) error_with_pos(s string, pos token.Position) {
mut kind := 'error:'
if p.pref.output_mode == .stdout {
if p.pref.is_verbose {
print_backtrace()
kind = 'parser error:'
}
ferror := util.formatted_error(kind, s, p.file_name, pos)
eprintln(ferror)
exit(1)
} else {
p.errors << errors.Error{
file_path: p.file_name
pos: pos
reporter: .parser
message: s
}
}
2019-12-30 09:38:12 +01:00
}
pub fn (mut p Parser) warn_with_pos(s string, pos token.Position) {
if p.pref.skip_warnings {
return
}
if p.pref.output_mode == .stdout {
ferror := util.formatted_error('warning:', s, p.file_name, pos)
eprintln(ferror)
} else {
p.warnings << errors.Warning{
file_path: p.file_name
pos: pos
reporter: .parser
message: s
}
}
}
fn (mut p Parser) parse_multi_expr(is_top_level bool) ast.Stmt {
2020-05-15 23:14:53 +02:00
// in here might be 1) multi-expr 2) multi-assign
// 1, a, c ... } // multi-expression
// a, mut b ... :=/= // multi-assign
// collect things upto hard boundaries
tok := p.tok
left := p.expr_list()
left0 := left[0]
if p.tok.kind in [.assign, .decl_assign] || p.tok.kind.is_assign() {
return p.partial_assign_stmt(left)
2020-06-24 14:35:00 +02:00
} else if is_top_level && tok.kind !in [.key_if, .key_match] &&
left0 !is ast.CallExpr && left0 !is ast.PostfixExpr && !(left0 is ast.InfixExpr &&
(left0 as ast.InfixExpr).op == .left_shift) &&
2020-06-18 20:21:08 +02:00
left0 !is ast.ComptimeCall {
p.error_with_pos('expression evaluated but not used', left0.position())
}
if left.len == 1 {
2020-05-21 22:35:43 +02:00
return ast.ExprStmt{
expr: left0
pos: tok.position()
is_expr: p.inside_for
2020-05-18 18:33:27 +02:00
}
}
return ast.ExprStmt{
expr: ast.ConcatExpr{
vals: left
2020-05-15 23:14:53 +02:00
}
pos: tok.position()
2020-05-15 23:14:53 +02:00
}
}
pub fn (mut p Parser) parse_ident(language table.Language) ast.Ident {
2020-02-06 17:38:02 +01:00
// p.warn('name ')
2020-05-15 23:14:53 +02:00
is_mut := p.tok.kind == .key_mut
if is_mut {
p.next()
}
2020-05-15 23:14:53 +02:00
is_static := p.tok.kind == .key_static
if is_static {
p.next()
}
2020-05-15 23:14:53 +02:00
if p.tok.kind == .name {
pos := p.tok.position()
mut name := p.check_name()
if name == '_' {
return ast.Ident{
name: '_'
kind: .blank_ident
pos: pos
2020-05-16 16:12:23 +02:00
info: ast.IdentVar{
2020-05-15 23:14:53 +02:00
is_mut: false
is_static: false
}
}
}
2020-06-19 11:46:08 +02:00
if p.inside_match_body && name == 'it' {
// p.warn('it')
}
2020-05-15 23:14:53 +02:00
if p.expr_mod.len > 0 {
name = '${p.expr_mod}.$name'
}
return ast.Ident{
2020-05-15 23:14:53 +02:00
kind: .unresolved
name: name
language: language
2020-05-15 23:14:53 +02:00
mod: p.mod
pos: pos
is_mut: is_mut
info: ast.IdentVar{
is_mut: is_mut
is_static: is_static
}
2020-05-15 23:14:53 +02:00
}
} else {
p.error('unexpected token `$p.tok.lit`')
2020-02-06 17:38:02 +01:00
}
}
pub fn (mut p Parser) name_expr() ast.Expr {
mut node := ast.Expr{}
2020-05-05 14:19:31 +02:00
if p.expecting_type {
p.expecting_type = false
// get type position before moving to next
type_pos := p.tok.position()
2020-05-04 16:46:36 +02:00
typ := p.parse_type()
2020-04-16 15:32:11 +02:00
return ast.Type{
2020-05-04 16:46:36 +02:00
typ: typ
pos: type_pos
2020-04-16 15:32:11 +02:00
}
}
language := if p.tok.lit == 'C' {
table.Language.c
} else if p.tok.lit == 'JS' {
table.Language.js
} else {
table.Language.v
}
mut mod := ''
2020-02-27 00:12:37 +01:00
// p.warn('resetting')
p.expr_mod = ''
// `map[string]int` initialization
if p.tok.lit == 'map' && p.peek_tok.kind == .lsbr {
map_type := p.parse_map_type()
if p.tok.kind == .lcbr && p.peek_tok.kind == .rcbr {
p.next()
p.next()
}
2020-03-07 16:23:10 +01:00
return ast.MapInit{
2020-03-02 12:34:02 +01:00
typ: map_type
}
2020-02-27 00:12:37 +01:00
}
2020-03-24 17:07:27 +01:00
// Raw string (`s := r'hello \n ')
if p.tok.lit in ['r', 'c', 'js'] && p.peek_tok.kind == .string && !p.inside_str_interp {
2020-03-24 17:07:27 +01:00
return p.string_expr()
}
known_var := p.mark_var_as_used(p.tok.lit)
2020-06-29 17:15:40 +02:00
mut is_mod_cast := false
2020-06-24 14:35:00 +02:00
if p.peek_tok.kind == .dot && !known_var &&
(language != .v || p.known_import(p.tok.lit) || p.mod.all_after_last('.') == p.tok.lit) {
if language == .c {
2020-02-29 11:47:47 +01:00
mod = 'C'
} else if language == .js {
2020-04-15 23:16:49 +02:00
mod = 'JS'
} else {
2020-05-14 17:14:24 +02:00
if p.tok.lit in p.imports {
p.register_used_import(p.tok.lit)
2020-06-29 17:15:40 +02:00
if p.peek_tok.kind == .dot && p.peek_tok2.lit[0].is_capital() {
is_mod_cast = true
}
2020-05-14 17:14:24 +02:00
}
// prepend the full import
mod = p.imports[p.tok.lit]
}
2020-01-07 16:06:37 +01:00
p.next()
p.check(.dot)
2020-02-27 00:12:37 +01:00
p.expr_mod = mod
}
lit0_is_capital := p.tok.lit[0].is_capital()
// p.warn('name expr $p.tok.lit $p.peek_tok.str()')
2020-02-07 21:29:28 +01:00
// fn call or type cast
2020-06-24 14:35:00 +02:00
if p.peek_tok.kind == .lpar ||
(p.peek_tok.kind == .lt && !lit0_is_capital && p.peek_tok2.kind == .name && p.peek_tok3.kind == .gt) {
// foo() or foo<int>()
mut name := p.tok.lit
2020-02-29 11:47:47 +01:00
if mod.len > 0 {
name = '${mod}.$name'
}
2020-03-01 16:14:52 +01:00
name_w_mod := p.prepend_mod(name)
2020-02-07 21:29:28 +01:00
// type cast. TODO: finish
// if name in table.builtin_type_names {
if (!known_var && (name in p.table.type_idxs ||
name_w_mod in p.table.type_idxs) &&
2020-06-29 17:15:40 +02:00
name !in ['C.stat', 'C.sigaction']) || is_mod_cast {
2020-02-11 10:26:46 +01:00
// TODO handle C.stat()
mut to_typ := p.parse_type()
2020-03-10 23:21:26 +01:00
if p.is_amp {
// Handle `&Foo(0)`
2020-04-25 09:08:53 +02:00
to_typ = to_typ.to_ptr()
2020-03-10 23:21:26 +01:00
}
p.check(.lpar)
mut expr := ast.Expr{}
mut arg := ast.Expr{}
mut has_arg := false
expr = p.expr(0)
// TODO, string(b, len)
2020-04-25 09:08:53 +02:00
if p.tok.kind == .comma && to_typ.idx() == table.string_type_idx {
p.next()
2020-04-20 08:30:42 +02:00
arg = p.expr(0) // len
2020-03-07 16:23:10 +01:00
has_arg = true
2020-02-07 21:29:28 +01:00
}
p.check(.rpar)
node = ast.CastExpr{
typ: to_typ
expr: expr
2020-03-07 16:23:10 +01:00
arg: arg
has_arg: has_arg
2020-05-06 12:05:24 +02:00
pos: expr.position()
}
2020-02-27 00:12:37 +01:00
p.expr_mod = ''
2020-02-18 08:58:20 +01:00
return node
} else {
2020-04-05 04:05:09 +02:00
// fn call
2020-02-18 08:58:20 +01:00
// println('calling $p.tok.lit')
node = p.call_expr(language, mod)
2020-02-07 21:29:28 +01:00
}
} else if (p.peek_tok.kind == .lcbr ||
(p.peek_tok.kind == .lt && lit0_is_capital)) && !p.inside_match && !p.inside_match_case &&
!p.inside_if && !p.inside_for { // && (p.tok.lit[0].is_capital() || p.builtin_mod) {
2020-04-20 08:30:42 +02:00
return p.struct_init(false) // short_syntax: false
} else if p.peek_tok.kind == .dot && (lit0_is_capital && !known_var && language == .v) {
2020-02-27 00:12:37 +01:00
// `Color.green`
mut enum_name := p.check_name()
2020-02-27 00:12:37 +01:00
if mod != '' {
enum_name = mod + '.' + enum_name
} else {
2020-02-27 00:12:37 +01:00
enum_name = p.prepend_mod(enum_name)
}
// p.warn('Color.green $enum_name ' + p.prepend_mod(enum_name) + 'mod=$mod')
2020-02-25 15:02:34 +01:00
p.check(.dot)
val := p.check_name()
// println('enum val $enum_name . $val')
2020-02-27 00:12:37 +01:00
p.expr_mod = ''
2020-02-25 15:02:34 +01:00
return ast.EnumVal{
enum_name: enum_name
2020-02-25 15:02:34 +01:00
val: val
2020-02-27 00:12:37 +01:00
pos: p.tok.position()
2020-03-15 00:46:08 +01:00
mod: mod
2020-02-25 15:02:34 +01:00
}
2020-05-05 02:12:40 +02:00
} else if p.peek_tok.kind == .colon && p.prev_tok.kind != .str_dollar {
// `foo(key:val, key2:val2)`
return p.struct_init(true) // short_syntax:true
2020-05-16 16:12:23 +02:00
// JS. function call with more than 1 dot
} else if language == .js && p.peek_tok.kind == .dot && p.peek_tok2.kind == .name {
node = p.call_expr(language, mod)
} else {
node = p.parse_ident(language)
2020-01-06 16:13:12 +01:00
}
2020-02-27 00:12:37 +01:00
p.expr_mod = ''
2020-02-18 08:58:20 +01:00
return node
2020-01-06 16:13:12 +01:00
}
fn (mut p Parser) index_expr(left ast.Expr) ast.IndexExpr {
// left == `a` in `a[0]`
2020-04-20 08:30:42 +02:00
p.next() // [
mut has_low := true
if p.tok.kind == .dotdot {
2020-03-06 22:24:39 +01:00
has_low = false
// [..end]
p.next()
high := p.expr(0)
p.check(.rsbr)
return ast.IndexExpr{
left: left
pos: p.tok.position()
index: ast.RangeExpr{
low: ast.Expr{}
high: high
has_high: true
}
}
2020-02-02 14:31:54 +01:00
}
2020-04-20 08:30:42 +02:00
expr := p.expr(0) // `[expr]` or `[expr..]`
mut has_high := false
if p.tok.kind == .dotdot {
// [start..end] or [start..]
p.next()
mut high := ast.Expr{}
if p.tok.kind != .rsbr {
2020-03-06 22:24:39 +01:00
has_high = true
high = p.expr(0)
}
p.check(.rsbr)
return ast.IndexExpr{
left: left
pos: p.tok.position()
index: ast.RangeExpr{
low: expr
high: high
has_high: has_high
has_low: has_low
}
}
}
// [expr]
2020-01-07 12:14:10 +01:00
p.check(.rsbr)
return ast.IndexExpr{
2020-01-07 12:14:10 +01:00
left: left
index: expr
2020-02-03 11:29:50 +01:00
pos: p.tok.position()
}
2020-01-07 12:14:10 +01:00
}
2020-05-02 15:26:58 +02:00
fn (mut p Parser) scope_register_it() {
2020-05-02 15:46:53 +02:00
p.scope.register('it', ast.Var{
name: 'it'
pos: p.tok.position()
is_used: true
})
2020-02-10 14:42:57 +01:00
}
fn (mut p Parser) dot_expr(left ast.Expr) ast.Expr {
2020-01-06 16:13:12 +01:00
p.next()
2020-05-27 03:20:22 +02:00
if p.tok.kind == .dollar {
return p.comptime_method_call(left)
}
mut name_pos := p.tok.position()
2020-01-06 16:13:12 +01:00
field_name := p.check_name()
2020-03-25 10:09:50 +01:00
is_filter := field_name in ['filter', 'map']
if is_filter {
p.open_scope()
name_pos = p.tok.position()
2020-05-02 15:26:58 +02:00
p.scope_register_it()
// wrong tok position when using defer
// defer {
// p.close_scope()
// }
2020-02-10 14:42:57 +01:00
}
2020-06-06 12:43:35 +02:00
// ! in mutable methods
if p.tok.kind == .not && p.peek_tok.kind == .lpar {
p.next()
}
// Method call
2020-06-06 12:28:03 +02:00
// TODO move to fn.v call_expr()
if p.tok.kind == .lpar {
p.next()
args := p.call_args()
2020-05-02 15:26:58 +02:00
if is_filter && args.len != 1 {
p.error('needs exactly 1 argument')
}
2020-04-10 14:53:06 +02:00
p.check(.rpar)
mut or_stmts := []ast.Stmt{}
2020-05-23 08:51:15 +02:00
mut or_kind := ast.OrKind.absent
2020-02-04 17:44:39 +01:00
if p.tok.kind == .key_orelse {
p.next()
p.open_scope()
p.scope.register('errcode', ast.Var{
name: 'errcode'
typ: table.int_type
pos: p.tok.position()
is_used: true
})
p.scope.register('err', ast.Var{
name: 'err'
typ: table.string_type
pos: p.tok.position()
is_used: true
})
2020-05-23 08:51:15 +02:00
or_kind = .block
or_stmts = p.parse_block_no_scope(false)
p.close_scope()
2020-02-04 17:44:39 +01:00
}
2020-06-06 12:43:35 +02:00
// `foo()?`
2020-05-23 08:51:15 +02:00
if p.tok.kind == .question {
p.next()
or_kind = .propagate
}
2020-06-06 12:43:35 +02:00
//
end_pos := p.tok.position()
pos := token.Position{
line_nr: name_pos.line_nr
pos: name_pos.pos
len: end_pos.pos - name_pos.pos
}
mcall_expr := ast.CallExpr{
left: left
name: field_name
args: args
pos: pos
is_method: true
or_block: ast.OrExpr{
stmts: or_stmts
2020-05-23 08:51:15 +02:00
kind: or_kind
pos: pos
}
}
2020-03-25 10:09:50 +01:00
if is_filter {
p.close_scope()
}
2020-05-21 22:35:43 +02:00
return mcall_expr
2020-01-08 10:19:12 +01:00
}
sel_expr := ast.SelectorExpr{
2020-01-06 16:13:12 +01:00
expr: left
2020-05-09 15:16:48 +02:00
field_name: field_name
pos: name_pos
2019-12-22 02:34:37 +01:00
}
mut node := ast.Expr{}
node = sel_expr
2020-03-25 10:09:50 +01:00
if is_filter {
p.close_scope()
}
return node
2019-12-24 18:54:43 +01:00
}
// `.green`
2020-02-20 15:42:56 +01:00
// `pref.BuildMode.default_mode`
fn (mut p Parser) enum_val() ast.EnumVal {
p.check(.dot)
2020-02-25 15:02:34 +01:00
val := p.check_name()
return ast.EnumVal{
2020-02-25 15:02:34 +01:00
val: val
2020-02-27 00:12:37 +01:00
pos: p.tok.position()
}
}
2020-01-03 11:36:17 +01:00
fn (mut p Parser) string_expr() ast.Expr {
2020-03-24 17:07:27 +01:00
is_raw := p.tok.kind == .name && p.tok.lit == 'r'
is_cstr := p.tok.kind == .name && p.tok.lit == 'c'
if is_raw || is_cstr {
p.next()
}
mut node := ast.Expr{}
2020-03-21 07:01:06 +01:00
val := p.tok.lit
2020-04-10 14:40:52 +02:00
pos := p.tok.position()
if p.peek_tok.kind != .str_dollar {
p.next()
node = ast.StringLiteral{
val: val
is_raw: is_raw
2020-06-18 20:21:08 +02:00
language: if is_cstr { table.Language.c } else { table.Language.v }
pos: pos
}
return node
}
mut exprs := []ast.Expr{}
mut vals := []string{}
mut has_fmts := []bool{}
mut fwidths := []int{}
mut precisions := []int{}
mut visible_pluss := []bool{}
mut fills := []bool{}
mut fmts := []byte{}
mut fposs := []token.Position{}
// Handle $ interpolation
p.inside_str_interp = true
2020-03-16 03:19:26 +01:00
for p.tok.kind == .string {
2020-03-21 07:01:06 +01:00
vals << p.tok.lit
p.next()
if p.tok.kind != .str_dollar {
break
}
p.next()
2020-03-21 07:01:06 +01:00
exprs << p.expr(0)
mut has_fmt := false
mut fwidth := 0
mut fwidthneg := false
mut precision := 0
mut visible_plus := false
mut fill := false
mut fmt := `_` // placeholder
if p.tok.kind == .colon {
2020-02-04 09:54:15 +01:00
p.next()
2020-04-11 17:25:39 +02:00
// ${num:-2d}
if p.tok.kind == .minus {
fwidthneg = true
p.next()
} else if p.tok.kind == .plus {
visible_plus = true
2020-04-11 17:25:39 +02:00
p.next()
}
// ${num:2d}
if p.tok.kind == .number {
fields := p.tok.lit.split('.')
if fields[0].len > 0 && fields[0][0] == `0` {
fill = true
}
fwidth = strconv.atoi(fields[0])
if fwidthneg {
fwidth = -fwidth
}
if fields.len > 1 {
precision = strconv.atoi(fields[1])
}
2020-04-11 17:25:39 +02:00
p.next()
}
if p.tok.kind == .name {
if p.tok.lit.len == 1 {
fmt = p.tok.lit[0]
has_fmt = true
p.next()
} else {
p.error('format specifier may only be one letter')
}
2020-02-11 10:26:46 +01:00
}
}
fwidths << fwidth
has_fmts << has_fmt
precisions << precision
visible_pluss << visible_plus
fmts << fmt
fills << fill
fposs << p.prev_tok.position()
}
2020-03-21 07:01:06 +01:00
node = ast.StringInterLiteral{
vals: vals
exprs: exprs
2020-06-18 20:21:08 +02:00
need_fmts: has_fmts
fwidths: fwidths
precisions: precisions
pluss: visible_pluss
fills: fills
fmts: fmts
fmt_poss: fposs
pos: pos
2020-03-21 07:01:06 +01:00
}
2020-06-18 20:21:08 +02:00
// need_fmts: prelimery - until checker finds out if really needed
p.inside_str_interp = false
return node
}
fn (mut p Parser) parse_number_literal() ast.Expr {
lit := p.tok.lit
2020-04-10 00:09:34 +02:00
pos := p.tok.position()
mut node := ast.Expr{}
2020-04-17 20:31:32 +02:00
if lit.index_any('.eE') >= 0 && lit[..2] !in ['0x', '0X', '0o', '0O', '0b', '0B'] {
node = ast.FloatLiteral{
val: lit
2020-04-20 14:49:26 +02:00
pos: pos
}
} else {
node = ast.IntegerLiteral{
val: lit
2020-04-10 00:09:34 +02:00
pos: pos
}
}
p.next()
return node
}
fn (mut p Parser) module_decl() ast.Module {
mut name := 'main'
is_skipped := p.tok.kind != .key_module
2020-05-16 16:12:23 +02:00
mut module_pos := token.Position{}
if !is_skipped {
2020-05-16 16:12:23 +02:00
module_pos = p.tok.position()
p.next()
mut pos := p.tok.position()
name = p.check_name()
if module_pos.line_nr != pos.line_nr {
p.error_with_pos('`module` and `$name` must be at same line', pos)
}
pos = p.tok.position()
if module_pos.line_nr == pos.line_nr {
if p.tok.kind != .name {
p.error_with_pos('`module x` syntax error', pos)
} else {
p.error_with_pos('`module x` can only declare one module', pos)
}
}
2020-05-16 16:12:23 +02:00
module_pos = module_pos.extend(pos)
}
full_mod := p.table.qualify_module(name, p.file_name)
p.mod = full_mod
p.builtin_mod = p.mod == 'builtin'
return ast.Module{
name: full_mod
is_skipped: is_skipped
2020-05-16 16:12:23 +02:00
pos: module_pos
}
2019-12-28 09:43:22 +01:00
}
2020-05-07 04:32:29 +02:00
fn (mut p Parser) import_stmt() ast.Import {
2020-05-08 15:01:54 +02:00
import_pos := p.tok.position()
2020-05-07 04:32:29 +02:00
p.check(.key_import)
2020-03-11 18:52:51 +01:00
pos := p.tok.position()
2020-05-07 04:32:29 +02:00
if p.tok.kind == .lpar {
p.error_with_pos('`import()` has been deprecated, use `import x` instead', pos)
}
mut mod_name := p.check_name()
2020-05-08 15:01:54 +02:00
if import_pos.line_nr != pos.line_nr {
p.error_with_pos('`import` and `module` must be at same line', pos)
}
mut mod_alias := mod_name
for p.tok.kind == .dot {
p.next()
2020-05-08 15:01:54 +02:00
pos_t := p.tok.position()
if p.tok.kind != .name {
p.error_with_pos('module syntax error, please use `x.y.z`', pos)
}
if import_pos.line_nr != pos_t.line_nr {
p.error_with_pos('`import` and `submodule` must be at same line', pos)
}
submod_name := p.check_name()
mod_name += '.' + submod_name
mod_alias = submod_name
}
2020-01-06 16:13:12 +01:00
if p.tok.kind == .key_as {
p.next()
mod_alias = p.check_name()
2020-01-06 16:13:12 +01:00
}
2020-05-08 15:01:54 +02:00
pos_t := p.tok.position()
if import_pos.line_nr == pos_t.line_nr {
if p.tok.kind != .name {
p.error_with_pos('module syntax error, please use `x.y.z`', pos_t)
} else {
p.error_with_pos('cannot import multiple modules at a time', pos_t)
}
}
p.imports[mod_alias] = mod_name
p.table.imports << mod_name
2020-05-07 04:32:29 +02:00
node := ast.Import{
mod: mod_name
alias: mod_alias
2020-03-11 18:52:51 +01:00
pos: pos
}
2020-05-07 04:32:29 +02:00
p.ast_imports << node
return node
}
fn (mut p Parser) const_decl() ast.ConstDecl {
p.top_level_statement_start()
2020-04-19 00:07:57 +02:00
start_pos := p.tok.position()
is_pub := p.tok.kind == .key_pub
if is_pub {
p.next()
}
2020-04-19 00:07:57 +02:00
end_pos := p.tok.position()
p.check(.key_const)
2020-04-16 06:00:05 +02:00
if p.tok.kind != .lpar {
p.error('consts must be grouped, e.g.\nconst (\n\ta = 1\n)')
}
2020-04-20 08:30:42 +02:00
p.next() // (
mut fields := []ast.ConstField{}
for p.tok.kind != .rpar {
mut comments := []ast.Comment{}
for p.tok.kind == .comment {
comments << p.comment()
2020-06-24 14:35:00 +02:00
if p.tok.kind == .rpar {
break
}
2020-04-05 02:08:10 +02:00
}
2020-04-30 12:17:31 +02:00
pos := p.tok.position()
2020-05-22 17:36:09 +02:00
name := p.check_name()
if util.contains_capital(name) {
2020-05-27 03:20:22 +02:00
p.warn_with_pos('const names cannot contain uppercase letters, use snake_case instead',
pos)
2020-05-22 17:36:09 +02:00
}
full_name := p.prepend_mod(name)
// name := p.check_name()
2020-02-22 17:07:03 +01:00
// println('!!const: $name')
p.check(.assign)
expr := p.expr(0)
field := ast.ConstField{
2020-05-22 17:36:09 +02:00
name: full_name
expr: expr
2020-04-30 12:17:31 +02:00
pos: pos
comments: comments
}
fields << field
p.global_scope.register(field.name, field)
2019-12-31 19:42:16 +01:00
}
p.top_level_statement_end()
p.check(.rpar)
return ast.ConstDecl{
2020-04-19 00:07:57 +02:00
pos: start_pos.extend(end_pos)
fields: fields
is_pub: is_pub
}
}
fn (mut p Parser) return_stmt() ast.Return {
2020-04-17 16:16:56 +02:00
first_pos := p.tok.position()
p.next()
// no return
if p.tok.kind == .rcbr {
return ast.Return{
2020-04-17 16:16:56 +02:00
pos: first_pos
}
}
// return exprs
exprs := p.expr_list()
2020-04-19 00:07:57 +02:00
end_pos := exprs.last().position()
2020-04-17 16:16:56 +02:00
return ast.Return{
exprs: exprs
2020-04-19 00:07:57 +02:00
pos: first_pos.extend(end_pos)
2019-12-28 09:43:22 +01:00
}
}
const (
// modules which allow globals by default
global_enabled_mods = ['rand']
)
// left hand side of `=` or `:=` in `a,b,c := 1,2,3`
fn (mut p Parser) global_decl() ast.GlobalDecl {
2020-05-04 16:46:36 +02:00
if !p.pref.translated && !p.pref.is_livemain && !p.builtin_mod && !p.pref.building_v &&
2020-06-24 14:35:00 +02:00
p.mod != 'ui' && p.mod != 'gg2' &&
p.mod != 'uiold' && !p.pref.enable_globals && !p.pref.is_fmt &&
p.mod !in global_enabled_mods {
p.error('use `v --enable-globals ...` to enable globals')
}
2020-05-16 16:12:23 +02:00
start_pos := p.tok.position()
p.next()
2020-05-16 16:12:23 +02:00
pos := start_pos.extend(p.tok.position())
name := p.check_name()
2020-03-31 19:58:44 +02:00
// println(name)
typ := p.parse_type()
mut expr := ast.Expr{}
2020-04-07 18:51:39 +02:00
has_expr := p.tok.kind == .assign
if has_expr {
p.next()
2020-04-07 18:51:39 +02:00
expr = p.expr(0)
}
// p.genln(p.table.cgen_name_type_pair(name, typ))
/*
mut g := p.table.cgen_name_type_pair(name, typ)
if p.tok == .assign {
p.next()
g += ' = '
_,expr := p.tmp_expr()
g += expr
}
// p.genln('; // global')
g += '; // global'
if !p.cgen.nogen {
p.cgen.consts << g
}
2020-04-25 17:49:16 +02:00
*/
glob := ast.GlobalDecl{
name: name
2020-03-06 16:31:40 +01:00
typ: typ
2020-05-16 16:12:23 +02:00
pos: pos
2020-04-07 18:51:39 +02:00
has_expr: has_expr
expr: expr
}
p.global_scope.register(name, glob)
return glob
}
fn (mut p Parser) enum_decl() ast.EnumDecl {
p.top_level_statement_start()
is_pub := p.tok.kind == .key_pub
2020-04-19 00:07:57 +02:00
start_pos := p.tok.position()
if is_pub {
p.next()
}
p.check(.key_enum)
2020-04-19 00:07:57 +02:00
end_pos := p.tok.position()
enum_name := p.check_name()
name := p.prepend_mod(enum_name)
p.check(.lcbr)
enum_decl_comments := p.eat_comments()
mut vals := []string{}
2020-04-26 16:25:54 +02:00
// mut default_exprs := []ast.Expr{}
mut fields := []ast.EnumField{}
for p.tok.kind != .eof && p.tok.kind != .rcbr {
2020-04-09 19:23:49 +02:00
pos := p.tok.position()
2020-04-10 00:09:34 +02:00
val := p.check_name()
vals << val
mut expr := ast.Expr{}
mut has_expr := false
2020-02-19 11:31:33 +01:00
// p.warn('enum val $val')
2020-02-12 01:16:38 +01:00
if p.tok.kind == .assign {
p.next()
2020-04-10 14:44:01 +02:00
expr = p.expr(0)
has_expr = true
2020-02-12 01:16:38 +01:00
}
fields << ast.EnumField{
2020-04-17 18:11:04 +02:00
name: val
pos: pos
expr: expr
has_expr: has_expr
comments: p.eat_comments()
}
}
p.top_level_statement_end()
p.check(.rcbr)
is_flag := 'flag' in p.attrs
if is_flag {
if fields.len > 32 {
p.error('when an enum is used as bit field, it must have a max of 32 fields')
}
pubfn := if p.mod == 'main' { 'fn' } else { 'pub fn' }
p.scanner.codegen('
//
$pubfn ( e &$enum_name) has(flag $enum_name) bool { return (int(*e) & (1 << int(flag))) != 0 }
$pubfn (mut e $enum_name) set(flag $enum_name) { unsafe{ *e = int(*e) | (1 << int(flag)) } }
$pubfn (mut e $enum_name) clear(flag $enum_name) { unsafe{ *e = int(*e) & ~(1 << int(flag)) } }
$pubfn (mut e $enum_name) toggle(flag $enum_name) { unsafe{ *e = int(*e) ^ (1 << int(flag)) } }
//
')
}
2020-02-25 13:30:43 +01:00
p.table.register_type_symbol(table.TypeSymbol{
kind: .enum_
name: name
mod: p.mod
2020-02-25 13:30:43 +01:00
info: table.Enum{
vals: vals
is_flag: is_flag
}
2020-02-25 13:30:43 +01:00
})
return ast.EnumDecl{
name: name
is_pub: is_pub
is_flag: is_flag
2020-04-09 19:23:49 +02:00
fields: fields
2020-04-19 00:07:57 +02:00
pos: start_pos.extend(end_pos)
comments: enum_decl_comments
}
}
fn (mut p Parser) type_decl() ast.TypeDecl {
2020-04-19 00:07:57 +02:00
start_pos := p.tok.position()
is_pub := p.tok.kind == .key_pub
if is_pub {
p.next()
}
p.check(.key_type)
2020-04-19 00:07:57 +02:00
end_pos := p.tok.position()
decl_pos := start_pos.extend(end_pos)
name := p.check_name()
if name.len == 1 && name[0].is_capital() {
p.error_with_pos('single letter capital names are reserved for generic template types.',
decl_pos)
}
mut sum_variants := []table.Type{}
if p.tok.kind == .assign {
2020-04-20 08:30:42 +02:00
p.next() // TODO require `=`
2020-04-13 15:06:02 +02:00
}
if p.tok.kind == .key_fn {
// function type: `type mycallback fn(string, int)`
fn_name := p.prepend_mod(name)
fn_type := p.parse_fn_type(fn_name)
return ast.FnTypeDecl{
name: fn_name
is_pub: is_pub
typ: fn_type
2020-04-19 00:07:57 +02:00
pos: decl_pos
2020-04-13 15:06:02 +02:00
}
}
2020-04-20 08:30:42 +02:00
first_type := p.parse_type() // need to parse the first type before we can check if it's `type A = X | Y`
2020-04-13 15:06:02 +02:00
if p.tok.kind == .pipe {
p.next()
2020-04-13 15:06:02 +02:00
sum_variants << first_type
// type SumType = A | B | c
for {
variant_type := p.parse_type()
sum_variants << variant_type
if p.tok.kind != .pipe {
break
}
p.check(.pipe)
}
p.table.register_type_symbol(table.TypeSymbol{
kind: .sum_type
name: p.prepend_mod(name)
mod: p.mod
info: table.SumType{
variants: sum_variants
}
is_public: is_pub
})
return ast.SumTypeDecl{
name: name
is_pub: is_pub
sub_types: sum_variants
2020-04-19 00:07:57 +02:00
pos: decl_pos
}
2020-03-02 23:19:04 +01:00
}
// type MyType int
2020-04-13 15:06:02 +02:00
parent_type := first_type
2020-05-18 21:38:06 +02:00
parent_name := p.table.get_type_symbol(parent_type).name
2020-04-25 09:08:53 +02:00
pid := parent_type.idx()
language := if parent_name.len > 2 && parent_name.starts_with('C.') {
table.Language.c
} else if parent_name.len > 2 && parent_name.starts_with('JS.') {
table.Language.js
} else {
table.Language.v
}
p.table.register_type_symbol({
kind: .alias
name: p.prepend_mod(name)
parent_idx: pid
mod: p.mod
info: table.Alias{
parent_type: parent_type
language: language
}
is_public: is_pub
})
return ast.AliasTypeDecl{
name: name
is_pub: is_pub
parent_type: parent_type
2020-04-19 00:07:57 +02:00
pos: decl_pos
}
}
fn (mut p Parser) assoc() ast.Assoc {
2020-04-01 23:23:20 +02:00
var_name := p.check_name()
pos := p.tok.position()
mut v := p.scope.find_var(var_name) or {
2020-04-01 23:23:20 +02:00
p.error('unknown variable `$var_name`')
return ast.Assoc{}
}
v.is_used = true
2020-04-01 23:23:20 +02:00
// println('assoc var $name typ=$var.typ')
mut fields := []string{}
mut vals := []ast.Expr{}
2020-04-01 23:23:20 +02:00
p.check(.pipe)
for {
2020-04-01 23:23:20 +02:00
fields << p.check_name()
p.check(.colon)
expr := p.expr(0)
vals << expr
if p.tok.kind == .comma {
p.next()
2020-04-01 23:23:20 +02:00
}
if p.tok.kind == .rcbr {
break
}
}
return ast.Assoc{
var_name: var_name
fields: fields
exprs: vals
pos: pos
}
}
2020-03-31 20:26:15 +02:00
fn (p &Parser) new_true_expr() ast.Expr {
return ast.BoolLiteral{
val: true
2020-04-20 14:49:26 +02:00
pos: p.tok.position()
2020-03-31 20:26:15 +02:00
}
}
2019-12-26 11:21:41 +01:00
fn verror(s string) {
util.verror('parser error', s)
2019-12-26 11:21:41 +01:00
}
fn (mut p Parser) top_level_statement_start() {
if p.comments_mode == .toplevel_comments {
p.scanner.set_is_inside_toplevel_statement(true)
p.rewind_scanner_to_current_token_in_new_mode()
$if debugscanner ? {
eprintln('>> p.top_level_statement_start | tidx:${p.tok.tidx:-5} | p.tok.kind: ${p.tok.kind:-10} | p.tok.lit: $p.tok.lit $p.peek_tok.lit $p.peek_tok2.lit $p.peek_tok3.lit ...')
}
}
}
fn (mut p Parser) top_level_statement_end() {
if p.comments_mode == .toplevel_comments {
p.scanner.set_is_inside_toplevel_statement(false)
p.rewind_scanner_to_current_token_in_new_mode()
$if debugscanner ? {
eprintln('>> p.top_level_statement_end | tidx:${p.tok.tidx:-5} | p.tok.kind: ${p.tok.kind:-10} | p.tok.lit: $p.tok.lit $p.peek_tok.lit $p.peek_tok2.lit $p.peek_tok3.lit ...')
}
}
}
fn (mut p Parser) rewind_scanner_to_current_token_in_new_mode() {
// Go back and rescan some tokens, ensuring that the parser's
// lookahead buffer p.peek_tok .. p.peek_tok3, will now contain
// the correct tokens (possible comments), for the new mode
// This refilling of the lookahead buffer is needed for the
// .toplevel_comments parsing mode.
tidx := p.tok.tidx
p.scanner.set_current_tidx(tidx - 5)
no_token := token.Token{}
p.prev_tok = no_token
p.tok = no_token
p.peek_tok = no_token
p.peek_tok2 = no_token
p.peek_tok3 = no_token
for {
p.next()
// eprintln('rewinding to ${p.tok.tidx:5} | goal: ${tidx:5}')
if tidx == p.tok.tidx {
break
}
}
}
pub fn (mut p Parser) mark_var_as_used(varname string) bool {
if obj := p.scope.find(varname) {
match mut obj {
ast.Var {
obj.is_used = true
return true
}
else {}
}
}
return false
}