v/vlib/v/parser/parser.v

1941 lines
36 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
import (
v.scanner
v.ast
v.token
v.table
v.pref
2019-12-29 06:50:08 +01:00
term
2019-12-30 12:10:46 +01:00
os
// runtime
// sync
// time
2019-12-22 02:34:37 +01:00
)
const (
colored_output = term.can_show_color_on_stderr()
)
2020-01-06 16:13:12 +01:00
2019-12-22 02:34:37 +01:00
struct Parser {
scanner &scanner.Scanner
file_name string
2019-12-22 02:34:37 +01:00
mut:
tok token.Token
peek_tok token.Token
2019-12-28 09:43:22 +01:00
// vars []string
table &table.Table
is_c bool
2020-01-07 01:57:38 +01:00
// prefix_parse_fns []PrefixParseFn
inside_if bool
pref &pref.Preferences // Preferences shared from V struct
builtin_mod bool
mod string
attr string
expr_mod string
scope &ast.Scope
imports map[string]string
ast_imports []ast.Import
2020-03-10 23:21:26 +01:00
is_amp bool
2020-03-27 14:44:30 +01:00
returns bool
2019-12-22 02:34:37 +01:00
}
// for tests
pub fn parse_stmt(text string, table &table.Table, scope &ast.Scope) ast.Stmt {
2020-02-29 17:51:35 +01:00
s := scanner.new_scanner(text, .skip_comments)
2019-12-22 02:34:37 +01:00
mut p := Parser{
scanner: s
table: table
2020-02-07 22:10:48 +01:00
pref: &pref.Preferences{}
scope: scope
2020-02-16 11:48:29 +01:00
// 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()
2019-12-28 14:11:05 +01:00
return p.stmt()
2019-12-22 02:34:37 +01:00
}
2020-03-27 14:44:30 +01:00
pub fn parse_file(path string, table &table.Table, comments_mode scanner.CommentsMode, pref &pref.Preferences) ast.File {
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)
// }
2019-12-28 14:11:05 +01:00
mut stmts := []ast.Stmt
mut p := Parser{
2020-02-29 17:51:35 +01:00
// scanner: scanner.new_scanner(text, comments_mode)
scanner: scanner.new_scanner_file(path, comments_mode)
table: table
2020-01-01 10:15:05 +01:00
file_name: path
2020-03-28 14:38:16 +01:00
pref: pref // &pref.Preferences{}
2020-02-16 11:48:29 +01:00
scope: &ast.Scope{
start_pos: 0
parent: 0
}
2020-02-29 17:51:35 +01:00
// comments_mode: comments_mode
}
2019-12-28 14:11:05 +01:00
p.read_first_token()
2020-02-16 11:48:29 +01:00
// p.scope = &ast.Scope{start_pos: p.tok.position(), parent: 0}
// module decl
module_decl := if p.tok.kind == .key_module { p.module_decl() } else { ast.Module{name: 'main'
} }
p.mod = module_decl.name
p.builtin_mod = p.mod == 'builtin'
// imports
2020-02-29 17:51:35 +01:00
/*
mut imports := []ast.Import
for p.tok.kind == .key_import {
imports << p.import_stmt()
}
2020-02-29 17:51:35 +01:00
*/
// TODO: import only mode
for {
2019-12-28 09:43:22 +01:00
// res := s.scan()
if p.tok.kind == .eof {
2020-02-19 16:12:39 +01:00
// println('EOF, breaking')
break
}
2020-01-06 16:13:12 +01:00
// println('stmt at ' + p.tok.str())
stmts << p.top_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{
2020-02-03 07:31:54 +01:00
path: path
mod: module_decl
2020-02-29 17:51:35 +01:00
imports: p.ast_imports
stmts: stmts
scope: p.scope
2019-12-28 14:11:05 +01:00
}
}
/*
struct Queue {
mut:
idx int
mu sync.Mutex
paths []string
table &table.Table
parsed_ast_files []ast.File
}
fn (q mut Queue) run() {
q.mu.lock()
idx := q.idx
if idx >= q.paths.len {
q.mu.unlock()
return
}
q.idx++
q.mu.unlock()
path := q.paths[idx]
file := parse_file(path, q.table, .skip_comments)
q.mu.lock()
q.parsed_ast_files << file
q.mu.unlock()
}
*/
2020-03-27 14:44:30 +01:00
pub fn parse_files(paths []string, table &table.Table, pref &pref.Preferences) []ast.File {
/*
println('\n\n\nparse_files()')
println(paths)
nr_cpus := runtime.nr_cpus()
println('nr_cpus= $nr_cpus')
mut q := &Queue{
paths: paths
table: table
}
for i in 0 .. nr_cpus {
go q.run()
}
time.sleep_ms(100)
return q.parsed_ast_files
*/
// ///////////////
2019-12-30 12:10:46 +01:00
mut files := []ast.File
for path in paths {
2020-03-27 08:46:54 +01:00
// println('parse_files $path')
2020-03-27 14:44:30 +01:00
files << parse_file(path, table, .skip_comments, pref)
2019-12-30 12:10:46 +01:00
}
return files
}
2020-01-07 01:57:38 +01:00
pub fn (p &Parser) init_parse_fns() {
// 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
2020-01-07 01:57:38 +01:00
println('')
2020-01-06 16:13:12 +01:00
}
2019-12-28 14:11:05 +01:00
pub fn (p mut Parser) read_first_token() {
// need to call next() twice to get peek token and current token
p.next()
p.next()
}
pub fn (p mut Parser) open_scope() {
p.scope = &ast.Scope{
parent: p.scope
start_pos: p.tok.pos
}
}
pub fn (p mut Parser) close_scope() {
p.scope.end_pos = p.tok.pos
p.scope.parent.children << p.scope
p.scope = p.scope.parent
}
2019-12-28 14:11:05 +01:00
pub fn (p mut Parser) parse_block() []ast.Stmt {
p.open_scope()
// println('parse block')
stmts := p.parse_block_no_scope()
p.close_scope()
// println('nr exprs in block = $exprs.len')
return stmts
}
pub fn (p mut Parser) parse_block_no_scope() []ast.Stmt {
2019-12-31 19:42:16 +01:00
p.check(.lcbr)
2019-12-28 14:11:05 +01:00
mut stmts := []ast.Stmt
2020-01-06 16:13:12 +01:00
if p.tok.kind != .rcbr {
for {
stmts << p.stmt()
// p.warn('after stmt(): tok=$p.tok.str()')
if p.tok.kind in [.eof, .rcbr] {
break
}
2019-12-27 13:57:49 +01:00
}
}
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
}
2019-12-22 02:34:37 +01:00
fn (p mut Parser) next() {
2020-02-29 17:51:35 +01:00
// for {
p.tok = p.peek_tok
p.peek_tok = p.scanner.scan()
2020-02-29 17:51:35 +01:00
// if !(p.tok.kind in [.line_comment, .mline_comment]) {
// break
// }
// }
2019-12-24 18:54:43 +01:00
// println(p.tok.str())
2019-12-22 02:34:37 +01:00
}
fn (p mut 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 {
s := 'syntax error: unexpected `${p.tok.kind.str()}`, expecting `${expected.str()}`'
2019-12-29 07:24:17 +01:00
p.error(s)
2019-12-27 13:57:49 +01:00
}
p.next()
}
fn (p mut Parser) check_name() string {
name := p.tok.lit
2019-12-27 13:57:49 +01:00
p.check(.name)
return name
}
2020-01-06 16:13:12 +01:00
pub fn (p mut 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()
}
.key_struct, .key_union, .key_interface {
return p.struct_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 {
2020-03-05 16:13:14 +01:00
return p.attribute()
}
.key_interface {
return p.interface_decl()
}
2020-02-29 17:51:35 +01:00
.key_module {
return p.module_decl()
}
.key_import {
node := p.import_stmt()
p.ast_imports << node
return node[0]
}
.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 {
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-02-18 20:20:15 +01:00
.line_comment {
2020-02-29 17:51:35 +01:00
return p.line_comment()
2020-02-18 20:20:15 +01:00
}
.mline_comment {
comment := p.tok.lit
p.next()
2020-02-18 20:20:15 +01:00
return ast.MultiLineComment{
text: comment
2020-02-18 20:20:15 +01:00
}
}
2020-01-06 16:13:12 +01:00
else {
2020-02-18 20:20:15 +01:00
// #printf("");
p.error('parser: 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-02-29 17:51:35 +01:00
pub fn (p mut Parser) line_comment() ast.LineComment {
text := p.tok.lit
p.next()
return ast.LineComment{
text: text
}
}
2020-01-06 16:13:12 +01:00
pub fn (p mut Parser) stmt() ast.Stmt {
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()
expr := p.expr(0)
return ast.AssertStmt{
expr: expr
2020-03-26 10:44:59 +01:00
pos: p.tok.position()
}
}
2019-12-28 11:02:06 +01:00
.key_mut {
return p.assign_stmt()
2019-12-28 11:02:06 +01:00
}
.key_for {
return p.for_statement()
}
2020-02-29 17:51:35 +01:00
.line_comment {
return p.line_comment()
}
2020-01-06 16:13:12 +01:00
.key_return {
return p.return_stmt()
}
.dollar {
return p.comp_if()
}
.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()
2020-02-26 20:45:03 +01:00
stmts := p.parse_block()
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()
return ast.GoStmt{
expr: p.expr(0)
}
}
2020-02-17 14:15:42 +01:00
.key_goto {
p.next()
name := p.check_name()
return ast.GotoStmt{
name: name
}
}
2019-12-28 14:11:05 +01:00
else {
2020-01-06 16:13:12 +01:00
// `x := ...`
if p.tok.kind == .name && p.peek_tok.kind in [.decl_assign, .comma] {
return p.assign_stmt()
2020-02-06 17:38:02 +01:00
}
2020-02-17 14:15:42 +01:00
// `label:`
else if p.tok.kind == .name && p.peek_tok.kind == .colon {
name := p.check_name()
p.check(.colon)
return ast.GotoLabel{
name: name
}
}
expr := p.expr(0)
2019-12-28 14:11:05 +01:00
return ast.ExprStmt{
expr: expr
}
}
}
}
2020-03-18 01:19:23 +01:00
// TODO: is it possible to merge with AssignStmt?
2020-01-06 16:13:12 +01:00
pub fn (p mut Parser) assign_expr(left ast.Expr) ast.AssignExpr {
op := p.tok.kind
p.next()
val := p.expr(0)
2020-01-06 16:13:12 +01:00
node := ast.AssignExpr{
left: left
val: val
op: op
pos: p.tok.position()
2020-01-06 16:13:12 +01:00
}
return node
}
2020-03-05 16:13:14 +01:00
fn (p mut Parser) attribute() ast.Attr {
p.check(.lsbr)
if p.tok.kind == .key_if {
p.next()
}
name := p.check_name()
p.check(.rsbr)
2020-03-05 16:13:14 +01:00
p.attr = name
return ast.Attr{
name: name
}
}
/*
2020-02-02 14:31:54 +01:00
fn (p mut Parser) range_expr(low ast.Expr) ast.Expr {
// ,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
}
*/
2020-02-02 14:31:54 +01:00
2019-12-29 06:50:08 +01:00
pub fn (p &Parser) error(s string) {
2020-01-07 01:57:38 +01:00
print_backtrace()
2020-02-07 07:34:18 +01:00
mut path := p.file_name
// Get relative path
2020-03-07 22:26:26 +01:00
workdir := os.getwd() + os.path_separator
2020-02-07 07:34:18 +01:00
if path.starts_with(workdir) {
path = path.replace(workdir, '')
}
2020-02-11 10:26:46 +01:00
final_msg_line := '$path:$p.tok.line_nr: error: $s'
if colored_output {
eprintln(term.bold(term.red(final_msg_line)))
}
else {
eprintln(final_msg_line)
}
2019-12-29 06:50:08 +01:00
exit(1)
}
2020-01-02 08:30:15 +01:00
pub fn (p &Parser) error_at_line(s string, line_nr int) {
final_msg_line := '$p.file_name:$line_nr: error: $s'
if colored_output {
eprintln(term.bold(term.red(final_msg_line)))
}
else {
eprintln(final_msg_line)
}
2020-01-02 08:30:15 +01:00
exit(1)
2019-12-30 09:38:12 +01:00
}
2020-01-02 08:30:15 +01:00
pub fn (p &Parser) warn(s string) {
final_msg_line := '$p.file_name:$p.tok.line_nr: warning: $s'
if colored_output {
eprintln(term.bold(term.blue(final_msg_line)))
}
else {
eprintln(final_msg_line)
}
}
pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
2020-02-06 17:38:02 +01:00
// p.warn('name ')
pos := p.tok.position()
mut name := p.check_name()
if name == '_' {
return ast.Ident{
name: '_'
kind: .blank_ident
pos: pos
}
}
if p.expr_mod.len > 0 {
name = '${p.expr_mod}.$name'
}
2020-02-06 17:38:02 +01:00
mut ident := ast.Ident{
kind: .unresolved
2020-02-06 17:38:02 +01:00
name: name
is_c: is_c
pos: pos
2020-02-06 17:38:02 +01:00
}
// variable
if p.expr_mod.len == 0 {
if var := p.scope.find_var(name) {
ident.kind = .variable
ident.info = ast.IdentVar{}
2020-02-22 14:39:25 +01:00
}
2020-02-06 17:38:02 +01:00
}
// handle consts/fns in checker
return ident
2020-02-06 17:38:02 +01:00
}
2020-02-18 08:58:20 +01:00
fn (p mut Parser) struct_init() ast.StructInit {
typ := p.parse_type()
p.expr_mod = ''
// sym := p.table.get_type_symbol(typ)
2020-02-18 20:20:15 +01:00
// p.warn('struct init typ=$sym.name')
p.check(.lcbr)
mut field_names := []string
mut exprs := []ast.Expr
mut i := 0
is_short_syntax := !(p.peek_tok.kind == .colon || p.tok.kind == .rcbr) // `Vec{a,b,c}`
// p.warn(is_short_syntax.str())
for p.tok.kind != .rcbr {
mut field_name := ''
if is_short_syntax {
expr := p.expr(0)
exprs << expr
}
else {
field_name = p.check_name()
field_names << field_name
}
if !is_short_syntax {
p.check(.colon)
expr := p.expr(0)
exprs << expr
}
i++
if p.tok.kind == .comma {
p.check(.comma)
}
}
2020-02-18 08:58:20 +01:00
node := ast.StructInit{
typ: typ
exprs: exprs
fields: field_names
pos: p.tok.position()
}
p.check(.rcbr)
2020-02-18 08:58:20 +01:00
return node
}
2020-02-18 08:58:20 +01:00
pub fn (p mut Parser) name_expr() ast.Expr {
2020-01-06 16:13:12 +01:00
mut node := ast.Expr{}
is_c := p.tok.lit == 'C'
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()
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 == 'r' && p.peek_tok.kind == .string {
// && p.prev_tok.kind != .str_dollar {
return p.string_expr()
}
2020-03-01 16:14:52 +01:00
known_var := p.scope.known_var(p.tok.lit)
if p.peek_tok.kind == .dot && !known_var && (is_c || p.known_import(p.tok.lit) || p.mod.all_after('.') == p.tok.lit) {
2020-02-29 11:47:47 +01:00
if is_c {
mod = 'C'
2020-02-29 17:51:35 +01:00
}
else {
// 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
}
// 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-01-06 16:13:12 +01:00
if p.peek_tok.kind == .lpar {
2020-02-29 11:47:47 +01:00
mut name := p.tok.lit
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 {
2020-03-01 16:14:52 +01:00
if (name in p.table.type_idxs || name_w_mod in p.table.type_idxs) && !(name in ['C.stat', 'C.sigaction']) {
2020-02-11 10:26:46 +01:00
// TODO handle C.stat()
2020-03-10 23:21:26 +01:00
mut to_typ := p.parse_type()
if p.is_amp {
// Handle `&Foo(0)`
to_typ = table.type_to_ptr(to_typ)
}
p.check(.lpar)
mut expr := ast.Expr{}
2020-03-07 16:23:10 +01:00
mut arg := ast.Expr{}
mut has_arg := false
expr = p.expr(0)
// TODO, string(b, len)
if p.tok.kind == .comma && table.type_idx(to_typ) == table.string_type_idx {
p.check(.comma)
2020-03-07 16:23:10 +01:00
arg = p.expr(0) // len
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-02-27 00:12:37 +01:00
p.expr_mod = ''
2020-02-18 08:58:20 +01:00
return node
2020-02-07 21:29:28 +01:00
}
// fn call
2020-02-07 21:29:28 +01:00
else {
2020-02-18 08:58:20 +01:00
// println('calling $p.tok.lit')
x := p.call_expr(is_c, mod) // TODO `node,typ :=` should work
2020-02-07 21:29:28 +01:00
node = x
}
2020-01-06 16:13:12 +01:00
}
else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || is_c ||
//
(p.builtin_mod && p.tok.lit in table.builtin_type_names)) &&
//
(p.tok.lit.len == 1 || !p.tok.lit[p.tok.lit.len - 1].is_capital())
//
{
// || p.table.known_type(p.tok.lit)) {
return p.struct_init()
2020-01-06 16:13:12 +01:00
}
2020-03-01 16:14:52 +01:00
else if p.peek_tok.kind == .dot && (p.tok.lit[0].is_capital() && !known_var) {
2020-02-27 00:12:37 +01:00
// `Color.green`
mut enum_name := p.check_name()
if mod != '' {
enum_name = mod + '.' + enum_name
}
else {
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{
2020-02-27 00:12:37 +01:00
enum_name: enum_name // lp.prepend_mod(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-02-25 13:30:43 +01:00
}
2020-01-06 16:13:12 +01:00
else {
2020-02-06 17:38:02 +01:00
mut ident := ast.Ident{}
ident = p.parse_ident(is_c)
2020-02-06 17:38:02 +01:00
node = ident
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
}
pub fn (p mut Parser) expr(precedence int) ast.Expr {
// println('\n\nparser.expr()')
mut typ := table.void_type
2019-12-28 14:11:05 +01:00
mut node := ast.Expr{}
2020-01-06 16:13:12 +01:00
// Prefix
2019-12-28 14:11:05 +01:00
match p.tok.kind {
.name {
2020-02-18 08:58:20 +01:00
node = p.name_expr()
}
2020-03-15 00:46:08 +01:00
.string {
node = p.string_expr()
2020-01-06 16:13:12 +01:00
}
.dot {
// .enum_val
node = p.enum_val()
}
2020-02-04 09:54:15 +01:00
.chartoken {
node = ast.CharLiteral{
val: p.tok.lit
}
p.next()
}
// -1, -a, !x, &x, ~x
.minus, .amp, .mul, .not, .bit_not {
2020-02-18 08:58:20 +01:00
node = p.prefix_expr()
2019-12-30 09:38:12 +01:00
}
2020-01-07 12:14:10 +01:00
// .amp {
// p.next()
// }
.key_true, .key_false {
node = ast.BoolLiteral{
val: p.tok.kind == .key_true
}
p.next()
}
.key_match {
node = p.match_expr()
}
2019-12-28 09:43:22 +01:00
.number {
node = p.parse_number_literal()
2019-12-28 09:43:22 +01:00
}
.lpar {
p.check(.lpar)
node = p.expr(0)
2019-12-28 11:02:06 +01:00
p.check(.rpar)
2020-02-28 14:41:19 +01:00
node = ast.ParExpr{
expr: node
}
2019-12-27 13:57:49 +01:00
}
2020-01-06 16:13:12 +01:00
.key_if {
node = p.if_expr()
2020-01-06 16:13:12 +01:00
}
.lsbr {
node = p.array_init()
2020-01-06 16:13:12 +01:00
}
.key_none {
p.next()
2020-02-20 15:42:56 +01:00
node = ast.None{}
}
2020-02-04 09:54:15 +01:00
.key_sizeof {
2020-02-18 18:13:34 +01:00
p.next() // sizeof
2020-02-04 09:54:15 +01:00
p.check(.lpar)
2020-02-19 16:12:39 +01:00
if p.tok.lit == 'C' {
p.next()
p.check(.dot)
}
if p.tok.kind == .amp {
p.next()
}
// type_name := p.check_name()
sizeof_type := p.parse_type()
2020-02-04 09:54:15 +01:00
p.check(.rpar)
2020-02-18 20:20:15 +01:00
node = ast.SizeOf{
typ: sizeof_type
// type_name: type_name
2020-02-18 20:20:15 +01:00
}
2020-02-04 09:54:15 +01:00
}
2020-03-19 12:15:39 +01:00
.key_typeof {
p.next()
p.check(.lpar)
expr := p.expr(0)
p.check(.rpar)
node = ast.TypeOf{
expr: expr
}
}
2020-02-17 14:15:42 +01:00
// Map `{"age": 20}` or `{ x | foo:bar, a:10 }`
2020-02-11 00:07:01 +01:00
.lcbr {
p.next()
2020-03-16 03:19:26 +01:00
if p.tok.kind == .string {
2020-02-22 14:13:19 +01:00
mut keys := []ast.Expr
mut vals := []ast.Expr
2020-02-17 14:15:42 +01:00
for p.tok.kind != .rcbr && p.tok.kind != .eof {
2020-02-22 14:39:25 +01:00
// p.check(.str)
key := p.expr(0)
2020-02-22 14:39:25 +01:00
keys << key
2020-02-17 14:15:42 +01:00
p.check(.colon)
val := p.expr(0)
2020-02-22 14:13:19 +01:00
vals << val
2020-02-17 14:15:42 +01:00
if p.tok.kind == .comma {
p.next()
}
2020-02-11 00:07:01 +01:00
}
2020-02-22 14:39:25 +01:00
node = ast.MapInit{
keys: keys
2020-02-22 14:13:19 +01:00
vals: vals
pos: p.tok.position()
}
2020-02-17 14:15:42 +01:00
}
else {
name := p.check_name()
2020-03-19 08:14:09 +01:00
var := p.scope.find_var(name) or {
p.error('unknown variable `$name`')
return node
}
// println('assoc var $name typ=$var.typ')
2020-02-22 14:39:25 +01:00
mut fields := []string
mut vals := []ast.Expr
2020-02-17 14:15:42 +01:00
p.check(.pipe)
for {
2020-02-22 14:39:25 +01:00
fields << p.check_name()
2020-02-17 14:15:42 +01:00
p.check(.colon)
expr := p.expr(0)
2020-02-22 14:39:25 +01:00
vals << expr
2020-02-17 14:15:42 +01:00
if p.tok.kind == .comma {
p.check(.comma)
}
if p.tok.kind == .rcbr {
break
}
2020-02-11 00:07:01 +01:00
}
node = ast.Assoc{
2020-02-29 18:07:29 +01:00
var_name: name
2020-02-22 14:39:25 +01:00
fields: fields
exprs: vals
pos: p.tok.position()
2020-03-19 08:14:09 +01:00
typ: var.typ
}
2020-02-11 00:07:01 +01:00
}
p.check(.rcbr)
}
2019-12-27 13:57:49 +01:00
else {
p.error('parser: expr(): bad token `$p.tok.str()`')
}
}
2020-01-06 16:13:12 +01:00
// Infix
for precedence < p.tok.precedence() {
if p.tok.kind.is_assign() {
node = p.assign_expr(node)
}
else if p.tok.kind == .dot {
node = p.dot_expr(node)
2020-01-06 16:13:12 +01:00
}
2020-01-07 12:14:10 +01:00
else if p.tok.kind == .lsbr {
2020-02-20 15:42:56 +01:00
node = p.index_expr(node)
2020-01-07 12:14:10 +01:00
}
2020-02-07 09:19:45 +01:00
else if p.tok.kind == .key_as {
pos := p.tok.position()
2020-02-07 09:19:45 +01:00
p.next()
typ = p.parse_type()
2020-03-04 02:50:32 +01:00
node = ast.AsCast{
2020-03-06 22:12:15 +01:00
expr: node
typ: typ
pos: pos
}
2020-02-07 09:19:45 +01:00
}
2020-03-04 02:50:32 +01:00
// TODO: handle in later stages since this
// will fudge left shift as it makes it right assoc
// `arr << 'a'` | `arr << 'a' + 'b'`
else if p.tok.kind == .left_shift {
tok := p.tok
p.next()
right := p.expr(precedence - 1)
node = ast.InfixExpr{
left: node
right: right
op: tok.kind
pos: tok.position()
}
}
2020-01-06 16:13:12 +01:00
else if p.tok.kind.is_infix() {
node = p.infix_expr(node)
2020-01-06 16:13:12 +01:00
}
2020-01-07 12:14:10 +01:00
// Postfix
2020-01-06 16:13:12 +01:00
else if p.tok.kind in [.inc, .dec] {
node = ast.PostfixExpr{
op: p.tok.kind
expr: node
2020-02-27 17:31:10 +01:00
pos: p.tok.position()
2019-12-24 18:54:43 +01:00
}
2020-01-06 16:13:12 +01:00
p.next()
return node
}
2020-01-06 16:13:12 +01:00
else {
return node
2020-01-06 16:13:12 +01:00
}
}
return node
2020-01-06 16:13:12 +01:00
}
2020-02-18 08:58:20 +01:00
fn (p mut Parser) prefix_expr() ast.PrefixExpr {
2020-03-28 14:38:16 +01:00
pos := p.tok.position()
2020-01-06 16:13:12 +01:00
op := p.tok.kind
2020-03-10 23:21:26 +01:00
if op == .amp {
p.is_amp = true
}
2020-01-06 16:13:12 +01:00
p.next()
right := p.expr(1)
2020-03-10 23:21:26 +01:00
p.is_amp = false
2020-02-18 08:58:20 +01:00
return ast.PrefixExpr{
2020-01-06 16:13:12 +01:00
op: op
right: right
2020-03-28 14:38:16 +01:00
pos: pos
2020-01-06 16:13:12 +01:00
}
}
fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr {
// left == `a` in `a[0]`
2020-02-02 14:31:54 +01:00
p.next() // [
2020-03-06 22:24:39 +01:00
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
2020-03-06 22:24:39 +01:00
has_high: true
}
}
2020-02-02 14:31:54 +01:00
}
expr := p.expr(0) // `[expr]` or `[expr..]`
2020-03-06 22:24:39 +01:00
mut has_high := false
if p.tok.kind == .dotdot {
// [start..end] or [start..]
p.check(.dotdot)
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
2020-03-06 22:24:39 +01:00
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
}
fn (p mut Parser) filter() {
p.scope.register_var(ast.Var{
name: 'it'
})
2020-02-10 14:42:57 +01:00
}
fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
2020-01-06 16:13:12 +01:00
p.next()
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()
p.filter()
// wrong tok position when using defer
// defer {
// p.close_scope()
// }
2020-02-10 14:42:57 +01:00
}
pos := p.tok.position()
// Method call
if p.tok.kind == .lpar {
p.next()
args := p.call_args()
mut or_stmts := []ast.Stmt
2020-02-04 17:44:39 +01:00
if p.tok.kind == .key_orelse {
p.next()
p.open_scope()
p.scope.register_var(ast.Var{
name: 'err'
typ: table.string_type
})
or_stmts = p.parse_block_no_scope()
p.close_scope()
2020-02-04 17:44:39 +01:00
}
mcall_expr := ast.CallExpr{
left: left
name: field_name
args: args
pos: pos
is_method: true
or_block: ast.OrExpr{
stmts: or_stmts
}
}
mut node := ast.Expr{}
node = mcall_expr
2020-03-25 10:09:50 +01:00
if is_filter {
p.close_scope()
}
return node
2020-01-08 10:19:12 +01:00
}
sel_expr := ast.SelectorExpr{
2020-01-06 16:13:12 +01:00
expr: left
field: field_name
pos: p.tok.position()
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
}
fn (p mut Parser) infix_expr(left ast.Expr) ast.Expr {
2020-01-06 16:13:12 +01:00
op := p.tok.kind
// mut typ := p.
// println('infix op=$op.str()')
precedence := p.tok.precedence()
2020-02-19 11:31:33 +01:00
pos := p.tok.position()
2020-01-06 16:13:12 +01:00
p.next()
2020-02-17 14:15:42 +01:00
mut right := ast.Expr{}
right = p.expr(precedence)
2020-01-06 16:13:12 +01:00
mut expr := ast.Expr{}
expr = ast.InfixExpr{
2020-01-06 16:13:12 +01:00
left: left
right: right
// right_type: typ
op: op
2020-02-19 11:31:33 +01:00
pos: pos
2020-01-06 16:13:12 +01:00
}
return expr
2020-01-06 16:13:12 +01:00
}
// Implementation of Pratt Precedence
/*
2020-01-03 11:36:17 +01:00
[inline]
fn (p &Parser) is_addative() bool {
return p.tok.kind in [.plus, .minus] && p.peek_tok.kind in [.number, .name]
}
*/
// `.green`
2020-02-20 15:42:56 +01:00
// `pref.BuildMode.default_mode`
fn (p mut 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
2020-01-07 00:14:19 +01:00
fn (p mut Parser) for_statement() ast.Stmt {
p.check(.key_for)
pos := p.tok.position()
p.open_scope()
// defer { p.close_scope() }
2020-01-07 00:14:19 +01:00
// Infinite loop
if p.tok.kind == .lcbr {
stmts := p.parse_block()
p.close_scope()
2020-01-07 00:14:19 +01:00
return ast.ForStmt{
stmts: stmts
2020-02-19 11:06:36 +01:00
pos: pos
is_inf: true
2020-01-07 00:14:19 +01:00
}
}
else if p.tok.kind == .key_mut {
p.error('`mut` is not required in for loops')
}
// for i := 0; i < 10; i++ {
2020-02-07 07:34:18 +01:00
else if p.peek_tok.kind in [.decl_assign, .assign, .semicolon] || p.tok.kind == .semicolon {
2020-01-07 00:14:19 +01:00
mut init := ast.Stmt{}
2020-03-31 19:58:44 +02:00
mut cond := p.new_true_expr()
// mut inc := ast.Stmt{}
2020-03-05 00:43:02 +01:00
mut inc := ast.Expr{}
mut has_init := false
if p.peek_tok.kind in [.assign, .decl_assign] {
init = p.assign_stmt()
has_init = true
2020-02-20 20:30:34 +01:00
}
2020-02-19 16:12:39 +01:00
else if p.tok.kind != .semicolon {}
// allow `for ;; i++ {`
// Allow `for i = 0; i < ...`
/*
2020-01-07 00:14:19 +01:00
cond, typ = p.expr(0)
if typ.kind != _bool {
p.error('non-bool used as for condition')
}
*/
2020-02-19 16:12:39 +01:00
// println(1)
// }
2020-01-07 00:14:19 +01:00
p.check(.semicolon)
if p.tok.kind != .semicolon {
mut typ := table.void_type
cond = p.expr(0)
2020-01-07 00:14:19 +01:00
}
p.check(.semicolon)
if p.tok.kind != .lcbr {
// inc = p.stmt()
inc = p.expr(0)
2020-01-07 00:14:19 +01:00
}
stmts := p.parse_block()
p.close_scope()
2020-01-07 00:14:19 +01:00
return ast.ForCStmt{
stmts: stmts
has_init: has_init
2020-01-07 00:14:19 +01:00
init: init
cond: cond
inc: inc
pos: pos
2020-01-07 00:14:19 +01:00
}
}
// `for i in vals`, `for i in start .. end`
else if p.peek_tok.kind in [.key_in, .comma] {
mut key_var_name := ''
mut val_var_name := p.check_name()
2020-02-04 17:44:39 +01:00
if p.tok.kind == .comma {
p.check(.comma)
key_var_name = val_var_name
val_var_name = p.check_name()
p.scope.register_var(ast.Var{
name: key_var_name
typ: table.int_type
2020-02-04 17:44:39 +01:00
})
}
2020-01-01 22:34:46 +01:00
p.check(.key_in)
// arr_expr
cond := p.expr(0)
// 0 .. 10
// start := p.tok.lit.int()
// TODO use RangeExpr
mut high_expr := ast.Expr{}
mut is_range := false
if p.tok.kind == .dotdot {
is_range = true
p.check(.dotdot)
high_expr = p.expr(0)
p.scope.register_var(ast.Var{
name: val_var_name
typ: table.int_type
})
}
else {
// this type will be set in checker
p.scope.register_var(ast.Var{
name: val_var_name
})
}
2020-01-01 22:34:46 +01:00
stmts := p.parse_block()
// println('nr stmts=$stmts.len')
p.close_scope()
2020-02-18 20:47:19 +01:00
return ast.ForInStmt{
2020-01-01 22:34:46 +01:00
stmts: stmts
2020-02-22 16:59:50 +01:00
cond: cond
key_var: key_var_name
val_var: val_var_name
high: high_expr
is_range: is_range
pos: pos
2020-01-01 22:34:46 +01:00
}
}
// `for cond {`
cond := p.expr(0)
stmts := p.parse_block()
p.close_scope()
return ast.ForStmt{
cond: cond
stmts: stmts
pos: pos
}
}
fn (p mut Parser) if_expr() ast.IfExpr {
2020-01-07 01:57:38 +01:00
p.inside_if = true
2020-02-19 11:31:33 +01:00
pos := p.tok.position()
mut branches := []ast.IfBranch
2020-02-22 16:59:50 +01:00
mut has_else := false
for p.tok.kind in [.key_if, .key_else] {
branch_pos := p.tok.position()
2020-02-04 17:44:39 +01:00
if p.tok.kind == .key_if {
p.check(.key_if)
2020-02-04 17:44:39 +01:00
}
else {
p.check(.key_else)
if p.tok.kind == .key_if {
p.check(.key_if)
}
else {
has_else = true
branches << ast.IfBranch{
stmts: p.parse_block()
pos: branch_pos
}
break
}
2020-02-04 17:44:39 +01:00
}
mut cond := ast.Expr{}
mut is_or := false
// `if x := opt() {`
if p.peek_tok.kind == .decl_assign {
is_or = true
p.open_scope()
var_name := p.check_name()
p.check(.decl_assign)
expr := p.expr(0)
p.scope.register_var(ast.Var{
name: var_name
expr: expr
})
cond = ast.IfGuardExpr{
var_name: var_name
expr: expr
}
}
else {
cond = p.expr(0)
}
p.inside_if = false
stmts := p.parse_block()
if is_or {
p.close_scope()
}
branches << ast.IfBranch{
cond: cond
stmts: stmts
pos: branch_pos
}
if p.tok.kind != .key_else {
break
}
}
return ast.IfExpr{
branches: branches
2020-02-19 11:31:33 +01:00
pos: pos
2020-02-22 17:07:03 +01:00
has_else: has_else
}
}
fn (p mut 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
node = ast.StringLiteral{
2020-03-21 07:01:06 +01:00
val: val
2020-03-24 17:07:27 +01:00
is_raw: is_raw
is_c: is_cstr
}
if p.peek_tok.kind != .str_dollar {
p.next()
return node
}
2020-03-21 07:01:06 +01:00
mut exprs := []ast.Expr
mut vals := []string
mut efmts := []string
// Handle $ interpolation
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 {
continue
}
p.check(.str_dollar)
2020-03-21 07:01:06 +01:00
exprs << p.expr(0)
mut efmt := []string
if p.tok.kind == .colon {
efmt << ':'
2020-02-04 09:54:15 +01:00
p.next()
}
2020-02-29 05:56:16 +01:00
// ${num:-2d}
if p.tok.kind == .minus {
efmt << '-'
2020-02-29 05:56:16 +01:00
p.next()
}
2020-02-11 10:26:46 +01:00
// ${num:2d}
if p.tok.kind == .number {
efmt << p.tok.lit
2020-02-11 10:26:46 +01:00
p.next()
if p.tok.lit.len == 1 {
efmt << p.tok.lit
2020-02-11 10:26:46 +01:00
p.next()
}
}
efmts << efmt.join('')
}
2020-03-21 07:01:06 +01:00
node = ast.StringInterLiteral{
vals: vals
exprs: exprs
expr_fmts: efmts
2020-03-21 07:01:06 +01:00
}
return node
}
2020-02-19 14:34:44 +01:00
fn (p mut Parser) array_init() ast.ArrayInit {
2019-12-30 09:38:12 +01:00
p.check(.lsbr)
// p.warn('array_init() exp=$p.expected_type')
2020-03-04 02:50:32 +01:00
mut array_type := table.void_type
mut elem_type := table.void_type
2019-12-30 09:38:12 +01:00
mut exprs := []ast.Expr
if p.tok.kind == .rsbr {
2020-02-17 14:15:42 +01:00
// []typ => `[]` and `typ` must be on the same line
line_nr := p.tok.line_nr
p.check(.rsbr)
// []string
2020-03-24 16:24:23 +01:00
if p.tok.kind in [.name, .amp] && p.tok.line_nr == line_nr {
2020-03-04 02:50:32 +01:00
elem_type = p.parse_type()
2020-02-19 14:34:44 +01:00
// this is set here becasue its a known type, others could be the
// result of expr so we do those in checker
2020-03-04 02:50:32 +01:00
idx := p.table.find_or_register_array(elem_type, 1)
2020-02-19 14:34:44 +01:00
array_type = table.new_type(idx)
}
}
else {
// [1,2,3]
for i := 0; p.tok.kind != .rsbr; i++ {
expr := p.expr(0)
exprs << expr
if p.tok.kind == .comma {
p.check(.comma)
}
}
2020-03-04 02:50:32 +01:00
line_nr := p.tok.line_nr
p.check(.rsbr)
2020-03-04 02:50:32 +01:00
// [100]byte
2020-03-24 16:24:23 +01:00
if exprs.len == 1 && p.tok.kind in [.name, .amp] && p.tok.line_nr == line_nr {
2020-03-04 02:50:32 +01:00
elem_type = p.parse_type()
// p.warn('fixed size array')
2019-12-30 09:38:12 +01:00
}
}
2020-02-19 16:12:39 +01:00
// !
if p.tok.kind == .not {
p.next()
}
if p.tok.kind == .not {
p.next()
}
2020-02-19 14:34:44 +01:00
return ast.ArrayInit{
2020-03-04 02:50:32 +01:00
elem_type: elem_type
2020-02-19 14:34:44 +01:00
typ: array_type
2019-12-30 09:38:12 +01:00
exprs: exprs
2020-01-19 13:52:34 +01:00
pos: p.tok.position()
2019-12-30 09:38:12 +01:00
}
}
fn (p mut Parser) parse_number_literal() ast.Expr {
lit := p.tok.lit
mut node := ast.Expr{}
if lit.contains('.') {
node = ast.FloatLiteral{
2019-12-28 09:43:22 +01:00
// val: lit.f64()
val: lit
}
2019-12-28 09:43:22 +01:00
}
else {
node = ast.IntegerLiteral{
val: lit
}
}
p.next()
return node
}
2019-12-30 12:10:46 +01:00
fn (p mut Parser) module_decl() ast.Module {
p.check(.key_module)
mod := p.check_name()
full_mod := p.table.qualify_module(mod, p.file_name)
p.mod = full_mod
return ast.Module{
name: full_mod
}
2019-12-28 09:43:22 +01:00
}
fn (p mut Parser) parse_import() ast.Import {
2020-03-11 18:52:51 +01:00
pos := p.tok.position()
2020-02-12 01:16:38 +01:00
mut mod_name := p.check_name()
mut mod_alias := mod_name
for p.tok.kind == .dot {
p.check(.dot)
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.check(.key_as)
mod_alias = p.check_name()
2020-01-06 16:13:12 +01:00
}
p.imports[mod_alias] = mod_name
p.table.imports << mod_name
2019-12-31 19:42:16 +01:00
return ast.Import{
mod: mod_name
alias: mod_alias
2020-03-11 18:52:51 +01:00
pos: pos
}
}
fn (p mut Parser) import_stmt() []ast.Import {
p.check(.key_import)
mut imports := []ast.Import
if p.tok.kind == .lpar {
p.check(.lpar)
for p.tok.kind != .rpar {
imports << p.parse_import()
}
p.check(.rpar)
}
else {
imports << p.parse_import()
}
return imports
}
fn (p mut Parser) const_decl() ast.ConstDecl {
is_pub := p.tok.kind == .key_pub
if is_pub {
p.next()
}
p.check(.key_const)
p.check(.lpar)
mut fields := []ast.Field
mut exprs := []ast.Expr
for p.tok.kind != .rpar {
2020-02-22 13:04:56 +01:00
name := p.prepend_mod(p.check_name())
2020-02-22 17:07:03 +01:00
// println('!!const: $name')
p.check(.assign)
expr := p.expr(0)
fields << ast.Field{
name: name
// typ: typ
}
exprs << expr
// TODO: once consts are fixed reg here & update in checker
// p.table.register_const(table.Var{
// name: name
// // typ: typ
// })
2019-12-31 19:42:16 +01:00
}
p.check(.rpar)
return ast.ConstDecl{
fields: fields
exprs: exprs
is_pub: is_pub
}
}
// structs and unions
fn (p mut Parser) struct_decl() ast.StructDecl {
2019-12-31 19:42:16 +01:00
is_pub := p.tok.kind == .key_pub
if is_pub {
p.next()
}
if p.tok.kind == .key_struct {
p.check(.key_struct)
}
else {
p.check(.key_union)
}
is_c := p.tok.lit == 'C' && p.peek_tok.kind == .dot
if is_c {
p.next() // C
p.next() // .
}
2020-02-29 11:47:47 +01:00
mut name := p.check_name()
2020-03-27 08:46:54 +01:00
// println('struct decl $name')
p.check(.lcbr)
mut ast_fields := []ast.Field
mut fields := []table.Field
2020-02-22 14:13:19 +01:00
mut mut_pos := -1
mut pub_pos := -1
mut pub_mut_pos := -1
for p.tok.kind != .rcbr {
2019-12-31 19:42:16 +01:00
if p.tok.kind == .key_pub {
p.check(.key_pub)
2020-02-04 12:50:58 +01:00
if p.tok.kind == .key_mut {
p.check(.key_mut)
2020-02-22 14:13:19 +01:00
pub_mut_pos = fields.len
}
else {
pub_pos = fields.len
2020-02-04 12:50:58 +01:00
}
p.check(.colon)
}
else if p.tok.kind == .key_mut {
p.check(.key_mut)
2019-12-31 19:42:16 +01:00
p.check(.colon)
2020-02-22 14:13:19 +01:00
mut_pos = fields.len
2019-12-31 19:42:16 +01:00
}
2020-03-27 08:46:54 +01:00
else if p.tok.kind == .key_global {
p.check(.key_global)
p.check(.colon)
}
field_name := p.check_name()
2020-02-04 12:50:58 +01:00
// p.warn('field $field_name')
typ := p.parse_type()
/*
if name == '_net_module_s' {
s := p.table.get_type_symbol(typ)
println('XXXX' + s.str())
}
*/
// Default value
if p.tok.kind == .assign {
p.next()
p.expr(0)
}
ast_fields << ast.Field{
name: field_name
typ: typ
}
fields << table.Field{
name: field_name
typ: typ
}
// println('struct field $ti.name $field_name')
}
p.check(.rcbr)
2020-02-29 11:47:47 +01:00
if is_c {
name = 'C.$name'
2020-02-29 17:51:35 +01:00
}
else {
2020-02-29 11:47:47 +01:00
name = p.prepend_mod(name)
}
t := table.TypeSymbol{
kind: .struct_
2020-02-29 11:47:47 +01:00
name: name
info: table.Struct{
fields: fields
}
2020-02-04 17:44:39 +01:00
}
mut ret := 0
if p.builtin_mod && t.name in table.builtin_type_names {
// this allows overiding the builtins type
// with the real struct type info parsed from builtin
ret = p.table.register_builtin_type_symbol(t)
2020-02-10 14:42:57 +01:00
}
else {
ret = p.table.register_type_symbol(t)
}
if ret == -1 {
p.error('cannot register type `$name`, another type with this name exists')
}
2020-02-27 00:12:37 +01:00
p.expr_mod = ''
return ast.StructDecl{
name: name
2019-12-31 19:42:16 +01:00
is_pub: is_pub
fields: ast_fields
pos: p.tok.position()
2020-02-22 14:13:19 +01:00
mut_pos: mut_pos
pub_pos: pub_pos
pub_mut_pos: pub_mut_pos
is_c: is_c
}
}
fn (p mut Parser) interface_decl() ast.InterfaceDecl {
is_pub := p.tok.kind == .key_pub
if is_pub {
p.next()
}
p.next() // `interface`
interface_name := p.check_name()
p.check(.lcbr)
2020-03-31 20:26:15 +02:00
mut field_names := []string
for p.tok.kind != .rcbr && p.tok.kind != .eof {
line_nr := p.tok.line_nr
name := p.check_name()
2020-03-31 20:26:15 +02:00
field_names << name
p.fn_args()
if p.tok.kind == .name && p.tok.line_nr == line_nr {
p.parse_type()
}
}
p.check(.rcbr)
return ast.InterfaceDecl{
name: interface_name
2020-03-31 20:26:15 +02:00
field_names: field_names
}
}
2019-12-28 14:11:05 +01:00
fn (p mut Parser) return_stmt() ast.Return {
p.next()
// return expressions
mut exprs := []ast.Expr
if p.tok.kind == .rcbr {
return ast.Return{
pos: p.tok.position()
}
}
for {
expr := p.expr(0)
exprs << expr
if p.tok.kind == .comma {
p.check(.comma)
}
else {
break
}
}
stmt := ast.Return{
exprs: exprs
pos: p.tok.position()
2019-12-28 09:43:22 +01:00
}
return stmt
}
// left hand side of `=` or `:=` in `a,b,c := 1,2,3`
fn (p mut Parser) parse_assign_lhs() []ast.Ident {
2020-02-06 17:38:02 +01:00
mut idents := []ast.Ident
for {
is_mut := p.tok.kind == .key_mut
if is_mut {
p.check(.key_mut)
}
is_static := p.tok.kind == .key_static
if is_static {
p.check(.key_static)
}
mut ident := p.parse_ident(false)
ident.info = ast.IdentVar{
is_mut: is_mut
is_static: is_static
}
2020-02-06 17:38:02 +01:00
idents << ident
if p.tok.kind == .comma {
p.check(.comma)
2020-02-07 07:34:18 +01:00
}
else {
2020-02-06 17:38:02 +01:00
break
}
}
return idents
}
// right hand side of `=` or `:=` in `a,b,c := 1,2,3`
fn (p mut Parser) parse_assign_rhs() []ast.Expr {
mut exprs := []ast.Expr
for {
expr := p.expr(0)
exprs << expr
if p.tok.kind == .comma {
p.check(.comma)
}
else {
break
}
}
return exprs
}
fn (p mut Parser) assign_stmt() ast.Stmt {
idents := p.parse_assign_lhs()
2020-03-31 06:34:59 +02:00
pos := p.tok.position()
op := p.tok.kind
2020-02-06 17:38:02 +01:00
p.next() // :=, =
exprs := p.parse_assign_rhs()
is_decl := op == .decl_assign
2020-03-10 14:45:21 +01:00
for i, ident in idents {
known_var := p.scope.known_var(ident.name)
if !is_decl && !known_var {
p.error('unknown variable `$ident.name`')
}
2020-02-27 11:15:30 +01:00
if is_decl && ident.kind != .blank_ident {
if p.scope.known_var(ident.name) {
p.error('redefinition of `$ident.name`')
}
2020-03-10 14:45:21 +01:00
if idents.len == exprs.len {
p.scope.register_var(ast.Var{
name: ident.name
expr: exprs[i]
})
}
else {
p.scope.register_var(ast.Var{
name: ident.name
})
}
}
}
2020-02-06 17:38:02 +01:00
return ast.AssignStmt{
left: idents
right: exprs
op: op
2020-03-31 06:34:59 +02:00
pos: pos
2020-02-06 17:38:02 +01:00
}
}
2020-02-04 09:54:15 +01:00
fn (p mut Parser) hash() ast.HashStmt {
2020-03-05 00:43:02 +01:00
val := p.tok.lit
2020-02-04 09:54:15 +01:00
p.next()
return ast.HashStmt{
2020-03-05 00:43:02 +01:00
val: val
2020-02-04 09:54:15 +01:00
}
}
fn (p mut Parser) global_decl() ast.GlobalDecl {
if !p.pref.translated && !p.pref.is_live && !p.builtin_mod && !p.pref.building_v && p.mod != 'ui' && p.mod != 'gg2' && p.mod != 'uiold' && !os.getwd().contains('/volt') && !p.pref.enable_globals {
p.error('use `v --enable-globals ...` to enable globals')
}
p.next()
name := p.check_name()
2020-03-31 19:58:44 +02:00
// println(name)
typ := p.parse_type()
if p.tok.kind == .assign {
p.next()
p.expr(0)
}
p.table.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 {
p.next()
g += ' = '
_,expr := p.tmp_expr()
g += expr
}
// p.genln('; // global')
g += '; // global'
if !p.cgen.nogen {
p.cgen.consts << g
}
*/
return ast.GlobalDecl{
name: name
2020-03-06 16:31:40 +01:00
typ: typ
}
}
2020-03-04 11:59:45 +01:00
fn (p mut Parser) match_expr() ast.MatchExpr {
p.check(.key_match)
pos := p.tok.position()
2020-02-12 01:16:38 +01:00
is_mut := p.tok.kind == .key_mut
2020-03-16 03:19:26 +01:00
mut is_sum_type := false
2020-02-12 01:16:38 +01:00
if is_mut {
p.next()
}
cond := p.expr(0)
p.check(.lcbr)
2020-03-04 11:59:45 +01:00
mut branches := []ast.MatchBranch
for {
2020-03-04 11:59:45 +01:00
mut exprs := []ast.Expr
branch_pos := p.tok.position()
2020-03-02 10:53:38 +01:00
p.open_scope()
2020-03-04 11:59:45 +01:00
// final else
if p.tok.kind == .key_else {
p.next()
}
// Sum type match
2020-03-04 11:59:45 +01:00
else if p.tok.kind == .name && (p.tok.lit[0].is_capital() || p.peek_tok.kind == .dot) {
2020-02-13 01:06:34 +01:00
// if sym.kind == .sum_type {
// p.warn('is sum')
2020-03-20 20:22:34 +01:00
// TODO `exprs << ast.Type{...}`
2020-03-02 10:53:38 +01:00
typ := p.parse_type()
2020-03-20 20:22:34 +01:00
x := ast.Type{
2020-03-02 10:53:38 +01:00
typ: typ
2020-02-13 01:06:34 +01:00
}
2020-03-20 20:22:34 +01:00
mut expr := ast.Expr{}
expr = x
exprs << expr
p.scope.register_var(ast.Var{
2020-03-02 10:53:38 +01:00
name: 'it'
2020-03-16 05:02:41 +01:00
typ: table.type_to_ptr(typ)
2020-03-02 10:53:38 +01:00
})
// TODO
if p.tok.kind == .comma {
p.next()
p.parse_type()
}
2020-03-16 03:19:26 +01:00
is_sum_type = true
2020-02-11 00:07:01 +01:00
}
else {
// Expression match
2020-02-11 10:26:46 +01:00
for {
expr := p.expr(0)
2020-03-04 11:59:45 +01:00
exprs << expr
2020-02-11 10:26:46 +01:00
if p.tok.kind != .comma {
break
}
p.check(.comma)
}
2020-02-11 00:07:01 +01:00
}
2020-02-19 11:31:33 +01:00
// p.warn('match block')
stmts := p.parse_block()
2020-03-04 11:59:45 +01:00
branches << ast.MatchBranch{
exprs: exprs
stmts: stmts
pos: branch_pos
2020-02-07 14:49:14 +01:00
}
2020-03-02 10:53:38 +01:00
p.close_scope()
if p.tok.kind == .rcbr {
break
}
}
p.check(.rcbr)
2020-03-04 11:59:45 +01:00
return ast.MatchExpr{
branches: branches
2020-02-07 14:49:14 +01:00
cond: cond
2020-03-16 03:19:26 +01:00
is_sum_type: is_sum_type
pos: pos
2020-02-07 14:49:14 +01:00
}
}
fn (p mut Parser) enum_decl() ast.EnumDecl {
is_pub := p.tok.kind == .key_pub
if is_pub {
p.next()
}
p.check(.key_enum)
name := p.prepend_mod(p.check_name())
p.check(.lcbr)
mut vals := []string
2020-03-31 19:43:11 +02:00
mut default_exprs := []ast.Expr
for p.tok.kind != .eof && p.tok.kind != .rcbr {
val := p.check_name()
vals << val
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-03-31 19:43:11 +02:00
default_exprs << p.expr(0)
2020-02-12 01:16:38 +01:00
}
}
p.check(.rcbr)
2020-02-25 13:30:43 +01:00
p.table.register_type_symbol(table.TypeSymbol{
kind: .enum_
name: name
2020-02-25 13:30:43 +01:00
info: table.Enum{
vals: vals
}
})
return ast.EnumDecl{
name: name
is_pub: is_pub
vals: vals
2020-03-31 19:43:11 +02:00
default_exprs: default_exprs
}
}
fn (p mut Parser) type_decl() ast.TypeDecl {
is_pub := p.tok.kind == .key_pub
if is_pub {
p.next()
}
p.check(.key_type)
name := p.check_name()
mut sum_variants := []table.Type
if p.tok.kind == .assign {
// type SumType = A | B | c
p.next()
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)
info: table.SumType{
variants: sum_variants
}
})
return ast.SumTypeDecl{
name: name
is_pub: is_pub
sub_types: sum_variants
}
2020-03-02 23:19:04 +01:00
}
// function type: `type mycallback fn(string, int)`
if p.tok.kind == .key_fn {
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-03-02 23:19:04 +01:00
// type MyType int
parent_type := p.parse_type()
pid := table.type_idx(parent_type)
p.table.register_type_symbol(table.TypeSymbol{
kind: .alias
name: p.prepend_mod(name)
parent_idx: pid
info: table.Alias{
foo: ''
}
})
return ast.AliasTypeDecl{
name: name
is_pub: is_pub
parent_type: parent_type
}
}
2020-03-31 20:26:15 +02:00
fn (p &Parser) new_true_expr() ast.Expr {
return ast.BoolLiteral{
val: true
}
}
2019-12-26 11:21:41 +01:00
fn verror(s string) {
println(s)
exit(1)
}