V抽象语法树

V语言所有的语法树结构体都在标准库的v.ast模块中定义，主要是通过联合类型来实现。

用联合类型来实现语法树，代码显得非常的简洁，清晰。

v ast子命令

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

v ast main.v       //生成json格式的AST语法树文件main.json
v ast -w main.v    //生成main.json,并且监控源文件变化，保存后自动重新生成
v ast -c main.v    //同时生成AST语法树文件main.json和C源代码main.c,并监控源文件变化，保存后自动重新生成
v ast -p main.v    //直接在终端中输出AST语法树
v ast -t main.v    //输出简洁版的AST语法树文件main.json[]

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

语法树结构体总览

ast.File语法树文件

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

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

AST结构体

File 语法树文件

示例代码

module main

import os
import time

fn main() {
  
}

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

{
	"ast_type": "ast.File"，
	"path": "/Users/xxx/v/vprojects/v_test/main.v"，
	"mod": {
		"ast_type": "Module"，
		"name": "main"，
		"is_skipped": false,
		"pos": {
			"line_nr": 0,
			"pos": 0,
			"len": 19
		}
	}，
	"imports": [
		{
			"ast_type": "Import"，
			"mod": "os"，
			"alias": "os"，
			"syms": []，
			"pos": {
				"line_nr": 2,
				"pos": 20,
				"len": 2
			}
		}，
		{
			"ast_type": "Import"，
			"mod": "time"，
			"alias": "time"，
			"syms": []，
			"pos": {
				"line_nr": 3,
				"pos": 30,
				"len": 4
			}
		}
	]，
	"global_scope": {
		"ast_type": "Scope"，
		"parent": "0"，
		"children": []，
		"start_pos": 0,
		"end_pos": 0,
		"objects": {}，
		"struct_fields": []
	}，
	"scope": {
		"ast_type": "Scope"，
		"parent": "7f970ef07c90"，
		"children": [
			{
				"parent": "7f970ef081f0"，
				"start_pos": 39,
				"end_pos": 51
			}
		]，
		"start_pos": 0,
		"end_pos": 53,
		"objects": {}，
		"struct_fields": []
	}，
	"errors": []，
	"warnings": []，
	"imported_symbols": {}，
	"generic_fns": []，
	"stmts": [
		{
			"ast_type": "Module"，
			"name": "main"，
			"is_skipped": false,
			"pos": {
				"line_nr": 0,
				"pos": 0,
				"len": 19
			}
		}，
		{
			"ast_type": "Import"，
			"mod": "os"，
			"alias": "os"，
			"syms": []，
			"pos": {
				"line_nr": 2,
				"pos": 20,
				"len": 2
			}
		}，
		{
			"ast_type": "Import"，
			"mod": "time"，
			"alias": "time"，
			"syms": []，
			"pos": {
				"line_nr": 3,
				"pos": 30,
				"len": 4
			}
		}，
		{
			"ast_type": "FnDecl"，
			"name": "main.main"，
			"mod": "main"，
			"is_deprecated": false,
			"is_pub": false,
			"is_variadic": false,
			"is_anon": false,
			"receiver": {
				"ast_type": "Field"，
				"name": ""，
				"typ": "void"，
				"pos": {
					"line_nr": 0,
					"pos": 0,
					"len": 0
				}
			}，
			"receiver_pos": {
				"line_nr": 0,
				"pos": 0,
				"len": 0
			}，
			"is_method": false,
			"method_idx": 0,
			"rec_mut": false,
			"rec_share": "enum:0(mut)"，
			"language": "enum:0(v)"，
			"no_body": false,
			"is_builtin": false,
			"is_generic": false,
			"is_direct_arr": false,
			"pos": {
				"line_nr": 5,
				"pos": 36,
				"len": 9
			}，
			"body_pos": {
				"line_nr": 7,
				"pos": 51,
				"len": 1
			}，
			"file": "/Users/xxx/v/vprojects/v_test/main.v"，
			"return_type": "void"，
			"source_file": 0,
			"scope": 250645264,
			"attrs": []，
			"params": []，
			"stmts": []，
			"comments": []，
			"next_comments": []
		}
	]
}

Module 模块

AST结构体

Module 模块声明语句
Import 模块导入语句

示例代码

module  main

import os // comment for mod
//comment for time
import time as t
import math { min, max }

fn main() {
  
}

Const 常量

AST结构体

ConstDecl 常量声明语句
ConstField 常量字段

示例代码

module main

pub const p = 3.14
const (
	// version comment 1
	version = '0.2.0' // version comment 2
	usage   = 'usage:xxxx'
	pi      = 3.14
	//end comment 1
	//end comment 2
)

Enum 枚举

EnumDecl 枚举声明语句
EnumField 枚举字段语句
EnumVal 枚举值表达式

示例代码

module main

[attr1]
['attr2:123']
enum Color { // enum comment 1
	// black comment 1
	// black comment 2
	black = 2 // black comment 3
	// white comment 1
	// white comment 2
	white // white comment 3
	blue
	green // green comment
	// end comment 1
	// end comment 2
}

[flag]
enum BitEnum {
	e1
	e2
	e3
}

[_allow_multiple_values]
enum MultipleEnum {
	v1 = 1
}

fn main() {
	mut color := Color.black
	color = .blue
}

Variable 变量

Assign 变量赋值语句

AST结构体

AssignStmt 变量赋值语句
Var 变量

示例代码

module main

fn main() {
	// an assignment
	a := 'abc' // comment for a
	mut b := 1
	// more operator
	b = 2
	b += 2
	b -= 2
	b *= 2
	b /= 2
	b %= 2
	// multi assign
	x, y, z := 1, 'y'， 3.3
	mut xx, mut yy, zz := 1, 3, 5
	// swap variable
	mut c := 1
	mut d := 2
	c, d = d, c
}

Identifier 标识符

AST结构体

Ident 标识符表达式
IdentFn 函数标识符
IdentVar 变量标识符

示例代码

module main

fn main() {
	i := 123 // common(unresolved) identifier
	_, x := 1, 2 // blank identifier
	mut s := 'abc' // with mut
	s = 'aaa'
}

Literal 字面量

AST结构体

IntegerLiteral 整数字面量
FloatLiteral	小数字面量
StringLiteral	字符串字面量
StringInterLiteral 字符串模板字面量
CharLiteral 单字符字面量
BoolLiteral 布尔值字面量

示例代码

module main

fn main() {
	a := 1 // integer literal
	b := 1.2 // float literal
	c := 'abc' // string literal
  name:='tom'
  age:= 33
  //string literal with `$xx` or `${xxx}`
	s1 := 'a is $a,b is $b,c is $c' 
	s2 := 'name is ${name}， age is ${age}'
	e := `c` // char literal
	f := true // bool literal
}

AsCast as造型语句

AST结构体

AsCast as造型语句

示例代码

module main

type Mysumtype = bool | f64 | int | string

fn main() {
	x := Mysumtype(3)
	x2 := x as int // as must be used for sumtype
	println(x2)
}

SizeOf sizeof语句

AST结构体

SizeOf sizeof语句

示例代码

module main

struct Point {
	x int
	y int
}

fn main() {
	a := sizeof(int) // basic type
	b := sizeof(bool) // basic type
	p := Point{
		x: 1
		y: 2
	}
	s1 := sizeof(Point) // struct type
	s2 := sizeof(p) // variable
}

TypeOf typeof语句

AST结构体

TypeOf  typeof语句

示例代码

module main

type MySumType = f32 | int

fn myfn(i int) int {
	return i
}

fn main() {
	a := 123
	s := 'abc'
	aint := []int{}
	astring := []string{}
	println(typeof(a)) // int
	println(typeof(s)) // string
	println(typeof(aint)) // array_int
	println(typeof(astring)) // array_string
	// sumtype
	sa := MySumType(32)
	println(typeof(sa)) // int
	// function type
	println(typeof(myfn)) // fn (int) int
}

CastExpr 造型表达式

AST结构体

CastExpr 造型表达式

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

module main

fn main() {
	x:=u8(3)
	y:=f32(2.1)
}

Array 数组

ArrayInit 数组初始化语句

AST结构体

ArrayInit 数组初始化语句

示例代码

module main

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

IndexExpr 索引表达式

AST结构体

IndexExpr 索引表达式

示例代码

module main

fn main() {
	mut arr := []string{len: 3, cap: 6, init: 'default'}
	arr[0] = 'a' //index expr
	arr[1] = 'b'
	println(arr)
  mut m := map[string]string{}
	m['name'] = 'tom' //index expr
	m['age'] = '33'
}

RangeExpr 数组区间表达式

AST结构体

RangeExpr 数组区间表达式

示例代码

module main

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

ArrayDecompose 数组解构

AST结构体

ArrayDecompose 数组解构

示例代码

module main

fn main() {
	a := ['a'， 'b'， 'c'] 
	println(variadic_fn_a(a...)) //ArrayDecompose
}

fn variadic_fn_a(a ...string) string {
	return variadic_fn_b(a...) //ArrayDecompose
}

fn variadic_fn_b(a ...string) string {
	a0 := a[0]
	a1 := a[1]
	a2 := a[2]
	return '$a0$a1$a2'
}

Map 字典

MapInit 字典初始化

AST结构体

MapInit 字典初始化

示例代码

module main

fn main() {
	mut m := map[string]string{} //map declaration
	m['name'] = 'tom'
	m['age'] = '33'
	//map literal declaration and init
	m2 := {
		'one':   1
		'two':   2
		'three': 3
	}
}

Operator 操作符

PrefixExpr 前缀表达式

AST结构体

PrefixExpr 前缀表达式

示例代码

module main

fn main() {
	x := -1 // minus
	p := &x // get address of variable
	x2 := *p // get value of pointer
	b := !true // logic not
	bit := ~0x0000 // bit not
}

InfixExpr 中缀表达式

AST结构体

InfixExpr 中缀表达式

示例代码

module main

fn main() {
	x := 1 + 2
	y := 1 - 2
	a := x == y // equal
	b := x > y // compare
	c := 1 in [1, 2] // in operator
	d := (x > y) && (1 < 2) // logic and
	e := 2 == 2 || 3 == 3 // logic or
	mut arr := [1, 2] // array append
	arr << 3
}

PostfixExpr 后缀表达式

AST结构体

PostfixExpr 后缀表达式

示例代码

module main

fn main() {
	mut x:=1
	x++
	x--
}

SelectorExpr 选择器表达式

AST结构体

SelectorExpr 选择器表达式

示例代码

module main

struct Point {
mut:
	x int
	y int
}

fn (mut p Point) move(a int, b int) {
	p.x += a // selector for struct field assign
	p.y += b
}

fn main() {
	mut p := Point{
		x: 1
		y: 3
	}
	p.x // selector for access field value
	p.move(2, 3)
}

ParExpr 括号表达式

AST结构体

ParExpr 括号表达式

示例代码

module main

fn main() {
	x:=(1+2)
	y:=(1<2)
}

ConcatExpr 连接表达式

AST结构体

ConcatExpr 连接表达式

示例代码

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

Function 函数

FnDecl 函数声明

AST结构体

FnDecl 函数声明语句

CallExpr 函数调用表达式

CallArg  调用参数

Return 返回值语句

示例代码

module main

fn main() {
	s := add(1, 3)
	println(s)
	s2 := add_generic(2, 4)
	s3 := add_generic[int](2, 4)
	println(s2)
	println(s3)
}

// function
fn add(x int, y int) int {
	return x + y
}

struct Point {
	x int
	y int
}

// method
pub fn (p Point) move(a int, b int) (int, int) {
	new_x := p.x + a
	new_y := p.y + b
	return new_x, new_y
}

// generic function
fn add_generic[T](x T, y T) T {
	return x + y
}

AnonFn 匿名函数

AST结构体

AnonFn 匿名函数

示例代码

module main

fn main() {
	f1 := fn (x int, y int) int {
		return x + y
	}
	f1(1,3)
}

DeferStmt 函数defer语句

AST结构体

DeferStmt  函数defer语句

示例代码

fn main() {
	println('main start')
	// defer {defer_fn1()} 
	// defer {defer_fn2()}
	defer {
		defer_fn1()
	}
	defer {
		defer_fn2()
	}
	println('main end')
}

fn defer_fn1() {
	println('from defer_fn1')
}

fn defer_fn2() {
	println('from defer_fn2')
}

Struct 结构体

StructDecl 结构体声明语句

AST结构体

StructDecl 结构体声明语句

StructField 结构体字段

Embed 结构体组合

示例代码

module main

[attr1]
[attr2]
struct Point { //comment 1
mut:
	x int [attr3]
	y int ['attr4=123']
pub mut:
	z int = 1
//end comment
}

fn main() {
}

示例代码

module main

struct Widget {
mut:
	x int
	y int
}

pub fn (mut w Widget) move(x_step int, y_step int) {
	w.x += x_step
	w.y += y_step
}

struct Widget2 {
mut:
	z int
}

pub fn (mut w Widget2) move_z(z_step int) {
	w.z += z_step
}

struct Button {
	Widget //embed
	Widget2 //embed
	title string
}

fn main() {
	mut button := Button{
		title: 'Click me'
	}
	button.x = 3 // x comes from Widget
	button.z = 4 // z comes from Widget2
	println('x:$button.x,y:$button.y,z:$button.z')
	button.move(3, 4) // move comes from Widget
	println('x:$button.x,y:$button.y,z:$button.z')
	button.move_z(5) // move_z comes from Widget2
	println('x:$button.x,y:$button.y,z:$button.z')
}

StructInit 结构体初始化表达式

AST结构体

StructInit 结构体初始化

StructInitField 结构体初始化字段

StructInitEmbed 结构体初始化组合

示例代码

module main

struct User {
	name string
	age int
}

fn add(u User) {
	println(u)
}

fn main(){
	add(User{name:'jack',age:22}) //standard
	add({name:'tom',age:23}) //short
	add(name:'tt',age:33) // more short
}

结构体初始化例子

struct City {
	name       string
	population int
}

struct Country {
	name    string
	capital City
}

fn main() {
	ccc := Country{
		name: 'test'
		capital: City{
			name: 'city'
		}
	}
	c2 := Country{
		。。.ccc  //update_expr
		capital: City{
			name: 'city2'
			population: 200
		}
	}
	println(c2)
}

Interface 接口

InterfaceDecl 接口声明语句

AST结构体

InterfaceDecl 接口声明语句

示例代码

module main

interface Speaker { //comment 1
	speak() string
	silent()
}

Type 类型

AliasType 类型别名声明语句

AST结构体

AliasTypeDecl 类型别名声明语句

示例代码

module main

struct Human {
	name string
}
type Myint =  int /*comment 1*/ //comment 2
type Person = Human

FunctionType 函数类型声明语句

AST结构体

FnTypeDecl  函数类型声明语句

示例代码

module main

type Mid_fn = fn (int, string) int /*comment 1*/ //comment 2

Sumtype 联合类型

AST结构体

SumTypeDecl 联合类型声明语句

示例代码

module main

struct User {
	name string
	age  int
}

type MySumtype = User | int | string //comment 1

TypeNode 类型表达式

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

AST结构体

TypeNode 类型表达式

示例代码

module main

struct User {
	name string
	age  int
}

pub fn (m &User) str() string {
	return 'name:$m.name,age:$m.age'
}

type MySum = User | int | string

pub fn (ms MySum) str() string {
	if ms is int { //类型表达式
		
	}
	match ms { 
		int { //类型表达式
			return ms.str()
		}
		string { //类型表达式
			return ms 
		}
		User { //类型表达式
			return ms.str()
		}
	}
}

FlowControl 流程控制

Block 代码块语句

AST结构体

Block 代码块语句

示例代码

fn main() {
	my_fn()
}

fn my_fn() {
	// block
	{
		println('in block')
	}
	// unsafe block
	unsafe {
	}
}

if 条件语句

AST结构体

IfExpr if表达式
IfBranch if条件分支
IfGuardExpr if守护条件表达式

示例代码

module main

//带错误的函数
fn my_fn(i int) !int {
	if i == 0 {
		return error('Not ok!') //抛出错误
	}
	return i //正常返回
}

fn main() {
	a := 10
	b := 20
	// if statement
	if a < b {
		println('$a < $b')
	} else if a > b {
		println('$a > $b')
	} else {
		println('$a == $b')
	}

	// if guard expr
	if c := my_fn(2) { // if守护条件，调用函数时，正常返回，执行if分支
		println('$c')
	} else {
		println('from else')
	}
	if c := my_fn(0) { // if守护条件，调用函数时，抛出错误，执行else分支
		println('$c')
	} else {
		println('from else')
	}

	// if守护条件，其实等价于
	cc := my_fn(22) or {
		println('from or')
		0
	}
	println(cc)

	// if expr
	num := 777
	s := if num % 2 == 0 { 'even' } else { 'odd' }
	x, y, z := if true { 1, 'awesome', 13 } else { 0, 'bad', 0 }
	// compile time if
	$if macos {
	} $else {
	}
	println('s:$s,x:$x,y:$y,z:$z')
}

match 分支匹配

AST结构体

MatchExpr 匹配表达式
MatchBranch 匹配分支

示例代码

fn main() {
	os := 'macos'
	// match statement
	match os {
		'windows' { println('windows') }
		'macos'， 'linux' { println('macos or linux') }
		else { println('unknow') }
	}
	// match expr
	price := match os {
		'windows' { 100 }
		'linux' { 120 }
		'macos' { 150 }
		else { 0 }
	}
	// multi assign 
	a, b, c := match false {
		true { 1, 2, 3 }
		false { 4, 5, 6 }
		else { 7, 8, 9 }
	}
}

type MySum = bool | int | string

pub fn (ms MySum) str() string {
	// match sum type
	match ms {
		int { return ms.str() }
		string { return ms }
		else { return 'unknown' }
	}
}

for 循环语句

AST结构体

ForCStmt forC循环语句
ForInStmt forin循环语句
ForStmt for循环语句
BranchStmt 分支语句

示例代码

fn main() {
	for i := 0; i < 10; i++ {
		if i == 6 {
			continue
		}
		if i == 10 {
			break
		}
		println(i)
	}
}

示例代码

fn main() {
	// string
	str := 'abcdef'
	for s in str {
		println(s.str())
	}
	// array
	numbers := [1, 2, 3, 4, 5]
	for num in numbers {
		println('num:$num')
	}
	// range
	mut sum := 0
	for i in 1 。。 11 {
		sum += i
	}
	// map
	m := {
		'name': 'jack'
		'age':  '20'
		'desc': 'good man'
	}
	for key, value in m {
		println('key:$key,value:$value')
	}
}

示例代码

fn main() {
	mut sum := 0
	mut x := 0
	for x <= 100 {
		sum += x
		x++
	}
	println(sum)
	// label for
	mut i := 4
	goto L1
	L1: for { // label for
		i++
		for {
			if i < 7 {
				continue L1
			} else {
				break L1
			}
		}
	}
}

goto 跳转语句

AST结构体

GotoLabel 跳转标签
GotoStmt 跳转语句

示例代码

fn main() {
	mut i := 0
	a: // goto label
	i++
	if i < 3 {
		goto a
	}
	println(i)
}

Error handle 错误控制

AST结构体

OrExpr or表达式
None none表达式

示例代码

fn my_fn(i int) !int {
	if i == 0 {
		return error('Not ok!')
	}
	return i
}

fn main() {
	println('from main') // OrKind is absent
	v1 := my_fn(0) or { // OrKind is block
		println('from 0')
		panic(err)
	}
	v2 := my_fn(0) or { 
		println('from 0') 
		panic('error msg is $err')	
	}
	v3 := my_fn(2) or {
		println('from 2')
		return
	}
	v4 := my_fn(3) ! // OrKind is propagate
}

Concurrent 并发

ChanInit 通道初始化

AST结构体

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

示例代码

module main

const (
	num_iterations = 10000
)

fn do_send(ch chan int) {
	for i in 0 。。 num_iterations {
		ch <- i
	}
}

fn main() {
	ch := chan int{cap: 1000} // chan init
	go do_send(ch) // go statement
	mut sum := i64(0)
	for _ in 0 。。 num_iterations {
		sum += <-ch
		println(sum)
	}
}

SelectExpr 通道监听表达式

AST结构体

SelectExpr 通道监听表达式
SelectBranch 通道监听分支

示例代码

import time
import sync

fn main() {
	ch1 := chan int{}
	ch2 := chan int{}
	go send(ch1, ch2)
	mut x := 0
	mut y := 0
	for {
		select { // 
			x = <-ch1 { // read channel
				println('$x')
			}
			y = <-ch2 {
				println('$y')
			}
			> 2 * time.second { // timeout
				break
			}
		}
	}
}

fn send(ch1 chan int, ch2 chan int) {
	ch1 <- 1
	ch2 <- 2
	ch1 <- 3
	ch2 <- 4
	ch1 <- 5
	ch2 <- 6
}

LockExpr 并发锁表达式

AST结构体

LockExpr 并发锁表达式

示例代码

module main

import time

struct St {
mut:
	x f64
}

fn f(x int, y f64, shared s St,shared m map[string]string) {
	time.usleep(50000)
	lock s,m { 
		s.x = x * y
		println(s.x)
		unsafe {
			m['a']='aa'
		}
		println(m['a'])
	}
	return
}

fn main() {
	shared t := &St{}
	shared m := &map[string]string
	unsafe {
		m['a']='aa'
	}
	r := go f(3, 4.0, shared t,shared m) 
	r.wait()
	rlock t { 
		println(t.x)
	}
}

GoExpr 并发表达式

AST结构体

GoExpr 并发表达式

示例代码

module main

import time

fn do_something() { 
 println('start do_something.。。')
	time.sleep(2) 
	println('end do_something')
}
fn add(x int, y int) int { 
	println('add start.。。')
	time.sleep(4) //
	println('end add')
	return x + y
}

fn main() {
  g:= go do_something()
  g2 := go add(3, 2) 
  g.wait() 
	result := g2.wait()
	println(result)
}

Unsafe 不安全代码

AST结构体

UnsafeExpr 不安全代码表达式

示例代码

module main

fn main() {
	a := ['a'， 'b'， 'c']
	p := unsafe { &a[2] } // unsafe expr
	println(p)
}

ASM 汇编

AST结构体

AsmStmt 汇编语句

AsmTemplate
AsmClobbered
AsmIO
AsmArg
AsmAddressing
AsmAlias
AsmRegister

示例代码

fn main() {
	a := 100
	b := 20
	mut c := 0
	asm amd64 {
		mov eax, a
		add eax, b
		mov c, eax
		; =r (c) // output 
		; r (a) // input 
		  r (b)
	}
	println('a: $a') // 100
	println('b: $b') // 20
	println('c: $c') // 120
}

SQL SQL语句

AST结构体

SqlStmt sql语句
SqlExpr sql表达式

示例代码

module main

import sqlite

struct Module {
	id           int
	name         string
	nr_downloads int
}

struct User {
	id             int
	age            int
	name           string
	is_customer    bool
	skipped_string string [skip]
}

struct Foo {
	age int
}

fn main() {
	db := sqlite.connect(':memory:') or { panic(err) }
	db.exec('drop table if exists User')
	db.exec("create table User (id integer primary key, age int default 0, name text default ''， is_customer int default 0);")
	name := 'Peter'
	db.exec("insert into User (name, age) values ('Sam'， 29)")
	db.exec("insert into User (name, age) values ('Peter'， 31)")
	db.exec("insert into User (name, age, is_customer) values ('Kate'， 30, 1)")
	nr_all_users := sql db {
		select count from User
	}
	println('nr_all_users=$nr_all_users')
	//
	nr_users1 := sql db {
		select count from User where id == 1
	}
	println('nr_users1=$nr_users1')
	//
	nr_peters := sql db {
		select count from User where id == 2 && name == 'Peter'
	}
	//
	new_user := User{
		name: 'New user'
		age: 30
	}
	sql db {
		insert new_user into User
	}
	sql db {
		update User set age = 31 where name == 'Kate'
	}
	sql db {
		delete from User where age == 34
	}
}

TestAssert 测试断言

AssertStmt 测试断言语句

AST结构体

AssertStmt 测试断言语句

示例代码

fn test_abc() {
	x := 1
	assert x == 1
}

DumpExpr 转储函数表达式

AST结构体

DumpExpr 转储函数表达式

示例代码

fn factorial(n u32) u32 {
	if dump(n <= 1) {
		return dump(1)
	}
	return dump(n * factorial(n - 1))
}

fn main() {
	println(factorial(5))
}

Compile time 编译时

CompFor 编译时循环语句

AST结构体

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

示例代码

struct App {
	a string
	b string
mut:
	c int
	d f32
pub:
	e f32
	f u64
pub mut:
	g string
	h u8
}

fn (mut app App) m1() {
}

fn (mut app App) m2() {
}

fn (mut app App) m3() int {
	return 0
}

fn main() {
	$for field in App.fields {
		println('field: $field.name')
	}
	$for method in App.methods {
		println('method: $method.name')
	}
}

AtExpr at全局常量表达式

AST结构体

AtExpr at全局常量量表达式

示例代码

module main

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

C Integration C代码互操作

GlobalDecl 全局变量声明

AST结构体

GlobalDecl 全局变量声明
GlobalField 全局字段声明

示例代码

module main

// single
__global  g1 int

// group
__global (
	g2 u8 
	g3 u8 
)

fn main() {
	g1 = 1
	g2 = 2
	g3 = 3
	println(g1)
	println(g2)
	println(g3)
}

HashStmt C宏指令语句

AST结构体

HashStmt C宏指令语句

示例代码

module main
    
#include <stdio.h> 

#flag -lmysqlclient
#flag linux -I/usr/include/mysql
#include <mysql.h>

fn main() {

}

Likely likely表达式

AST结构体

Likely

示例代码

module main

fn main() {
	x := 1
	if _likely_(x == 1) {
		println('a')
	} else {
		println('b')
	}
	if _unlikely_(x == 1) {
		println('a')
	} else {
		println('b')
	}
}

OffsetOf 结构体字段内存偏移量

AST结构体

OffsetOf 结构体字段内存偏移量

示例代码

module main

struct User {
	name [50]u8
	age int
	desc string
}

fn main() {
	offset_name:=__offsetof(User,name)
	offset_age:=__offsetof(User,age)
	offset_desc:=__offsetof(User,desc)
	println(offset_name)
	println(offset_age)
	println(offset_desc)
}

Comment 注释

AST结构体

Comment 注释

示例代码

module main
/*
multi line comment
multi line comment
*/
// signle line comment
fn main() {
	x := 1 // behind statement comment
}

Other 其他

Empty 空语句/表达式

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

AST结构体

EmptyStmt 空语句
EmptyExpr 空表达式

NodeError 错误节点

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

NodeError既是语句，也是表达式。

上一页clipboard 下一页V语言服务

最后更新于2年前

hashtagv ast子命令

hashtag语法树结构体总览

hashtagast.File语法树文件

hashtagModule 模块

hashtagConst 常量

hashtagEnum 枚举

hashtagVariable 变量

hashtagAssign 变量赋值语句

hashtagIdentifier 标识符

hashtagLiteral 字面量

hashtagAsCast as造型语句

hashtagSizeOf sizeof语句

hashtagTypeOf typeof语句

hashtagCastExpr 造型表达式

hashtagArray 数组

hashtagArrayInit 数组初始化语句

hashtagIndexExpr 索引表达式

hashtagRangeExpr 数组区间表达式

hashtagArrayDecompose 数组解构

hashtagMap 字典

hashtagMapInit 字典初始化

hashtagOperator 操作符

hashtagPrefixExpr 前缀表达式

hashtagInfixExpr 中缀表达式

hashtagPostfixExpr 后缀表达式

hashtagSelectorExpr 选择器表达式

hashtagParExpr 括号表达式

hashtagConcatExpr 连接表达式

hashtagFunction 函数

hashtagFnDecl 函数声明

hashtagAnonFn 匿名函数

hashtagDeferStmt 函数defer语句

hashtagStruct 结构体

hashtagStructDecl 结构体声明语句

hashtagStructInit 结构体初始化表达式

hashtagInterface 接口

hashtagInterfaceDecl 接口声明语句

hashtagType 类型

hashtagAliasType 类型别名声明语句

hashtagFunctionType 函数类型声明语句

hashtagSumtype 联合类型

hashtagTypeNode 类型表达式

hashtagFlowControl 流程控制

hashtagBlock 代码块语句

hashtagif 条件语句

hashtagmatch 分支匹配

hashtagfor 循环语句

hashtaggoto 跳转语句

hashtagError handle 错误控制

hashtagConcurrent 并发

hashtagChanInit 通道初始化

hashtagSelectExpr 通道监听表达式

hashtagLockExpr 并发锁表达式

hashtagGoExpr 并发表达式

hashtagUnsafe 不安全代码

hashtagASM 汇编

hashtagSQL SQL语句

hashtagTestAssert 测试断言

hashtagAssertStmt 测试断言语句

hashtagDumpExpr 转储函数表达式

hashtagCompile time 编译时

hashtagCompFor 编译时循环语句

hashtagAtExpr at全局常量表达式

hashtagC Integration C代码互操作

hashtagGlobalDecl 全局变量声明

hashtagHashStmt C宏指令语句

hashtagLikely likely表达式

hashtagOffsetOf 结构体字段内存偏移量

hashtagComment 注释

hashtagOther 其他

hashtagEmpty 空语句/表达式

hashtagNodeError 错误节点

v ast子命令

语法树结构体总览

ast.File语法树文件

Module 模块

Const 常量

Enum 枚举

Variable 变量

Assign 变量赋值语句

Identifier 标识符

Literal 字面量

AsCast as造型语句

SizeOf sizeof语句

TypeOf typeof语句

CastExpr 造型表达式

Array 数组

ArrayInit 数组初始化语句

IndexExpr 索引表达式

RangeExpr 数组区间表达式

ArrayDecompose 数组解构

Map 字典

MapInit 字典初始化

Operator 操作符

PrefixExpr 前缀表达式

InfixExpr 中缀表达式

PostfixExpr 后缀表达式

SelectorExpr 选择器表达式

ParExpr 括号表达式

ConcatExpr 连接表达式

Function 函数

FnDecl 函数声明

AnonFn 匿名函数

DeferStmt 函数defer语句

Struct 结构体

StructDecl 结构体声明语句

StructInit 结构体初始化表达式

Interface 接口

InterfaceDecl 接口声明语句

Type 类型

AliasType 类型别名声明语句

FunctionType 函数类型声明语句

Sumtype 联合类型

TypeNode 类型表达式

FlowControl 流程控制

Block 代码块语句

if 条件语句

match 分支匹配

for 循环语句

goto 跳转语句

Error handle 错误控制

Concurrent 并发

ChanInit 通道初始化

SelectExpr 通道监听表达式

LockExpr 并发锁表达式

GoExpr 并发表达式

Unsafe 不安全代码

ASM 汇编

SQL SQL语句

TestAssert 测试断言

AssertStmt 测试断言语句

DumpExpr 转储函数表达式

Compile time 编译时

CompFor 编译时循环语句

AtExpr at全局常量表达式

C Integration C代码互操作

GlobalDecl 全局变量声明

HashStmt C宏指令语句

Likely likely表达式

OffsetOf 结构体字段内存偏移量

Comment 注释

Other 其他

Empty 空语句/表达式

NodeError 错误节点