文法设计，对于void的修改

 //这个文件主要是用来描述当前源语言的词法结构和语法结构
 //当前语言是c语言的一个子集，因此里面所有的描述大家都很熟悉
 //注意，当前语言并不支持预处理，因为c预处理比较复杂，而且楼主能力低下，因此做不来
 //如果有想做预处理的同志，可以自行修改代码。
 //本代码完全木有任何版权，因此各位读者在使用过程中由于程序bug而造成的挂科、失恋、车祸、离婚等不良后果
 //楼主不负任何法律责任，钦此。
 //
 //
 //第一版本修改，添加函数。函数这东西老牛逼了。
 //下面来描述词法中的字符集
 //
 //
 //变量名称符:大小写字母和下划线，注意这里并不支持数字，变量名字中有数字是很不科学的，个人认为，而下划线在
 //使得变量名称可读这方面有很重要的作用，因此这里会支持
 //算术及逻辑运算符： < > <= >= == + - * & | ! ^ && || /  ~ %
 //赋值运算符： =
 //取地址运算符：$
 //指针运算符: @
 //结构体分量运算符： .
 //结构体指针分量运算符： ->
 //数组运算符: [ ]
 //函数运算符: ( )
 //内存大小运算符: sizeof
 //行尾界定符： ；
 //字符串界定符: " "
 //字符界定符: ' '
 //换行符: \n
 //制表符: \t
 //单元界定符: ( )
 //空格符:
 //转义字符：\  说明，转义字符与其之后的那一个字符会被当作一个单元来处理，即直接输出其之后的字符
 //注意，转义字符只会在字符及字符串中进行使用，其他情况下会被解释为除法运算符
 //代码块界定符: { }
 //
 //下面来介绍一下关键字
 //sizeof ,大家对这个很熟悉了吧，不解释
 //for ,不解释
 //while 不解释
 //if 不解释
 //else 不解释
 //break 不解释
 //return 不解释
 //注意我这个语言取消了goto和switch,case，因为goto容易引起混乱，而switch的语法结构对我来说有点复杂，
 //而且这个分支结构总是能够转变为for语句加上break的模式，因此我当前就不添加了，有兴趣的人可以自己去修改
 //下面说的是类型关键字
 //int 不解释
 //float 不解释
 //long 不解释
 //double 不解释
 //char 不解释
 //struct 不解释
 //union 不解释
 //unsign 代表无符号的长整数
 //void 这里的void跟c里面的不同，void代表一个四字节的内容，没有格式，变量声明可以声明为void 以及他的指针形式
 //跟int的用法没有差别，唯一的差别就是函数的返回值类型为void时，代表没有返回值,这是void唯一需要注意的地方
 //注意这里我们取消了枚举类型，因为如果对这个类型进行处理的话，会让我很烦躁
 //typedef也被我取消了，这东西除了少写几个字外，没啥大用途把
 //现在我们开始对这个做词法单元分类
 //注意这里我们只支持十进制和十六进制，8进制直接被忽略,
 //而且对于整数常量，我们默认为64位，因此对于十进制，我们支持18位数字
 //而对于浮点数，由于默认常量为双精度，所以我们允许，小数点后有10位，,小数点之前最多36位
 //这里我只是照搬c语言里面的规定，事实上，需要这么多位并要求精确计算的还是用大数来算吧。
 //不要指望系统自带的算术精度
 //constant_char:'(a-b)|(A-B)|(0-9)|\n|\t|\0| ',事实上还有其他有关转义字符的组合，但是那些组合并没有特殊意义
 //所以在这里我们就不提那些组合了
 //这里我们将不支持科学计数法的表示

 //
 //
 //现在我们讨论声明和定义部分

 //unsigned : 0x((0-9)|(a-f)|(A-F))+|(0-9)+
 //sign_constant_int: -(0-9)+
 //
 //double_constant:(-)?((0-9)+.(0-9)+)
 //new_name: ((a-z)|(A-Z)|(-))+  ,即一个或多个合法的名称字符
 //
 //
 //
 //list_name: new_name|list_name[unsign_constant_int] 对应数组的情形
 //data_type_basic_body: int |char|float|double|long|unsigned|void 基础类型体
 //data_type_basic_pointer: data_type_basic *|data_type_basic_pointer * 基础类型的指针
 //data_type_basic:data_type_basic_body|data_type_basic_pointer 基础类型（包括指针）
 //data_type_struct_body: struct struct_direct_name  //结构体类型
 //data_type_union_body: union union_direct_name        联合类型
 //data_type_struct_pointer: data_type_struct_body *|data_type_struct_pointer *    结构体指针
 //data_type_struct:data_type_struct_body|data_type_struct_pointer                结构体类型声明头部
 //data_type_union_pointer:data_type_union_body * |data_type_union_pointer *        联合类型指针
 //data_type_union:data_type_union_body|data_type_union_pointer                    联合类型声明头部
 //data_type_head:data_type_basic|data_type_struct|data_type_union                所有的类型头部
 //data_var_decl: data_type_head list_name;                                所有的显示变量声明
 //data_type_struct_anomynous: struct { in_block_def_list } new_name ;            内部结构体声明
 //data_type_union_anomynous:  union { in_block_def_list } new_name;                内部联合声明
 //in_block_def: data_var_decl|data_type_struct_anomynous|data_type_union_anomynous  内部声明类型
 //in_block_def_list: in_block_def| in_block_def_list in_block_def                内部声明列表
 //data_type_struct_decl: struct new_name { in_block_def_list } ;                外部结构体声明
 //data_type_union_decl: union new_name { in_block_def_list };                    外部联合声明
 //data_type_decl_simple: data_type_struct_decl|data_type_union_decl
 //外部声明，包括具名联合和结构
 //data_type_com_list:data_type_simple|data_type_com_list data_type_simple        所有的类型声明列表

 //现在开始函数声明
 //因为我们默认函数的返回值是有长度限制的，所以我们把返回类型限制为所有的基础类型和所有的指针类型
 //return_type_basic: data_type_basic_body | struct struct_direct_name | union union_direct_name
 //return_type_pointer: return_type_basic * | return_type_pointer *
 //return_type_concrete: return_type_basic_body| return_type_pointer
 //return_type: void | return_type_concrete
 //现在开始参数列表的声明，我们把参数的类型限定为基础类型和指针类型，即与返回值一样的类型
 //返回值类型只包括所有基础类型及其指针及符合类型的指针
 //decl_arg_list_concrete: return_type_concrete new_name | decl_arg_list_concrete ; return_type_concrete new_name
 //decl_arg_list: void | decl_arg_list_concrete
 //注意我们这里采用分号作为分隔符
 //function_decl: return_type new_name ( decl_arg_list ) { code_block }//这里有两个向后引用
 //注意这里我们允许函数内部再声明函数的，这样就增加了构造符号表的难度。。。
 //function_decl_list: function_decl | function_decl_list function_decl                        所有的函数声明
 //当前语言的特点是所有的类型声明都需要在变量声明之前出现，但是结构体内部及联合内部声明不受此限制

 //现在开始变量声明部分
 //data_var_decl_list: data_instance_decl| data_var_decl_list data_var_decl
 //至此变量声明结束
 //现在开始变量定义的处理
 //现在开始描述运算符的优先级
 //0级: [ ] ( ) -> . 结合性 从左到右
 //1级:! ~  & * - (cast)  sizeof 这些都是单目运算符，注意cast的意思是强制类型转换
 //2级: * / % 这些运算符都是从左到右
 //3级: + - 这些也是从左到右
 //4级: >> << 按道理木有结合性
 //5级：> < >= <= 从左到右
 //6级: == != 从左到右
 //7级: & 从左到右
 //8级：^ 从左到右
 //9级：| 从左到右
 //10级： && 从左到右
 //11级： ||从左到右
 //总共12级优先级，这里相对于c语言少了三个优先级，分别是条件运算符，逗号运算符和赋值运算符，
 //逗号和条件都是坑爹的存在，我是不想去实现他了，而对于赋值运算符，我把这个单独归类，放在文法分析里面去
 //对于自增以及自减运算符，这东西除了作为考试题恶心人用没啥大用途吧，
 //i=i+1在优化的时候总是会变成等价的自增指令，咱们何必呢

 //首先考虑算术优先级
 //我们用优先级编号来命名临时的产生式
 //而且我们用左递归来完成从左到右的优先级
 //
 //expression_0:char_type|constant|name|(expression_11)|expression_0[expression_11]|expression_0.name|expression_0->name |fun_name(fun_arg)
 //expression_1:expression_0|!expression_0|~expression_0|-expression_0
 //                |&expression_0|*expression_0|(data_type_com)expression_0|sizeof （expression_0 ）
 //expression_2:expression_1|expression_2 * expression_1|expression_2 / expression_1| expression_2 % expression_1
 //expression_3:expression_2|expression_3 + expression_2 | expression_3 - expression_2|
 //expression_4:expression_3|expression_4 >> expression_3| expression_4 << expression_3
 //expression_5:expression_4|expression_5 > expression_4| expression_5 < expression_4| expression_5 >= expression_4
 //                |expression_5 <= expression_4
 //expression_6:expression_5|expression_6 == expression_5|expression_6 != expression_5
 //expression_7:expression_6|expression_7 & expression_6
 //expression_8: expression_7|expression_8 ^ expression_7
 //expression_9: expression_8| expression_9 \| expression_8
 //expression_10:expression_9|expression_10 && expression_9
 //expression_11:expression_10|expression_11 \|\| expression_10
 //expression: expression_11
 //id_0: name |(id)| id_0[constant] | id_0.name | id_0->name |id_0[name]
 //id_1: id_0 | *id_0
 //id : id_1
 //function_arg_type: constant| id
 //function_use_arg: function_arg_type ;| function_use_arg function_arg_type ;
 //fun_arg: (void)//这里代表空参数 | function_use_arg

 //statement_0: id = expression ;|fun_name(fun_arg);
 // simple_statements: statement_0| simple_statements statement_0
 //for_statement: for ( statement_0 ; expression ; statement_0 ) { statements }
 //while_statement: while(expression) { statements }
 //branch_statement: if (expression) { statements } else { statements }
 //                    | if(expression) { statements }
 //break_statement: break ;
 //statement: simple_statements | break_statement | branch_statement | while_statement |for_statement
 //statements: statement | statements statement
 //code_block:data_type_com_list function_decl_list data_var_decl_list statements
 //
 //
 //总的来说，一个程序分为三个部分，第一部分数据类型声明，数据类型声明的末尾是函数声明，
 //所有的声明按照拓扑顺序来声明
 //数据类型声明之后是变量声明，注意这里的变量声明还不能赋值，所以当前只是分配空间
 //在变量声明之后才是程序的正文，即所有的赋值语句。
 //注意，这里我把算术赋值与函数赋值分开来了。即不允许在算术表达式中出现函数求值。
 //还有一个非常需要注意的一点就是，在调用函数的时候，我们不允许算术表达式的存在
 //注意在赋值的时候，左边的分量只利用了前两级的运算符，因此任何带取地址和读内存运算符的都需要使用括号括起来
 //因为这几个与其他运算符合用的时候总是很容易引起误会，所以我这里就强制规定了
 //而对于右边，我就没做这个规定，但是推荐是所有的都采取这样。
 //在调用函数的时候，由于参数里面不允许有算术运算符及其他类似的运算符，因此所有的参数都需要提前计算好它的值
 //然后再传，这样就没有求值顺序的问题了，我真是太机智了。
 //
 //
 //接下来需要处理的是符号表的管理及各个数据类型、函数、变量的作用域的问题，这个才是大麻烦
 //
 //
 //