V语言抽象语法树(AST)

V语言所有的语法树结构体都在标准库的v.ast子模块中定义.

主要是通过联合类型来实现,用联合类型来实现语法树,代码显得非常的简洁,清晰.

v ast子命令

可使用v ast子命令来生成语法树结构,这样你就可以边写代码,边查看代码对应的语法树,有助于加深对V语言语法树的理解.

  1. v ast main.v       //生成json格式的AST语法树文件main.json
  2. v ast -w main.v    //生成main.json,并且监控源文件变化,保存后自动重新生成
  3. v ast -c main.v    //同时生成AST语法树文件main.json和C源代码main.c,并监控源文件变化,保存后自动重新生成

使用v ast子命令,将本章节中的示例代码生成语法树,即可查看到各种不同代码对应的语法树.

语法树结构体总览

V抽象语法树 - 图1

ast.File语法树文件

整个编译过程主要的步骤就是: [ ]os.File => [ ]ast.File => 目标代码(c/x64/js) => 可执行文件.

一个os.File(源代码文件)会生成一个对应的ast.File(语法树文件).

AST结构体

  1. File 语法树文件

示例代码

  1. module main
  3. import os
  4. import time
  6. fn main() {
  8. }

生成的AST:

整个源文件的所有语句都保存在stmts语句数组节点中

  1. {
  2.     "ast_type": "ast.File",
  3.     "path": "/Users/xxx/v/vprojects/v_test/main.v",
  4.     "mod": {
  5.         "ast_type": "Module",
  6.         "name": "main",
  7.         "is_skipped": false,
  8.         "pos": {
  9.             "line_nr": 0,
  10.             "pos": 0,
  11.             "len": 19
  12.         }
  13.     },
  14.     "imports": [
  15.         {
  16.             "ast_type": "Import",
  17.             "mod": "os",
  18.             "alias": "os",
  19.             "syms": [],
  20.             "pos": {
  21.                 "line_nr": 2,
  22.                 "pos": 20,
  23.                 "len": 2
  24.             }
  25.         },
  26.         {
  27.             "ast_type": "Import",
  28.             "mod": "time",
  29.             "alias": "time",
  30.             "syms": [],
  31.             "pos": {
  32.                 "line_nr": 3,
  33.                 "pos": 30,
  34.                 "len": 4
  35.             }
  36.         }
  37.     ],
  38.     "global_scope": {
  39.         "ast_type": "Scope",
  40.         "parent": "0",
  41.         "children": [],
  42.         "start_pos": 0,
  43.         "end_pos": 0,
  44.         "objects": {},
  45.         "struct_fields": []
  46.     },
  47.     "scope": {
  48.         "ast_type": "Scope",
  49.         "parent": "7f970ef07c90",
  50.         "children": [
  51.             {
  52.                 "parent": "7f970ef081f0",
  53.                 "start_pos": 39,
  54.                 "end_pos": 51
  55.             }
  56.         ],
  57.         "start_pos": 0,
  58.         "end_pos": 53,
  59.         "objects": {},
  60.         "struct_fields": []
  61.     },
  62.     "errors": [],
  63.     "warnings": [],
  64.     "imported_symbols": {},
  65.     "generic_fns": [],
  66.     "stmts": [
  67.         {
  68.             "ast_type": "Module",
  69.             "name": "main",
  70.             "is_skipped": false,
  71.             "pos": {
  72.                 "line_nr": 0,
  73.                 "pos": 0,
  74.                 "len": 19
  75.             }
  76.         },
  77.         {
  78.             "ast_type": "Import",
  79.             "mod": "os",
  80.             "alias": "os",
  81.             "syms": [],
  82.             "pos": {
  83.                 "line_nr": 2,
  84.                 "pos": 20,
  85.                 "len": 2
  86.             }
  87.         },
  88.         {
  89.             "ast_type": "Import",
  90.             "mod": "time",
  91.             "alias": "time",
  92.             "syms": [],
  93.             "pos": {
  94.                 "line_nr": 3,
  95.                 "pos": 30,
  96.                 "len": 4
  97.             }
  98.         },
  99.         {
  100.             "ast_type": "FnDecl",
  101.             "name": "main.main",
  102.             "mod": "main",
  103.             "is_deprecated": false,
  104.             "is_pub": false,
  105.             "is_variadic": false,
  106.             "is_anon": false,
  107.             "receiver": {
  108.                 "ast_type": "Field",
  109.                 "name": "",
  110.                 "typ": "void",
  111.                 "pos": {
  112.                     "line_nr": 0,
  113.                     "pos": 0,
  114.                     "len": 0
  115.                 }
  116.             },
  117.             "receiver_pos": {
  118.                 "line_nr": 0,
  119.                 "pos": 0,
  120.                 "len": 0
  121.             },
  122.             "is_method": false,
  123.             "method_idx": 0,
  124.             "rec_mut": false,
  125.             "rec_share": "enum:0(mut)",
  126.             "language": "enum:0(v)",
  127.             "no_body": false,
  128.             "is_builtin": false,
  129.             "is_generic": false,
  130.             "is_direct_arr": false,
  131.             "pos": {
  132.                 "line_nr": 5,
  133.                 "pos": 36,
  134.                 "len": 9
  135.             },
  136.             "body_pos": {
  137.                 "line_nr": 7,
  138.                 "pos": 51,
  139.                 "len": 1
  140.             },
  141.             "file": "/Users/xxx/v/vprojects/v_test/main.v",
  142.             "return_type": "void",
  143.             "source_file": 0,
  144.             "scope": 250645264,
  145.             "attrs": [],
  146.             "params": [],
  147.             "stmts": [],
  148.             "comments": [],
  149.             "next_comments": []
  150.         }
  151.     ]
  152. }

Module 模块

AST结构体

  1. Module 模块声明语句
  2. Import 模块导入语句

示例代码

  1. module  main
  3. import os // comment for mod
  4. //comment for time
  5. import time as t
  6. import math { min, max }
  8. fn main() {
  10. }

Const 常量

AST结构体

  1. ConstDecl 常量声明语句
  2. ConstField 常量字段

示例代码

  1. module main
  3. pub const p = 3.14
  4. const (
  5.     // version comment 1
  6.     version = '0.2.0' // version comment 2
  7.     usage   = 'usage:xxxx'
  8.     pi      = 3.14
  9.     //end comment 1
  10.     //end comment 2
  11. )

Enum 枚举

  1. EnumDecl 枚举声明语句
  2. EnumField 枚举字段语句
  3. EnumVal 枚举值表达式

示例代码

  1. module main
  3. [attr1]
  4. ['attr2:123']
  5. enum Color { // enum comment 1
  6.     // black comment 1
  7.     // black comment 2
  8.     black = 2 // black comment 3
  9.     // white comment 1
  10.     // white comment 2
  11.     white // white comment 3
  12.     blue
  13.     green // green comment
  14.     // end comment 1
  15.     // end comment 2
  16. }
  18. [flag]
  19. enum BitEnum {
  20.     e1
  21.     e2
  22.     e3
  23. }
  25. [_allow_multiple_values]
  26. enum MultipleEnum {
  27.     v1 = 1
  28. }
  30. fn main() {
  31.     mut color := Color.black
  32.     color = .blue
  33. }

Variable 变量

Assign 变量赋值语句

AST结构体

  1. AssignStmt 变量赋值语句
  2. Var 变量

示例代码

  1. module main
  3. fn main() {
  4.     // an assignment
  5.     a := 'abc' // comment for a
  6.     mut b := 1
  7.     // more operator
  8.     b = 2
  9.     b += 2
  10.     b -= 2
  11.     b *= 2
  12.     b /= 2
  13.     b %= 2
  14.     // multi assign
  15.     x, y, z := 1, 'y', 3.3
  16.     mut xx, mut yy, zz := 1, 3, 5
  17.     // swap variable
  18.     mut c := 1
  19.     mut d := 2
  20.     c, d = d, c
  21. }

Identifier 标识符

AST结构体

  1. Ident 标识符表达式
  2. IdentFn 函数标识符
  3. IdentVar 变量标识符

示例代码

  1. module main
  3. fn main() {
  4.     i := 123 // common(unresolved) identifier
  5.     _, x := 1, 2 // blank identifier
  6.     mut s := 'abc' // with mut
  7.     s = 'aaa'
  8. }

Literal 字面量

AST结构体

  1. IntegerLiteral 整数字面量
  2. FloatLiteral    小数字面量
  3. StringLiteral    字符串字面量
  4. StringInterLiteral 字符串模板字面量
  5. CharLiteral 单字符字面量
  6. BoolLiteral 布尔值字面量

示例代码

  1. module main
  3. fn main() {
  4.     a := 1 // integer literal
  5.     b := 1.2 // float literal
  6.     c := 'abc' // string literal
  7.   name:='tom'
  8.   age:= 33
  9.   //string literal with `$xx` or `${xxx}`
  10.     s1 := 'a is $a,b is $b,c is $c' 
  11.     s2 := 'name is ${name}, age is ${age}'
  12.     e := `c` // char literal
  13.     f := true // bool literal
  14. }

AsCast as造型语句

AST结构体

  1. AsCast as造型语句

示例代码

  1. module main
  3. type Mysumtype = bool | f64 | int | string
  5. fn main() {
  6.     x := Mysumtype(3)
  7.     x2 := x as int // as must be used for sumtype
  8.     println(x2)
  9. }

SizeOf sizeof语句

AST结构体

  1. SizeOf sizeof语句

示例代码

  1. module main
  3. struct Point {
  4.     x int
  5.     y int
  6. }
  8. fn main() {
  9.     a := sizeof(int) // basic type
  10.     b := sizeof(bool) // basic type
  11.     p := Point{
  12.         x: 1
  13.         y: 2
  14.     }
  15.     s1 := sizeof(Point) // struct type
  16.     s2 := sizeof(p) // variable
  17. }

TypeOf typeof语句

AST结构体

  1. TypeOf  typeof语句

示例代码

  1. module main
  3. type MySumType = f32 | int
  5. fn myfn(i int) int {
  6.     return i
  7. }
  9. fn main() {
  10.     a := 123
  11.     s := 'abc'
  12.     aint := []int{}
  13.     astring := []string{}
  14.     println(typeof(a)) // int
  15.     println(typeof(s)) // string
  16.     println(typeof(aint)) // array_int
  17.     println(typeof(astring)) // array_string
  18.     // sumtype
  19.     sa := MySumType(32)
  20.     println(typeof(sa)) // int
  21.     // function type
  22.     println(typeof(myfn)) // fn (int) int
  23. }

CastExpr 造型表达式

AST结构体

  1. CastExpr 造型表达式

示例代码 ( todo: need more about string(buf,n) )

  1. module main
  3. fn main() {
  4.     x:=byte(3)
  5.     y:=f32(2.1)
  6. }

Array 数组

ArrayInit 数组初始化语句

AST结构体

  1. ArrayInit 数组初始化语句

示例代码

  1. module main
  3. fn main() {
  4.     mut arr := []string{len: 3, cap: 6, init: 'default'}
  5.     arr[0] = 'a'
  6.     arr[1] = 'b'
  7.     println(arr)
  8. }

IndexExpr 索引表达式

AST结构体

  1. IndexExpr 索引表达式

示例代码

  1. module main
  3. fn main() {
  4.     mut arr := []string{len: 3, cap: 6, init: 'default'}
  5.     arr[0] = 'a' //index expr
  6.     arr[1] = 'b'
  7.     println(arr)
  8.   mut m := map[string]string{}
  9.     m['name'] = 'tom' //index expr
  10.     m['age'] = '33'
  11. }

RangeExpr 数组区间表达式

AST结构体

  1. RangeExpr 数组区间表达式

示例代码

  1. module main
  3. fn main() {
  4.     n := [1, 2, 3, 4, 5]
  5.     a1 := n[..2] //[1, 2]
  6.     a2 := n[2..] //[3, 4, 5]
  7.     a3 := n[2..4] //[3, 4]
  8. }

ArrayDecompose 数组解构

AST结构体

  1. ArrayDecompose 数组解构

示例代码

  1. module main
  3. fn main() {
  4.     a := ['a', 'b', 'c'] 
  5.     println(variadic_fn_a(a...)) //ArrayDecompose
  6. }
  8. fn variadic_fn_a(a ...string) string {
  9.     return variadic_fn_b(a...) //ArrayDecompose
  10. }
  12. fn variadic_fn_b(a ...string) string {
  13.     a0 := a[0]
  14.     a1 := a[1]
  15.     a2 := a[2]
  16.     return '$a0$a1$a2'
  17. }

Map 字典

MapInit 字典初始化

AST结构体

  1. MapInit 字典初始化

示例代码

  1. module main
  3. fn main() {
  4.     mut m := map[string]string{} //map declaration
  5.     m['name'] = 'tom'
  6.     m['age'] = '33'
  7.     //map literal declaration and init
  8.     m2 := {
  9.         'one':   1
  10.         'two':   2
  11.         'three': 3
  12.     }
  13. }

Operator 操作符

PrefixExpr 前缀表达式

AST结构体

  1. PrefixExpr 前缀表达式

示例代码

  1. module main
  3. fn main() {
  4.     x := -1 // minus
  5.     p := &x // get address of variable
  6.     x2 := *p // get value of pointer
  7.     b := !true // logic not
  8.     bit := ~0x0000 // bit not
  9. }

InfixExpr 中缀表达式

AST结构体

  1. InfixExpr 中缀表达式

示例代码

  1. module main
  3. fn main() {
  4.     x := 1 + 2
  5.     y := 1 - 2
  6.     a := x == y // equal
  7.     b := x > y // compare
  8.     c := 1 in [1, 2] // in operator
  9.     d := (x > y) && (1 < 2) // logic and
  10.     e := 2 == 2 || 3 == 3 // logic or
  11.     mut arr := [1, 2] // array append
  12.     arr << 3
  13. }

PostfixExpr 后缀表达式

AST结构体

  1. PostfixExpr 后缀表达式

示例代码

  1. module main
  3. fn main() {
  4.     mut x:=1
  5.     x++
  6.     x--
  7. }

SelectorExpr 选择器表达式

AST结构体

  1. SelectorExpr 选择器表达式

示例代码

  1. module main
  3. struct Point {
  4. mut:
  5.     x int
  6.     y int
  7. }
  9. fn (mut p Point) move(a int, b int) {
  10.     p.x += a // selector for struct field assign
  11.     p.y += b
  12. }
  14. fn main() {
  15.     mut p := Point{
  16.         x: 1
  17.         y: 3
  18.     }
  19.     p.x // selector for access field value
  20.     p.move(2, 3)
  21. }

ParExpr 括号表达式

AST结构体

  1. ParExpr 括号表达式

示例代码

  1. module main
  3. fn main() {
  4.     x:=(1+2)
  5.     y:=(1<2)
  6. }

ConcatExpr 连接表达式

AST结构体

  1. ConcatExpr 连接表达式

示例代码

  1. a, b, c := match false {
  2.     true { 1, 2, 3 }
  3.     false { 4, 5, 6 }
  4.     else { 7, 8, 9 }
  5. }

Function 函数

FnDecl 函数声明

AST结构体

  1. FnDecl 函数声明语句
  3. CallExpr 函数调用表达式
  5. CallArg  调用参数
  7. Return 返回值语句

示例代码

  1. module main
  3. fn main() {
  4.     s := add(1, 3)
  5.     println(s)
  6.     s2 := add_generic(2, 4)
  7.     s3 := add_generic<int>(2, 4)
  8.     println(s2)
  9.     println(s3)
  10. }
  12. // function
  13. fn add(x int, y int) int {
  14.     return x + y
  15. }
  17. struct Point {
  18.     x int
  19.     y int
  20. }
  22. // method
  23. pub fn (p Point) move(a int, b int) (int, int) {
  24.     new_x := p.x + a
  25.     new_y := p.y + b
  26.     return new_x, new_y
  27. }
  29. // generic function
  30. fn add_generic<T>(x T, y T) T {
  31.     return x + y
  32. }

AnonFn 匿名函数

AST结构体

  1. AnonFn 匿名函数

示例代码

  1. module main
  3. fn main() {
  4.     f1 := fn (x int, y int) int {
  5.         return x + y
  6.     }
  7.     f1(1,3)
  8. }

DeferStmt 函数defer语句

AST结构体

  1. DeferStmt  函数defer语句

示例代码

  1. fn main() {
  2.     println('main start')
  3.     // defer {defer_fn1()} 
  4.     // defer {defer_fn2()}
  5.     defer {
  6.         defer_fn1()
  7.     }
  8.     defer {
  9.         defer_fn2()
  10.     }
  11.     println('main end')
  12. }
  14. fn defer_fn1() {
  15.     println('from defer_fn1')
  16. }
  18. fn defer_fn2() {
  19.     println('from defer_fn2')
  20. }

Struct 结构体

StructDecl 结构体声明语句

AST结构体

  1. StructDecl 结构体声明语句
  3. StructField 结构体字段
  5. Embed 结构体组合

示例代码

  1. module main
  3. [attr1]
  4. [attr2]
  5. struct Point { //comment 1
  6. mut:
  7.     x int [attr3]
  8.     y int ['attr4=123']
  9. pub mut:
  10.     z int = 1
  11. //end comment
  12. }
  14. fn main() {
  15. }

示例代码

  1. module main
  3. struct Widget {
  4. mut:
  5.     x int
  6.     y int
  7. }
  9. pub fn (mut w Widget) move(x_step int, y_step int) {
  10.     w.x += x_step
  11.     w.y += y_step
  12. }
  14. struct Widget2 {
  15. mut:
  16.     z int
  17. }
  19. pub fn (mut w Widget2) move_z(z_step int) {
  20.     w.z += z_step
  21. }
  23. struct Button {
  24.     Widget //embed
  25.     Widget2 //embed
  26.     title string
  27. }
  29. fn main() {
  30.     mut button := Button{
  31.         title: 'Click me'
  32.     }
  33.     button.x = 3 // x comes from Widget
  34.     button.z = 4 // z comes from Widget2
  35.     println('x:$button.x,y:$button.y,z:$button.z')
  36.     button.move(3, 4) // move comes from Widget
  37.     println('x:$button.x,y:$button.y,z:$button.z')
  38.     button.move_z(5) // move_z comes from Widget2
  39.     println('x:$button.x,y:$button.y,z:$button.z')
  40. }

StructInit 结构体初始化表达式

AST结构体

  1. StructInit 结构体初始化
  3. StructInitField 结构体初始化字段
  5. StructInitEmbed 结构体初始化组合

示例代码 

  1. module main
  3. struct User {
  4.     name string
  5.     age int
  6. }
  8. fn add(u User) {
  9.     println(u)
  10. }
  12. fn main(){
  13.     add(User{name:'jack',age:22}) //standard
  14.     add({name:'tom',age:23}) //short
  15.     add(name:'tt',age:33) // more short
  16. }

结构体初始化例子

  1. struct City {
  2.     name       string
  3.     population int
  4. }
  6. struct Country {
  7.     name    string
  8.     capital City
  9. }
  11. fn main() {
  12.     ccc := Country{
  13.         name: 'test'
  14.         capital: City{
  15.             name: 'city'
  16.         }
  17.     }
  18.     c2 := Country{
  19.         ...ccc  //update_expr
  20.         capital: City{
  21.             name: 'city2'
  22.             population: 200
  23.         }
  24.     }
  25.     println(c2)
  26. }

Interface 接口

InterfaceDecl 接口声明语句

AST结构体

  1. InterfaceDecl 接口声明语句

示例代码

  1. module main
  3. interface Speaker { //comment 1
  4.     speak() string
  5.     silent()
  6. }

Type 类型

AliasType 类型别名声明语句

AST结构体

  1. AliasTypeDecl 类型别名声明语句

示例代码

  1. module main
  3. struct Human {
  4.     name string
  5. }
  6. type Myint =  int /*comment 1*/ //comment 2
  7. type Person = Human

FunctionType 函数类型声明语句

AST结构体

  1. FnTypeDecl  函数类型声明语句

示例代码

  1. module main
  3. type Mid_fn = fn (int, string) int /*comment 1*/ //comment 2

Sumtype 联合类型

AST结构体

  1. SumTypeDecl 联合类型声明语句

示例代码

  1. module main
  3. struct User {
  4.     name string
  5.     age  int
  6. }
  8. type MySumtype = User | int | string //comment 1

TypeNode 类型表达式

主要用于联合类型的match类型匹配,以及is类型判断

AST结构体

  1. TypeNode 类型表达式

示例代码

  1. module main
  3. struct User {
  4.     name string
  5.     age  int
  6. }
  8. pub fn (m &User) str() string {
  9.     return 'name:$m.name,age:$m.age'
  10. }
  12. type MySum = User | int | string
  14. pub fn (ms MySum) str() string {
  15.     if ms is int { //类型表达式
  17.     }
  18.     match ms { 
  19.         int { //类型表达式
  20.             return ms.str()
  21.         }
  22.         string { //类型表达式
  23.             return ms 
  24.         }
  25.         User { //类型表达式
  26.             return ms.str()
  27.         }
  28.     }
  29. }

FlowControl 流程控制

Block 代码块语句

AST结构体

  1. Block 代码块语句

示例代码

  1. fn main() {
  2.     my_fn()
  3. }
  5. fn my_fn() {
  6.     // block
  7.     {
  8.         println('in block')
  9.     }
  10.     // unsafe block
  11.     unsafe {
  12.     }
  13. }

if 条件语句

AST结构体

  1. IfExpr if表达式
  2. IfBranch if条件分支
  3. IfGuardExpr if守护条件表达式

示例代码

  1. module main
  3. //带错误的函数
  4. fn my_fn(i int) ?int {
  5.     if i == 0 {
  6.         return error('Not ok!') //抛出错误
  7.     }
  8.     if i == 1 {
  9.         return none //抛出错误
  10.     }
  11.     return i //正常返回
  12. }
  14. fn main() {
  15.     a := 10
  16.     b := 20
  17.     // if statement
  18.     if a < b {
  19.         println('$a < $b')
  20.     } else if a > b {
  21.         println('$a > $b')
  22.     } else {
  23.         println('$a == $b')
  24.     }
  26.     // if guard expr
  27.     if c := my_fn(2) { // if守护条件,调用函数时,正常返回,执行if分支
  28.         println('$c')
  29.     } else {
  30.         println('from else')
  31.     }
  32.     if c := my_fn(1) { // if守护条件,调用函数时,抛出错误,执行else分支
  33.         println('$c')
  34.     } else {
  35.         println('from else')
  36.     }
  38.     // if守护条件,其实等价于
  39.     cc := my_fn(22) or {
  40.         println('from or')
  41.         0
  42.     }
  43.     println(cc)
  45.     // if expr
  46.     num := 777
  47.     s := if num % 2 == 0 { 'even' } else { 'odd' }
  48.     x, y, z := if true { 1, 'awesome', 13 } else { 0, 'bad', 0 }
  49.     // compile time if
  50.     $if macos {
  51.     } $else {
  52.     }
  53.     println('s:$s,x:$x,y:$y,z:$z')
  54. }

match 分支匹配

AST结构体

  1. MatchExpr 匹配表达式
  2. MatchBranch 匹配分支

示例代码

  1. fn main() {
  2.     os := 'macos'
  3.     // match statement
  4.     match os {
  5.         'windows' { println('windows') }
  6.         'macos', 'linux' { println('macos or linux') }
  7.         else { println('unknow') }
  8.     }
  9.     // match expr
  10.     price := match os {
  11.         'windows' { 100 }
  12.         'linux' { 120 }
  13.         'macos' { 150 }
  14.         else { 0 }
  15.     }
  16.     // multi assign 
  17.     a, b, c := match false {
  18.         true { 1, 2, 3 }
  19.         false { 4, 5, 6 }
  20.         else { 7, 8, 9 }
  21.     }
  22. }
  24. type MySum = bool | int | string
  26. pub fn (ms MySum) str() string {
  27.     // match sum type
  28.     match ms {
  29.         int { return ms.str() }
  30.         string { return ms }
  31.         else { return 'unknown' }
  32.     }
  33. }

for 循环语句

AST结构体

  1. ForCStmt forC循环语句
  2. ForInStmt forin循环语句
  3. ForStmt for循环语句
  4. BranchStmt 分支语句

示例代码

  1. fn main() {
  2.     for i := 0; i < 10; i++ {
  3.         if i == 6 {
  4.             continue
  5.         }
  6.         if i == 10 {
  7.             break
  8.         }
  9.         println(i)
  10.     }
  11. }

示例代码

  1. fn main() {
  2.     // string
  3.     str := 'abcdef'
  4.     for s in str {
  5.         println(s.str())
  6.     }
  7.     // array
  8.     numbers := [1, 2, 3, 4, 5]
  9.     for num in numbers {
  10.         println('num:$num')
  11.     }
  12.     // range
  13.     mut sum := 0
  14.     for i in 1 .. 11 {
  15.         sum += i
  16.     }
  17.     // map
  18.     m := {
  19.         'name': 'jack'
  20.         'age':  '20'
  21.         'desc': 'good man'
  22.     }
  23.     for key, value in m {
  24.         println('key:$key,value:$value')
  25.     }
  26. }

示例代码

  1. fn main() {
  2.     mut sum := 0
  3.     mut x := 0
  4.     for x <= 100 {
  5.         sum += x
  6.         x++
  7.     }
  8.     println(sum)
  9.     // label for
  10.     mut i := 4
  11.     goto L1
  12.     L1: for { // label for
  13.         i++
  14.         for {
  15.             if i < 7 {
  16.                 continue L1
  17.             } else {
  18.                 break L1
  19.             }
  20.         }
  21.     }
  22. }

goto 跳转语句

AST结构体

  1. GotoLabel 跳转标签
  2. GotoStmt 跳转语句

示例代码

  1. fn main() {
  2.     mut i := 0
  3.     a: // goto label
  4.     i++
  5.     if i < 3 {
  6.         goto a
  7.     }
  8.     println(i)
  9. }

Error handle 错误控制

AST结构体

  1. OrExpr or表达式
  2. None none表达式

示例代码

  1. fn my_fn(i int) ?int {
  2.     if i == 0 {
  3.         return error('Not ok!')
  4.     }
  5.     if i == 1 {
  6.         return none
  7.     }
  8.     return i
  9. }
  11. fn main() {
  12.     println('from main') // OrKind is absent
  13.     v1 := my_fn(0) or { // OrKind is block
  14.         println('from 0')
  15.         panic(err)
  16.     }
  17.     v2 := my_fn(1) or { 
  18.         println('from 1') 
  19.         panic('error msg is $err')    
  20.     }
  21.     v3 := my_fn(2) or {
  22.         println('from 2')
  23.         return
  24.     }
  25.     v4 := my_fn(3) ? // OrKind is propagate
  26. }

Concurrent 并发

ChanInit 通道初始化

AST结构体

  1. ChanInit 通道初始化语句
  2. GoStmt go并发语句

示例代码

  1. module main
  3. const (
  4.     num_iterations = 10000
  5. )
  7. fn do_send(ch chan int) {
  8.     for i in 0 .. num_iterations {
  9.         ch <- i
  10.     }
  11. }
  13. fn main() {
  14.     ch := chan int{cap: 1000} // chan init
  15.     go do_send(ch) // go statement
  16.     mut sum := i64(0)
  17.     for _ in 0 .. num_iterations {
  18.         sum += <-ch
  19.         println(sum)
  20.     }
  21. }

SelectExpr 通道监听表达式

AST结构体

  1. SelectExpr 通道监听表达式
  2. SelectBranch 通道监听分支

示例代码

  1. import time
  2. import sync
  4. fn main() {
  5.     ch1 := chan int{}
  6.     ch2 := chan int{}
  7.     go send(ch1, ch2)
  8.     mut x := 0
  9.     mut y := 0
  10.     for {
  11.         select { // 
  12.             x = <-ch1 { // read channel
  13.                 println('$x')
  14.             }
  15.             y = <-ch2 {
  16.                 println('$y')
  17.             }
  18.             > 2 * time.second { // timeout
  19.                 break
  20.             }
  21.         }
  22.     }
  23. }
  25. fn send(ch1 chan int, ch2 chan int) {
  26.     ch1 <- 1
  27.     ch2 <- 2
  28.     ch1 <- 3
  29.     ch2 <- 4
  30.     ch1 <- 5
  31.     ch2 <- 6
  32. }

LockExpr 并发锁表达式

AST结构体

  1. LockExpr 并发锁表达式

示例代码

  1. module main
  3. import time
  5. struct St {
  6. mut:
  7.     x f64
  8. }
  10. fn f(x int, y f64, shared s St,shared m map[string]string) {
  11.     time.usleep(50000)
  12.     lock s,m { 
  13.         s.x = x * y
  14.         println(s.x)
  15.         unsafe {
  16.             m['a']='aa'
  17.         }
  18.         println(m['a'])
  19.     }
  20.     return
  21. }
  23. fn main() {
  24.     shared t := &St{}
  25.     shared m := &map[string]string
  26.     unsafe {
  27.         m['a']='aa'
  28.     }
  29.     r := go f(3, 4.0, shared t,shared m) 
  30.     r.wait()
  31.     rlock t { 
  32.         println(t.x)
  33.     }
  34. }

GoExpr 并发表达式

AST结构体

  1. GoExpr 并发表达式

示例代码

  1. module main
  3. import time
  5. fn do_something() { 
  6.  println('start do_something...')
  7.     time.sleep(2) 
  8.     println('end do_something')
  9. }
  10. fn add(x int, y int) int { 
  11.     println('add start...')
  12.     time.sleep(4) //
  13.     println('end add')
  14.     return x + y
  15. }
  17. fn main() {
  18.   g:= go do_something()
  19.   g2 := go add(3, 2) 
  20.   g.wait() 
  21.     result := g2.wait()
  22.     println(result)
  23. }

Unsafe 不安全代码

AST结构体

  1. UnsafeExpr 不安全代码表达式

示例代码

  1. module main
  3. fn main() {
  4.     a := ['a', 'b', 'c']
  5.     p := unsafe { &a[2] } // unsafe expr
  6.     println(p)
  7. }

ASM 汇编

AST结构体

  1. AsmStmt 汇编语句
  3. AsmTemplate
  4. AsmClobbered
  5. AsmIO
  6. AsmArg
  7. AsmAddressing
  8. AsmAlias
  9. AsmRegister

示例代码

  1. fn main() {
  2.     a := 100
  3.     b := 20
  4.     mut c := 0
  5.     asm amd64 {
  6.         mov eax, a
  7.         add eax, b
  8.         mov c, eax
  9.         ; =r (c) // output 
  10.         ; r (a) // input 
  11.           r (b)
  12.     }
  13.     println('a: $a') // 100
  14.     println('b: $b') // 20
  15.     println('c: $c') // 120
  16. }

SQL SQL语句

AST结构体

  1. SqlStmt sql语句
  2. SqlExpr sql表达式

示例代码

  1. module main
  3. import sqlite
  5. struct Module {
  6.     id           int
  7.     name         string
  8.     nr_downloads int
  9. }
  11. struct User {
  12.     id             int
  13.     age            int
  14.     name           string
  15.     is_customer    bool
  16.     skipped_string string [skip]
  17. }
  19. struct Foo {
  20.     age int
  21. }
  23. fn main() {
  24.     db := sqlite.connect(':memory:') or { panic(err) }
  25.     db.exec('drop table if exists User')
  26.     db.exec("create table User (id integer primary key, age int default 0, name text default '', is_customer int default 0);")
  27.     name := 'Peter'
  28.     db.exec("insert into User (name, age) values ('Sam', 29)")
  29.     db.exec("insert into User (name, age) values ('Peter', 31)")
  30.     db.exec("insert into User (name, age, is_customer) values ('Kate', 30, 1)")
  31.     nr_all_users := sql db {
  32.         select count from User
  33.     }
  34.     println('nr_all_users=$nr_all_users')
  35.     //
  36.     nr_users1 := sql db {
  37.         select count from User where id == 1
  38.     }
  39.     println('nr_users1=$nr_users1')
  40.     //
  41.     nr_peters := sql db {
  42.         select count from User where id == 2 && name == 'Peter'
  43.     }
  44.     //
  45.     new_user := User{
  46.         name: 'New user'
  47.         age: 30
  48.     }
  49.     sql db {
  50.         insert new_user into User
  51.     }
  52.     sql db {
  53.         update User set age = 31 where name == 'Kate'
  54.     }
  55.     sql db {
  56.         delete from User where age == 34
  57.     }
  58. }

TestAssert 测试断言

AssertStmt 测试断言语句

AST结构体

  1. AssertStmt 测试断言语句

示例代码

  1. fn test_abc() {
  2.     x := 1
  3.     assert x == 1
  4. }

DumpExpr 转储函数表达式

AST结构体

  1. DumpExpr 转储函数表达式

示例代码

  1. fn factorial(n u32) u32 {
  2.     if dump(n <= 1) {
  3.         return dump(1)
  4.     }
  5.     return dump(n * factorial(n - 1))
  6. }
  8. fn main() {
  9.     println(factorial(5))
  10. }

Compile time 编译时

CompFor 编译时循环语句

AST结构体

  1. CompFor 编译时循环语句
  2. ComptimeCall 编译时调用表达式
  3. ComptimeSelector 编译时选择器表达式

示例代码

  1. struct App {
  2.     a string
  3.     b string
  4. mut:
  5.     c int
  6.     d f32
  7. pub:
  8.     e f32
  9.     f u64
  10. pub mut:
  11.     g string
  12.     h byte
  13. }
  15. fn (mut app App) m1() {
  16. }
  18. fn (mut app App) m2() {
  19. }
  21. fn (mut app App) m3() int {
  22.     return 0
  23. }
  25. fn main() {
  26.     $for field in App.fields {
  27.         println('field: $field.name')
  28.     }
  29.     $for method in App.methods {
  30.         println('method: $method.name')
  31.     }
  32. }

AtExpr at全局常量表达式

AST结构体

  1. AtExpr at全局常量量表达式

示例代码

  1. module main
  3. fn main() {
  4.     println('module: ${@MOD}')            //当前模块
  5.     println('fn: ${@FN}')                //当前函数
  6.     println('sturct: ${@STRUCT}')        //当前结构体
  7.     println('method: ${@METHOD}')        //当前方法
  8.     println('vexe: ${@VEXE}')            //当前V编译器命令行可执行文件
  9.     println('vexeroot: ${@VEXEROOT}')    //当前V编译器命令行所在的目录
  10.     println('file: ${@FILE}')            //当前源代码文件名
  11.     println('line: ${@LINE}')            //当前代码所在的行
  12.     println('column: ${@COLUMN}')        //当前代码在当前行中的列数
  13.     println('vhash: ${@VHASH}')            //当前V命令行编译时的hash    
  14.     println('vmod_file: ${@VMOD_FILE}')    //当前文件所处项目的v.mod文件内容
  15.     println('vmodroot: ${@VMODROOT}')    //当前文件所处项目的v.mod文件所在的目录
  16. }

C Integration C代码互操作

GlobalDecl 全局变量声明

AST结构体

  1. GlobalDecl 全局变量声明
  2. GlobalField 全局字段声明

示例代码

  1. module main
  3. // single
  4. __global  g1 int
  6. // group
  7. __global (
  8.     g2 byte 
  9.     g3 byte 
  10. )
  12. fn main() {
  13.     g1 = 1
  14.     g2 = 2
  15.     g3 = 3
  16.     println(g1)
  17.     println(g2)
  18.     println(g3)
  19. }

HashStmt C宏指令语句

AST结构体

  1. HashStmt C宏指令语句

示例代码

  1. module main
  3. #include <stdio.h> 
  5. #flag -lmysqlclient
  6. #flag linux -I/usr/include/mysql
  7. #include <mysql.h>
  9. fn main() {
  11. }

Likely likely表达式

AST结构体

  1. Likely

示例代码

  1. module main
  3. fn main() {
  4.     x := 1
  5.     if _likely_(x == 1) {
  6.         println('a')
  7.     } else {
  8.         println('b')
  9.     }
  10.     if _unlikely_(x == 1) {
  11.         println('a')
  12.     } else {
  13.         println('b')
  14.     }
  15. }

OffsetOf 结构体字段内存偏移量

AST结构体

  1. OffsetOf 结构体字段内存偏移量

示例代码

  1. module main
  3. struct User {
  4.     name [50]byte
  5.     age int
  6.     desc string
  7. }
  9. fn main() {
  10.     offset_name:=__offsetof(User,name)
  11.     offset_age:=__offsetof(User,age)
  12.     offset_desc:=__offsetof(User,desc)
  13.     println(offset_name)
  14.     println(offset_age)
  15.     println(offset_desc)
  16. }

Comment 注释

AST结构体

  1. Comment 注释

示例代码

  1. module main
  2. /*
  3. multi line comment
  4. multi line comment
  5. */
  6. // signle line comment
  7. fn main() {
  8.     x := 1 // behind statement comment
  9. }

Other 其他

Empty 空语句/表达式

只在编译内部使用,用来判断空语句和空表达式.

AST结构体

  1. EmptyStmt 空语句
  2. EmptyExpr 空表达式

NodeError 错误节点

只在编译内部使用,当解析器报错时,返回NodeError节点.

NodeError既是语句,也是表达式.