编译生成C代码

编译器本质上就是一门语言生成另一门语言的过程

V目前的编译思路是:编译生成对应的C代码,然后调用C编译器来生成可执行文件

V语言的开发重点在编译器前端,C就是编译器后端

现在也生成了js代码,估计也会生成wasm代码

或者考虑基于LLVM,生成LLVM IR

或者直接生成机器码

生成C代码

使用-o参数就可以

把当前目录的main.v代码生成main.c代码:

  1. v -o main.c ./main.v

通过查看V代码生成的C代码,可以更容易理解V编译器是如何编译的

基本类型对应

v的基本类型通过C的类型别名typedef来实现

  1. //int类型没有类型别名,直接就是C的int类型
  2. typedef int64_t i64;
  3. typedef int16_t i16;
  4. typedef int8_t i8;
  6. typedef uint64_t u64;
  7. typedef uint32_t u32;
  8. typedef uint16_t u16;
  9. typedef uint8_t byte;
  11. typedef uint32_t rune;
  13. typedef float f32;
  14. typedef double f64;
  16. typedef unsigned char* &byte; //字节指针
  17. typedef int* intptr; //整型指针
  18. typedef void* voidptr; //通用指针
  19. typedef char* charptr; //C字符指针
  21. typedef struct array array;
  22. typedef struct map map;
  24. typedef array array_string;
  25. typedef array array_int;
  26. typedef array array_byte;
  27. typedef array array_f32;
  28. typedef array array_f64;
  29. typedef array array_u16;
  30. typedef array array_u32;
  31. typedef array array_u64;
  32. typedef map map_int;
  33. typedef map map_string;
  34. typedef byte array_fixed_byte_300 [300];
  35. typedef byte array_fixed_byte_400 [400];
  37. typedef uint8_t byte;
  38. ...
  39. #ifndef bool
  40.         typedef int bool; //布尔类型在C里面通过int类型来实现,1字节
  41.         typedef byte bool;
  42.         #define true 1 //true是整数常量1
  43.         #define false 0 //false是整数常量0
  44. #endif

代码对照表

常量

int类型常量,生成C的宏定义:

  1. //V代码
  2. const (
  3.     i=1 //int类型的常量
  4. )
  6. //C代码
  7. #define _const_i 1 //整数类型的常量通过C宏定义

其他类型常量,生成C的全局变量,常量的不可修改,由V编译器负责检查

这样就很好理解,V语言中的常量可以是任何类型,跟变量一样,甚至可以是函数调用的结果

  1. //V代码
  2. const (
  3.     a=i8(11)
  4.     b=i16(12)
  5.     c=i64(13)
  6.     d=byte(14)
  7.     e=u16(15)
  8.     f=u32(16)
  9.     g=u64(17)
  10.     h=f32(1.1)
  11.     i=f64(1.2)
  12.   bb=true
  13. )
  14. //C代码
  15. i8 _const_a; // inited later
  16. i16 _const_b; // inited later
  17. i64 _const_c; // inited later
  18. byte _const_d; // inited later
  19. u16 _const_e; // inited later
  20. u32 _const_f; // inited later
  21. u64 _const_g; // inited later
  22. f32 _const_h; // inited later
  23. f64 _const_i; // inited later
  24. bool _const_bb; // inited later
  26. void _vinit() { //然后在_vinit函数进行初始化
  27.   _const_a = ((i8)(11));
  28.     _const_b = ((i16)(12));
  29.     _const_c = ((i64)(13));
  30.     _const_d = ((byte)(14));
  31.     _const_e = ((u16)(15));
  32.     _const_f = ((u32)(16));
  33.     _const_g = ((u64)(17));
  34.     _const_h = ((f32)(1.1));
  35.     _const_i = ((f64)(1.2));
  36.     _const_bb = true;
  37. }

枚举

  1. //V代码
  2. pub enum Color {
  3.     blue =1            //如果没有指定初始值，默认从0开始，然后往下递增1
  4.     green
  5.     white
  6.     black
  7. }
  8. c := Color.blue
  10. //C代码
  11. typedef enum {
  12.     Color_blue = 1 ,
  13.     Color_green, // 1
  14.     Color_white, // 2
  15.     Color_black, // 3
  16. } Color;
  18. Color c = Color_blue;

模块

V的模块,在生成对应C代码后,只是对应元素名称的前缀,毕竟C语言中没有模块的概念

常量,结构体,接口,类型等一级元素生成C代码后的名称规则是:”模块名__名称”,用双下划线区隔

模块中的add()函数生成C代码后的名称为:mymodule__add()

结构体的方法等二级元素生成C代码后的名称规则是:”模块名 _ 类名 方法名”,用单下划线区隔

例模块中的Color结构体的str()方法生成C代码后的名称为:mymodule__Color_str()

函数

主模块中的主函数和函数,生成等价的C的函数

  1. //V代码
  2. module main 
  3. fn main() {
  4.     println('from main')
  5.     add(1,3)
  6. } 
  8. pub fn add(x,y int) int { //pub的模块访问控制由V编译器负责检查,C没有pub的对应
  9.     if x>0 {
  10.         return x+y
  11.     } else {
  12.         return x+y
  13.     }
  14. }
  16. //C代码
  17. int add(int x, int y); //函数声明
  19. int main(int ___argc, char** ___argv) {  //主函数生成主函数
  20.     _vinit(); //先执行初始化函数
  21.     println(tos3("from main"));
  22.     add(1, 3);
  23.     return 0;
  24. }
  26. int add(int x, int y) { 
  27.     if (x > 0) {
  28.         return x + y;
  29.     } else {
  30.         return x + y;
  31.     }
  32. }

函数defer语句

C没有defer语句,V编译的时候就是把函数中的defer语句去掉,然后按后进先出的顺序放在defer语句之后的所有return语句前以及函数末尾,有各自独立的代码块

  1. //V代码
  2. fn main(){
  3.     defer {defer_fn1()} 
  4.   defer {defer_fn2()}
  5.     println('main start')
  6.     if 1<2 {
  7.         return
  8.     }
  9.     if 1==1 {
  10.         return
  11.     }
  13.     println('main end')
  14. }
  16. fn defer_fn1(){
  17.     println('from defer_fn1')
  18. }
  20. fn defer_fn2(){
  21.     println('from defer_fn2')
  22. }
  23. //C代码
  24. int main(int ___argc, char** ___argv) { 
  25.     _vinit();
  26.     println(tos3("main start"));
  27.     if (1 < 2) {
  28.         // defer
  29.             defer_fn1();//defer语句之后的所有return语句之前
  30.         // defer
  31.             defer_fn2();//defer语句之后的所有return语句之前
  32.         return 0;
  33.     }
  34.     if (1 == 1) {
  35.         // defer
  36.             defer_fn1();//defer语句之后的所有return语句之前
  37.         // defer
  38.             defer_fn2();//defer语句之后的所有return语句之前
  39.         return 0;
  40.     }
  41.     println(tos3("main end"));
  42.   // defer
  43.     defer_fn1();//函数末尾
  44.     // defer
  45.     defer_fn2();//函数末尾
  46.     return 0;
  47. }
  49. void defer_fn1() { 
  50.     println(tos3("from defer_fn1"));
  51. }
  53. void defer_fn2() { 
  54.     println(tos3("from defer_fn2"));
  55. }

函数不确定个数参数

不确定参数就是根据返回值的类型和调用的最大参数数量,编译时动态生成一个结构体

然后把最后一个参数变为这个结构体的指针类型

不确定参数结构体,会重用,如果有别的函数也是返回了相同类型的不确定参数,会直接使用,同时修改args数组的长度为调用过参数的最大值

  1. //V代码
  2. fn my_fn(i int,s string, others ...string) {
  3.     println(i)
  4.     println(s)
  5.     println(others[0])
  6.     println(others[1])
  7.     println(others[2])
  8. }
  10. fn main() {
  11.     my_fn(1,'abc','de','fg','hi')
  12. }
  13. //C代码
  14. struct varg_string { //自动生成不确定参数结构体
  15.   int len;
  16.   string args[4];
  17. };
  19.  void main__my_fn(int i, string s, varg_string *others) {
  20.    printf("%d\n", i);
  21.    println(s);
  22.    println(others->args[0]);
  23.    println(others->args[1]);
  24.    println(others->args[2]);
  25.  }
  27.  void main__main() {
  28.    main__my_fn(
  29.        1, tos3("abc"),
  30.        &(varg_string){.len = 3, .args = {tos3("de"), tos3("fg"),                 tos3("hi")}});
  31.  }

函数多返回值

C的函数返回值只有1个,V的函数多返回值,就是把多返回值的组合,编译时动态生成一个结构体,然后返回结构体

  1. //V代码
  2. fn foo() (int, int) { //多返回值
  3.     return 2, 3
  4. }
  6. fn some_multiret_fn(a int, b int) (int, int) {
  7.     return a+1, b+1 //可以返回表达式
  8. }
  9. fn main() {
  10.     a, b := foo()
  11.     println(a) // 2
  12.     println(b) // 3
  13. }
  14. //C代码
  15. typedef struct _V_MulRet_int_V_int _V_MulRet_int_V_int;
  16. struct _V_MulRet_int_V_int { //生成的返回值组合的结构体,还可以给其他函数共用
  17.     int var_0;
  18.     int var_1;
  19. };
  21.  _V_MulRet_int_V_int main__foo() {
  22.    return (_V_MulRet_int_V_int){.var_0 = 2, .var_1 = 3};
  23.  }
  24.  _V_MulRet_int_V_int main__some_multiret_fn(int a, int b) {
  25.    return (_V_MulRet_int_V_int){.var_0 = a + 1, .var_1 = b + 1};
  26.  }
  27.  void main__main() {
  28.    _V_MulRet_int_V_int _V_mret_49_a_b = main__foo();
  29.    int a = _V_mret_49_a_b.var_0;
  30.    int b = _V_mret_49_a_b.var_1;
  31.    /*opt*/ printf("%d\n", a);
  32.    /*opt*/ printf("%d\n", b);
  33.  }

数组

V的数组是用struct来实现的,生成C代码也是struct

  1. //V代码
  2. fn main() {
  3.     a:=[1,3,5]
  4.     b:=['a','b','c']
  5.     println(a)
  6.     println(b)
  7. }
  8. //C代码
  9. //第一部分: 从内置的vlib/built/array.v生成
  10. struct array {
  11.     void* data;
  12.     int len;
  13.     int cap;
  14.     int element_size;
  15. };
  16. //第二部分:从内置的vlib/built/array.v生成
  17. typedef struct array array;
  18. typedef array array_string;
  19. typedef array array_int;
  20. typedef array array_byte;
  21. typedef array array_f32;
  22. typedef array array_f64;
  23. typedef array array_u16;
  24. typedef array array_u32;
  25. typedef array array_u64;
  26. //第三部分:数组使用的代码,字面量方式创建
  27. array_int a=new_array_from_c_array(3, 3, sizeof(int), EMPTY_ARRAY_OF_ELEMS( int, 3 ) {  1 ,  3 ,  5  }) ;
  28. array_string b=new_array_from_c_array(3, 3, sizeof(string), EMPTY_ARRAY_OF_ELEMS( string, 3 ) {  tos3("a") ,  tos3("b") ,  tos3("c")  }) ;
  29.  println (array_int_str( a ) ) ;
  30.  println (array_string_str( b ) ) ;
  31.  }

字符串

V的字符串是用struct来实现的,生成C代码也是struct

  1. //V代码
  2. //vlib/builtin/string.v
  3. pub struct string {
  4.     // var:
  5.     // hash_cache int
  6. pub:
  7.     str &byte // points to a C style 0 terminated string of bytes.
  8.     len int // the length of the .str field, excluding the ending 0 byte. It is always equal to strlen(.str).
  9. }
  10. //string的各种内置方法:
  11. ...
  12. //使用代码:
  13. fn main(){
  14.     mystr:='abc'
  15.     mystr2:="def"
  16.     println(mystr)
  17.     println(mystr2)
  18. }
  20. //C代码
  21. //第一部分:vlib/builtin/string.v生成:
  22. typedef struct string string;
  23. struct string {
  24.     byte* str;
  25.     int len;
  26. };
  27. //string的各种内置方法生成:
  28. string string_left (string s, int n);
  29. string string_right (string s, int n);
  30. string string_substr2 (string s, int start, int _end, bool end_max);
  31. string string_substr (string s, int start, int end);
  33. //第二部分,使用代码:
  34. void main__main () {
  35. string mystr= tos3("abc") ;
  36. string mystr2= tos3("def") ;
  37.  println ( mystr ) ;
  38.  println ( mystr2 ) ;
  39.  }

字典

V的字典是用struct来实现的,生成C代码也是struct

  1. //V代码
  2. //第一部分:定义map
  3. pub struct map {
  4.     element_size int
  5.     root         &mapnode
  6. pub:
  7.     size         int
  8. }
  10. struct mapnode {
  11.     left     &mapnode
  12.     right    &mapnode
  13.     is_empty bool // set by delete()
  14.     key      string
  15.     val      voidptr
  16. }
  17. //其他map内置方法
  18. ...
  19. //第二部分:使用map
  20. fn main() {
  21.     mut m := map[string]int
  22.     m['one'] = 1
  23.     m['two'] = 2
  24.     println(m['one']) 
  25.     println(m['bad_key'])
  26. }
  28. //C代码
  29. //第一部分:定义map
  30. typedef struct map map;
  31. typedef struct mapnode mapnode;
  33. typedef map map_int;
  34. typedef map map_string;
  36. struct map {
  37.     int element_size;
  38.     mapnode* root;
  39.     int size;
  40. };
  41. struct mapnode {
  42.     mapnode* left;
  43.     mapnode* right;
  44.     bool is_empty;
  45.     string key;
  46.     void* val;
  47. };
  49. //map的各种内置方法
  50. ...
  51. //第二部分:使用map:
  52. void main__main () {
  53.     map_int m= new_map(1, sizeof(int)) ;
  54.     map_set(& m , tos3("one") , & (int []) {  1 }) ;
  55.     map_set(& m , tos3("two") , & (int []) {  2 }) ; 
  56.      int tmp1 = 0; bool tmp2 = map_get(m , tos3("one"), & tmp1); 
  58.      printf ("%d\n",  tmp1 ) ; 
  59.      int tmp3 = 0; bool tmp4 = map_get(m , tos3("bad_key"), & tmp3); 
  61.      printf ("%d\n",  tmp3 ) ;
  62.  }

结构体

生成对应的C结构体

  1. //V代码
  2. pub struct Point {
  3.     x int
  4.     y int
  5. }
  7. pub fn (p Point) str() string {
  8.     return 'x is ${p.x},y is:${p.y}'
  9. }
  11. fn main() {
  12.     p := Point{
  13.         x: 1
  14.         y: 3
  15.     }
  16.     println(p)
  17. }
  19. //C代码
  20. struct Point {
  21.     int x;
  22.     int y;
  23. };
  24. string Point_str (Point p); //函数声明
  26. string Point_str (Point p) { //函数定义,默认第一个参数是自己
  27.     return  _STR("x is %d,y is:%d", p .x, p .y) ;
  28. }
  29. void main__main () {
  30.     Point p= (Point) { .x =  1 , .y =  3 } ;
  31.      println (Point_str( p ) ) ;
  32. }

结构体方法

生成对应的C函数,默认第一个参数是对应的结构体类型的指针

生成的C函数的命名规则是:”结构体名_方法名”

  1. //V代码
  2. pub fn (mut a array) insert(i int, val voidptr) {
  3.     if i < 0 || i > a.len {
  4.         panic('array.insert: index out of range (i == $i, a.len == $a.len)')
  5.     }
  6.     a.ensure_cap(a.len + 1)
  7.     size := a.element_size
  8.     C.memmove(a.data + (i + 1) * size, a.data + i * size, (a.len - i) * size)
  9.     C.memcpy(a.data + i * size, val, size)
  10.     a.len++
  11. }
  12. //C代码
  13. void array_insert(array *a, int i, void *val) { //默认第一个参数是对应类型指针
  14.   if (i < 0 || i > a->len) {
  15.     v_panic(_STR("array.insert: index out of range (i == %d, a.len == %d)", i,
  16.                  a->len));
  17.   };
  18.   array_ensure_cap(a, a->len + 1);
  19.   int size = a->element_size;
  20.   memmove((byte *)a->data + (i + 1) * size, (byte *)a->data + i * size,
  21.           (a->len - i) * size);
  22.   memcpy((byte *)a->data + i * size, val, size);
  23.   a->len++;
  24. }

结构体访问控制

访问控制在C代码中没有体现,全部在V编译器中控制

  1. //V代码
  2. struct Foo {
  3.     a int     //私有,不可变(默认).在模块内部可访问,不可修改;模块外不可访问,不可修改
  4. mut: 
  5.     b int     // 私有,可变.在模块内部可访问,可修改,模块外部不可访问,不可修改
  6.     c int     // (相同访问控制的字段可以放在一起)   
  7. pub: 
  8.     d int   // 公共,不可变,只读.在模块内部和外部都可以访问,但是不可修改
  9. pub mut: 
  10.     e int  //公共,模块内部可访问,可修改;模块外部可访问,但是不可修改
  11. __global:
  12.     f int // 全局字段,模块内部和外部都可访问,可修改,这样等于破坏了封装性,不推荐使用
  13. }    
  15. fn main() {
  16.     f:=Foo{}
  17.     println(f)
  18. }
  20. //C代码
  21. typedef struct Foo Foo;
  22. struct Foo {
  23.     int a;
  24.     int b;
  25.     int c;
  26.     int d;
  27.     int e;
  28.     int f;
  29. };
  30. string Foo_str();
  31. void main__main() {
  32.    Foo f = (Foo){.a = 0, .b = 0, .c = 0, .d = 0, .e = 0, .f = 0};
  33.    println(Foo_str(f));
  34.  }
  35. string Foo_str(Foo a) {
  36.    return _STR("{\n    a: %d\n    b: %d\n    c: %d\n    d: %d\n    e: %d\n    f: %d\n}", a.a,a.b, a.c, a.d, a.e, a.f);
  37.  }

流程控制语句

if语句,生成C if语句

  1. //V代码
  2. fn main() {
  3.     a := 10
  4.     b := 20
  5.     if a < b {
  6.         println('$a < $b')
  7.     }
  8.     else if a > b {
  9.         println('$a > $b')
  10.     }
  11.     else {
  12.         println('$a == $b')
  13.     }
  14. }
  16. //C代码
  17. void main__main () {
  18.     int a= 10 ;
  19.     int b= 20 ;
  20.      if ( a < b ) {
  21.         printf( "%d < %d\n", a, b ) ;
  22.      }
  23.       else  if ( a > b ) {
  24.         printf( "%d > %d\n", a, b ) ;
  25.      }
  26.       else { 
  27.         printf( "%d == %d\n", a, b ) ;
  28. }

if表达式语句,生成C的三元运算符 ? :

  1. //V代码
  2. fn main() {
  3.     num := 777
  4.     s := if num % 2 == 0 {
  5.     'even'
  6.     }
  7.     else {
  8.     'odd'
  9.     }
  10.     println(s) // "odd"
  11. }
  12. //C代码
  13. void main__main() {
  14.   int num = 777;
  15.   string s = ((num % 2 == 0) ? (tos3("even")) : (tos3("odd")));
  16.   println(s);
  17. }

match语句

  1. //V代码
  2. fn main() {
  3. os:='macos'
  4. match os {
  5.     'windows' {
  6.         println('windows')
  7.     }
  8.     'linux' {
  9.         println('linux')
  10.     }
  11.     'macos' {
  12.         println('macos')
  13.     }
  14.     else  {
  15.         println('unknow')
  16.     }
  17. }
  18. }
  19. //C代码
  20. void main__main() {
  21.   string os = tos3("macos");
  22.   string tmp1 = os;
  24.   if (string_eq(tmp1, tos3("windows"))) {
  25.     println(tos3("windows"));
  26.   } else if (string_eq(tmp1, tos3("linux"))) {
  27.     println(tos3("linux"));
  28.   } else if (string_eq(tmp1, tos3("macos"))) {
  29.     println(tos3("macos"));
  30.   } else // default:
  31.   {
  32.     println(tos3("unknow"));
  33.   };
  34. }

match表达式语句

  1. //V代码
  2. fn main() {
  3. os:='macos'
  4. price:=match os {
  5.     'windows' {
  6.         100
  7.     }
  8.     'linux' {
  9.         120
  10.     }
  11.     'macos' {
  12.         150
  13.     }
  14.     else {
  15.         0
  16.     }
  17. }
  18. println(price) //输出150
  19. }
  21. //C代码 
  22. //生成嵌套的三元表达式
  23. void main__main() {
  24.   string os = tos3("macos");
  25.   string tmp1 = os;
  27.   int price = ((string_eq(tmp1, tos3("windows")))
  28.                    ? (100)
  29.                    : ((string_eq(tmp1, tos3("linux")))
  30.                           ? (120)
  31.                           : ((string_eq(tmp1, tos3("macos"))) ? (150) : (0))));
  32.   /*opt*/ printf("%d\n", price);
  33. }

for循环

传统的：for i=0;i<100;i++ {}

  1. //V代码
  2. fn main() {
  3.   for i := 0; i < 10; i++ { 
  4.        //跳过6
  5.        if i == 6 {
  6.            continue
  7.        }
  8.        println(i)
  9.    }
  10. }
  12. //C代码
  13. void main__main() {
  14.   for (int i = 0; i < 10; i++) {
  16.     if (i == 6) {
  17.       continue;
  18.     };
  19.     /*opt*/ printf("%d\n", i);
  20.   };
  21. }

替代while：for i<100 {}

  1. //V代码
  2. fn main() {
  3.    mut sum := 0
  4.    mut i := 0
  5.    for i <= 100 {
  6.        sum += i
  7.        i++
  8.    }
  9.    println(sum) // 输出"5050"
  10. }
  11. //C代码
  12. void main__main () {
  13.     int sum= 0 ;
  14.     int i= 0 ;
  15.      while ( i <= 100 ) {
  17.      sum  +=  i ;
  18.      i ++ ;
  19.  }

无限循环：for {}

  1. //V代码
  2. fn main() {
  3.     mut num := 0
  4.     for {
  5.         num++
  6.         if num >= 10 {
  7.             break
  8.         }
  9.     }
  10.     println(num) // "10"
  11. }
  12. //C代码
  13.  void main__main() {
  14.    int num = 0;
  15.    while (1) {
  16.      num++;
  17.      if (num >= 10) {
  18.        break;
  19.      };
  20.    };
  21.    /*opt*/ printf("%d\n", num);
  22.  }

遍历：for i in xxx {}

  1. //V代码
  2. fn main() {
  3.     numbers := [1, 2, 3, 4, 5]
  4.     for i,num in numbers {
  5.         println('i:$i,num:$num')
  6.     }
  7. }
  8. //C代码
  9. void main__main() {
  10.    array_int numbers = new_array_from_c_array(
  11.        5, 5, sizeof(int), EMPTY_ARRAY_OF_ELEMS(int, 5){1, 2, 3, 4, 5});
  12.    array_int tmp1 = numbers;
  13.    for (int i = 0; i < tmp1.len; i++) {
  14.      int num = ((int *)tmp1.data)[i];
  16.      printf("i:%d,num:%d\n", i, num);
  17.    };
  18.  }

类型定义

类型定义type生成C的类型别名typedef

  1. //V代码
  2. pub struct Point {
  3.     x int
  4.     y int
  5. }
  6. type myint=int
  7. type myPoint=Point
  9. //C代码
  10. struct Point {
  11.     int x;
  12.     int y;
  13. };
  14. typedef  int myint;
  15. typedef  Point myPoint;

接口

  1. //V代码
  3. //C代码

泛型

  1. //V代码
  3. //C代码

错误处理

  1. //V代码
  3. //C代码

联合类型

  1. //V代码
  2. struct User {
  3.     name string
  4.     age int
  5. }
  6. pub fn (m &User) str() string {
  7.     return 'name:$m.name,age:$m.age'
  8. }
  9. type MySum= int|string|User //联合类型声明
  10.     i:=123
  11.     s:='abc'
  12.     u:=User{name:'tom',age:33}
  13.     mut res:=MySum{} //声明联合类型变量
  14.     res=i
  15.     res=s
  16.     res=u
  18. pub fn add(ms MySum) { 
  19. match ms { 
  20.     int { 
  21.             println('ms is int,value is $it.str()')    
  22.     }
  23.     string {
  24.             println('ms is string,value is $it')    
  25.     }
  26.     User {
  27.             println('ms is User,value is $it.str()')    
  28.     }
  29.     else {
  30.             println('unknown')
  31.     }
  32. }
  33. }
  35. //C代码
  36. #define SumType_int 1    // DEF2
  37. #define SumType_string 2 // DEF2
  38. #define SumType_User 3   // DEF2
  40. typedef struct {
  41.   void *obj; //存储变量指针
  42.   int typ; //联合类型中对应的类型常量,就是上面的宏定义
  43. } MySum;
  46. //声明联合类型变量
  47. MySum res = (MySum){EMPTY_STRUCT_INITIALIZATION};
  48. //变量赋值
  49. res = /*SUM TYPE CAST2*/ (MySum){.obj = memdup(&(int[]){i}, sizeof(int)),
  50.                                    .typ = SumType_int};
  51. res = /*SUM TYPE CAST2*/ (MySum){.obj = memdup(&(string[]){s}, sizeof(string)), .typ = SumType_string};
  52. res = /*SUM TYPE CAST2*/ (MySum){.obj = memdup(&(User[]{u},sizeof(User)),
  53.                                    .typ = SumType_User};
  54.   //match类型判断                                             
  55.   if (tmp3.typ == SumType_int) {
  56.     int *it = (int *)tmp3.obj;
  57.     printf("res is:%.*s\n", int_str(*it).len, int_str(*it).str);
  58.   } else if (tmp3.typ == SumType_string) {
  59.     string *it = (string *)tmp3.obj;
  60.     printf("res is:%p\n", it);
  61.   } else if (tmp3.typ == SumType_User) {
  62.     User *it = (User *)tmp3.obj;
  63.     printf("res is:%.*s\n", User_str(&/* ? */ *it).len,
  64.            User_str(&/* ? */ *it).str);
  65.   } else // default:
  66.   {
  67.     println(tos3("unknown"));
  68.   };

运算符重载

  1. //V代码
  3. //C代码

条件编译

生成等价的C宏定义

  1. //V代码
  2. fn main() {
  3.     $if windows {
  4.         println('windows')
  5.     }
  6.     $if linux {
  7.         println('linux')
  8.     }
  9.     $if macos {
  10.         println('mac')
  11.     }
  12. }
  13. //C代码
  14. VV_LOCAL_SYMBOL void main__main() {
  15.     #if defined(_WIN32)
  16.     {
  17.     }
  18.     #endif
  19.     #if defined(__linux__)
  20.     {
  21.     }
  22.     #endif
  23.     #if defined(__APPLE__)
  24.     {
  25.         println(tos_lit("mac"));
  26.     }
  27.     #endif
  28. }
  1. //V代码
  2. fn main() {
  3.     mut x := 0
  4.     $if x32 {
  5.         println('system is 32 bit')
  6.         x = 1
  7.     }
  8.     $if x64 {
  9.         println('system is 64 bit')
  10.         x = 2
  11.     }
  12. }
  14. //C代码
  15. void main__main() {
  16.    int x = 0;
  17.     #ifdef TARGET_IS_32BIT
  18.        println(tos3("system is 32 bit"));
  19.        x = 1;
  20.     #endif
  21.        ;
  22.     #ifdef TARGET_IS_64BIT
  23.        println(tos3("system is 64 bit"));
  24.        x = 2;
  25.     #endif
  26.        ;
  1. //V代码
  2. fn main() {
  3.     mut x := 0
  4.     $if little_endian {
  5.         println('system is little endian')
  6.         x = 1
  7.     }
  8.     $if big_endian {
  9.         println('system is big endian')
  10.         x = 2
  11.     }
  12. }
  14. //C代码
  15.  void main__main() {
  16.    int x = 0;
  17.     #ifdef TARGET_ORDER_IS_LITTLE
  18.    println(tos3("system is little endian"));
  19.    x = 1;
  20.     #endif
  21.    ;
  22.     #ifdef TARGET_ORDER_IS_BIG
  23.    println(tos3("system is big endian"));
  24.    x = 2;
  25.     #endif
  26.    ;

内联汇编代码

生成等价的C内联汇编的代码

  1. //V代码
  2. fn main() {
  3.     a := 10
  4.     b := 0
  5.     unsafe {    //unsafe代码块
  6.         asm {    //asm代码块,里面可以直接写汇编代码
  7.             "movl %1, %%eax;"
  8.             "movl %%eax, %0;"
  9.             :"=r"(b)
  10.             :"r"(a)
  11.             :"%eax"
  12.         }
  13.     }
  14.     println(a) //返回10
  15.     println(b) //返回10,直接通过汇编代码修改了b的值
  17.     e := 0
  18.     unsafe {
  19.         asm {
  20.             "movl $5, %0"
  21.             :"=a"(e)
  22.         }
  23.     }
  24.     println(e) //返回5,直接通过汇编代码修改了e的值
  25. }
  27. //C代码
  28.  void main__main() {
  29.    int a = 10;
  30.    int b = 0;
  31.    {
  32.      asm("movl %1, %%eax;"
  33.          "movl %%eax, %0;"
  34.          : "=r"(b)
  35.          : "r"(a)
  36.          : "%eax");
  37.      ;
  38.    };
  39.    /*opt*/ printf("%d\n", a);
  40.    /*opt*/ printf("%d\n", b);
  41.    int e = 0;
  42.    {
  43.      asm("movl $5, %0" : "=a"(e));
  44.      ;
  45.    };
  46.    /*opt*/ printf("%d\n", e);
  47.  }