v/vlib/v/ast/ast.v

424 lines
5.5 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 ast
import (
v.token
v.table
2019-12-22 02:34:37 +01:00
)
2020-02-04 09:54:15 +01:00
pub type Expr = InfixExpr | IfExpr | StringLiteral | IntegerLiteral | CharLiteral |
2020-02-03 07:44:52 +01:00
FloatLiteral | Ident | CallExpr | BoolLiteral | StructInit | ArrayInit | SelectorExpr | PostfixExpr |
2020-02-02 14:31:54 +01:00
AssignExpr | PrefixExpr | MethodCallExpr | IndexExpr | RangeExpr
2019-12-28 14:11:05 +01:00
2020-02-03 07:44:52 +01:00
pub type Stmt = VarDecl | GlobalDecl | FnDecl | Return | Module | Import | ExprStmt |
2020-02-04 09:54:15 +01:00
ForStmt | StructDecl | ForCStmt | ForInStmt | CompIf | ConstDecl | Attr | BranchStmt |
HashStmt
2020-01-06 16:13:12 +01:00
// | IncDecStmt k
2019-12-28 14:11:05 +01:00
// Stand-alone expression in a statement list.
pub struct ExprStmt {
pub:
expr Expr
ti table.Type
2019-12-28 14:11:05 +01:00
}
2019-12-22 02:34:37 +01:00
2019-12-26 11:21:41 +01:00
pub struct IntegerLiteral {
pub:
val int
}
2019-12-24 18:54:43 +01:00
2019-12-27 10:03:29 +01:00
pub struct FloatLiteral {
pub:
2019-12-28 09:43:22 +01:00
// val f64
2019-12-27 10:03:29 +01:00
val string
}
2019-12-24 18:54:43 +01:00
pub struct StringLiteral {
pub:
val string
}
2019-12-22 02:34:37 +01:00
2020-02-04 09:54:15 +01:00
pub struct CharLiteral {
pub:
val string
}
pub struct BoolLiteral {
pub:
val bool
}
// `foo.bar`
pub struct SelectorExpr {
pub:
pos token.Position
expr Expr
field string
}
2019-12-28 11:02:06 +01:00
// module declaration
pub struct Module {
pub:
2019-12-28 09:43:22 +01:00
name string
path string
expr Expr
}
pub struct Field {
pub:
name string
// type_idx int
typ table.Type
}
pub struct ConstDecl {
pub:
fields []Field
exprs []Expr
}
pub struct StructDecl {
pub:
pos token.Position
name string
fields []Field
2019-12-31 19:42:16 +01:00
is_pub bool
}
pub struct StructInit {
pub:
pos token.Position
ti table.Type
fields []string
exprs []Expr
}
// import statement
pub struct Import {
pub:
pos token.Position
mod string
alias string
2019-12-31 19:42:16 +01:00
// expr Expr
}
2019-12-29 07:24:17 +01:00
pub struct Arg {
pub:
ti table.Type
2019-12-29 07:24:17 +01:00
name string
}
2019-12-27 13:57:49 +01:00
pub struct FnDecl {
pub:
2020-01-06 16:13:12 +01:00
name string
stmts []Stmt
ti table.Type
2020-01-06 16:13:12 +01:00
args []Arg
is_pub bool
receiver Field
2019-12-29 07:24:17 +01:00
}
pub struct BranchStmt {
pub:
tok token.Token
}
2019-12-29 07:24:17 +01:00
pub struct CallExpr {
pub:
// tok token.Token
pos token.Position
mut:
// func Expr
name string
args []Expr
}
pub struct MethodCallExpr {
pub:
// tok token.Token
pos token.Position
expr Expr
name string
args []Expr
2019-12-27 13:57:49 +01:00
}
pub struct Return {
pub:
pos token.Position
expected_ti table.Type // TODO: remove once checker updated
exprs []Expr
2019-12-27 13:57:49 +01:00
}
2019-12-22 02:34:37 +01:00
/*
pub enum Expr {
Binary(InfixExpr)
2019-12-22 02:34:37 +01:00
If(IfExpr)
Integer(IntegerExpr)
}
*/
2019-12-24 18:54:43 +01:00
/*
2019-12-22 02:34:37 +01:00
pub struct Stmt {
pos int
//end int
}
2019-12-24 18:54:43 +01:00
*/
2019-12-28 09:43:22 +01:00
2019-12-24 18:54:43 +01:00
pub struct VarDecl {
pub:
name string
expr Expr
is_mut bool
mut:
typ table.Type
pos token.Position
2019-12-24 18:54:43 +01:00
}
pub struct GlobalDecl {
pub:
name string
expr Expr
mut:
typ table.Type
}
2019-12-30 12:10:46 +01:00
pub struct File {
2019-12-24 18:54:43 +01:00
pub:
2020-02-03 07:31:54 +01:00
path string
mod Module
imports []Import
stmts []Stmt
unresolved []Expr
}
pub struct IdentVar {
pub:
typ table.Type
//name string
}
type IdentInfo = IdentVar
pub enum IdentKind {
blank_ident
variable
constant
2019-12-24 18:54:43 +01:00
}
2019-12-28 14:11:05 +01:00
2019-12-22 02:34:37 +01:00
// A single identifier
2019-12-28 14:11:05 +01:00
pub struct Ident {
pub:
name string
tok_kind token.Kind
pos token.Position
2019-12-28 09:43:22 +01:00
value string
mut:
kind IdentKind
info IdentInfo
2019-12-22 02:34:37 +01:00
}
pub struct InfixExpr {
2019-12-22 02:34:37 +01:00
pub:
2019-12-28 19:16:04 +01:00
// op BinaryOp
op token.Kind
pos token.Position
left Expr
left_type table.Type
right Expr
right_type table.Type
2019-12-22 02:34:37 +01:00
}
/*
// renamed to PrefixExpr
pub struct UnaryExpr {
pub:
// tok_kind token.Kind
2019-12-28 09:43:22 +01:00
// op BinaryOp
op token.Kind
2019-12-28 09:43:22 +01:00
left Expr
}
*/
2020-01-06 16:13:12 +01:00
pub struct PostfixExpr {
pub:
op token.Kind
expr Expr
2020-02-04 07:37:38 +01:00
pos token.Position
2020-01-06 16:13:12 +01:00
}
pub struct PrefixExpr {
pub:
op token.Kind
right Expr
}
2020-01-07 12:14:10 +01:00
pub struct IndexExpr {
pub:
// op token.Kind
2020-02-03 07:44:52 +01:00
pos token.Position
2020-01-07 12:14:10 +01:00
left Expr
index Expr // [0], [start..end] etc
2020-02-03 11:29:50 +01:00
// typ table.Type
2020-01-07 12:14:10 +01:00
}
2019-12-28 19:16:04 +01:00
pub struct IfExpr {
pub:
2020-01-01 22:34:46 +01:00
tok_kind token.Kind
cond Expr
stmts []Stmt
2019-12-31 19:42:16 +01:00
else_stmts []Stmt
ti table.Type
left Expr // `a` in `a := if ...`
pos token.Position
}
pub struct CompIf {
pub:
cond Expr
stmts []Stmt
else_stmts []Stmt
2019-12-22 02:34:37 +01:00
}
pub struct ForStmt {
pub:
cond Expr
stmts []Stmt
pos token.Position
2020-01-07 00:14:19 +01:00
}
pub struct ForInStmt {
pub:
var string
cond Expr
stmts []Stmt
}
pub struct ForCStmt {
pub:
init Stmt // i := 0;
cond Expr // i < 10;
inc Stmt // i++;
stmts []Stmt
}
2019-12-28 19:16:04 +01:00
pub struct ReturnStmt {
tok_kind token.Kind // or pos
pos token.Position
2019-12-28 09:43:22 +01:00
results []Expr
2019-12-22 02:34:37 +01:00
}
2020-02-04 09:54:15 +01:00
// #include etc
pub struct HashStmt {
pub:
name string
}
/*
2019-12-28 19:16:04 +01:00
pub struct AssignStmt {
pub:
left Expr
right Expr
op token.Kind
2019-12-28 19:16:04 +01:00
}
*/
// e.g. `[unsafe_fn]`
pub struct Attr {
pub:
name string
}
2019-12-28 19:16:04 +01:00
2020-01-06 16:13:12 +01:00
pub struct AssignExpr {
pub:
op token.Kind
pos token.Position
2020-01-06 16:13:12 +01:00
left Expr
val Expr
}
2019-12-30 09:38:12 +01:00
pub struct ArrayInit {
pub:
2020-01-19 13:52:34 +01:00
pos token.Position
2019-12-30 09:38:12 +01:00
exprs []Expr
ti table.Type
2019-12-30 09:38:12 +01:00
}
2020-02-02 14:31:54 +01:00
// s[10..20]
pub struct RangeExpr {
pub:
low Expr
high Expr
}
// string representaiton of expr
pub fn (x Expr) str() string {
match x {
InfixExpr {
return '(${it.left.str()} $it.op.str() ${it.right.str()})'
}
/*
PrefixExpr {
return it.left.str() + it.op.str()
}
*/
IntegerLiteral {
return it.val.str()
}
IntegerLiteral {
return '"$it.val"'
}
2019-12-28 09:43:22 +01:00
else {
return ''
}
}
2019-12-22 02:34:37 +01:00
}
2019-12-28 14:11:05 +01:00
pub fn (node Stmt) str() string {
match node {
VarDecl {
return it.name + ' = ' + it.expr.str()
}
ExprStmt {
return it.expr.str()
}
FnDecl {
return 'fn ${it.name}() { $it.stmts.len stmts }'
}
else {
return '[unhandled stmt str]'
}
}
}
/*
enum BinaryOp {
sum
difference
product
quotient
remainder
bitwise_and
bitwise_or
bitwise_xor
left_shift
right_shift
equality
inequality
less_than
less_than_or_equal
more_than
more_than_or_equal
in_check
//These are suffixed with `bool` to prevent conflict with the keyword `or`
and_bool
or_bool
}
*/