文法设计，有一些大的修改

上次忘了写函数的实现，只写了函数的声明。此外修改了基本语句的文法，把判断语句删除了。嗯，就是这样。

//这个文件主要是用来描述当前源语言的词法结构和语法结构
//当前语言是c语言的一个子集，因此里面所有的描述大家都很熟悉
//注意，当前语言并不支持预处理，因为c预处理比较复杂，而且楼主能力低下，因此做不来
//如果有想做预处理的同志，可以自行修改代码。
//本代码完全木有任何版权，因此各位读者在使用过程中由于程序bug而造成的挂科、失恋、车祸、离婚等不良后果
//楼主不负任何法律责任，钦此。
//
//
//第一版本修改，添加函数。函数这东西老牛逼了。
//下面来描述词法中的字符集
//
//
//变量名称符:大小写字母和下划线，注意这里并不支持数字，变量名字中有数字是很不科学的，个人认为，而下划线在
//使得变量名称可读这方面有很重要的作用，因此这里会支持
//算术及逻辑运算符： < > <= >= == + - * & | ! ^ && || /  ~ %
//赋值运算符： =
//取地址运算符：$
//指针运算符: @
//结构体分量运算符： .
//结构体指针分量运算符： ->
//数组运算符: [ ]
//函数运算符: ( )
//内存大小运算符: sizeof
//行尾界定符： ；
//字符串界定符: " "
//字符界定符: ' '
//换行符: 

//制表符: 	
//单元界定符: ( )
//空格符: 
//转义字符：  说明，转义字符与其之后的那一个字符会被当作一个单元来处理，即直接输出其之后的字符
//注意，转义字符只会在字符及字符串中进行使用，其他情况下会被解释为除法运算符
//代码块界定符: { }
//
//下面来介绍一下关键字
//sizeof ,大家对这个很熟悉了吧，不解释
//for ,不解释
//while 不解释
//if 不解释
//else 不解释
//break 不解释
//注意我这个语言取消了goto和switch,case，因为goto容易引起混乱，而switch的语法结构对我来说有点复杂，
//而且这个分支结构总是能够转变为for语句加上break的模式，因此我当前就不添加了，有兴趣的人可以自己去修改
//下面说的是类型关键字
//int 不解释
//float 不解释
//long 不解释
//double 不解释
//char 不解释
//struct 不解释
//union 不解释
//void 不解释
//注意这里我们取消了枚举类型，因为如果对这个类型进行处理的话，会让我很烦躁
//typedef也被我取消了，这东西除了少写几个字外，没啥大用途把
//现在我们开始对这个做词法单元分类
//注意这里我们只支持十进制和十六进制，8进制直接被忽略,
//而且对于整数常量，我们默认为64位，因此对于十进制，我们支持18位数字
//而对于浮点数，由于默认常量为双精度，所以我们允许，小数点后有10位，,小数点之前最多36位
//这里我只是照搬c语言里面的规定，事实上，需要这么多位并要求精确计算的还是用大数来算吧。
//不要指望系统自带的算术精度
//constant_char:'(a-b)|(A-B)|(0-9)|
|	|| ',事实上还有其他有关转义字符的组合，但是那些组合并没有特殊意义
//所以在这里我们就不提那些组合了
//这里我们将不支持科学计数法的表示

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


//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  基础类型体
//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_definition:data_type_basic|data_type_struct|data_type_union            所有的类型头部
//data_type_def_phrase: data_type_definition 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_type_def_phrase|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_definition_phrase|data_type_struct_decl|data_type_union_decl 
//外部声明，包括具名联合和结构
//data_type_com_list:data_type_simple|data_type_com_list data_type_simple 声明列表
//data_type_decl_phrases:data_type_com_list    | function_decl                        声明头
//现在开始函数声明
//因为我们默认函数的返回值是有长度限制的，所以我们把返回类型限制为所有的基础类型和所有的指针类型
//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 ) { data_instance_decl statements }//这里有两个向后引用
//注意这里我们允许函数内部再声明函数的，这样就增加了构造符号表的难度。。。
//当前语言的特点是所有的类型声明都需要在变量声明之前出现，但是结构体内部及联合内部声明不受此限制
//现在开始变量声明部分
//data_instance_decl_list : data_type_def_phrase| data_instance_decl_list data_type_def_phrase
//data_instance_decl: data_instance_decl_list
//至此变量声明结束
//现在开始变量定义的处理
//现在开始描述运算符的优先级
//0级: [ ] ( ) -> . 结合性 从左到右
//1级:! ~  & * - (cast)  sizeof 这些都是单目运算符，注意cast的意思是强制类型转换
//2级: * / % 这些运算符都是从左到右 
//3级: + - 这些也是从左到右 
//4级: >> << 按道理木有结合性
//5级：> < >= <= 从左到右
//6级: == != 从左到右
//7级: & 从左到右
//8级：^ 从左到右
//9级：| 从左到右
//10级： && 从左到右
//11级： ||从左到右
//总共12级优先级，这里相对于c语言少了三个优先级，分别是条件运算符，逗号运算符和赋值运算符，
//逗号和条件都是坑爹的存在，我是不想去实现他了，而对于赋值运算符，我把这个单独归类，放在文法分析里面去
//对于自增以及自减运算符，这东西除了作为考试题恶心人用没啥大用途吧，
//i=i+1在优化的时候总是会变成等价的自增指令，咱们何必呢


//首先考虑算术优先级
//我们用优先级编号来命名临时的产生式 
//而且我们用左递归来完成从左到右的优先级
//function_arg_type: constant| id_0
//function_use_arg: function_arg_type| function_use_arg ; function_arg_type
//fun_arg: void | function_use_arg
//expression_0:constant|name|(expression_11)|expression_0[expression_11]|expression_0.name|expression_0->name |fun_name(fun_arg)
//expression_1:expression_0|!expression_1|~expression_1|-expression_1
//                |&expression_1|*expression_1|(data_type_com)expression_1|sizeof expression_1
//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[expression_11] | id_0.name | id_0->name 
//id_1: id_0 | *id_0 |& id_0
//id : id_1
//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
//
//
//
//总的来说，一个程序分为三个部分，第一部分数据类型声明，数据类型声明的末尾是函数声明，
//所有的声明按照拓扑顺序来声明
//数据类型声明之后是变量声明，注意这里的变量声明还不能赋值，所以当前只是分配空间
//在变量声明之后才是程序的正文，即所有的赋值语句。
//注意，这里我把算术赋值与函数赋值分开来了。即不允许在算术表达式中出现函数求值。
//还有一个非常需要注意的一点就是，在调用函数的时候，我们不允许算术表达式的存在
//注意在赋值的时候，左边的分量只利用了前两级的运算符，因此任何带取地址和读内存运算符的都需要使用括号括起来
//因为这几个与其他运算符合用的时候总是很容易引起误会，所以我这里就强制规定了
//而对于右边，我就没做这个规定，但是推荐是所有的都采取这样。
//在调用函数的时候，由于参数里面不允许有算术运算符及其他类似的运算符，因此所有的参数都需要提前计算好它的值
//然后再传，这样就没有求值顺序的问题了，我真是太机智了。
//
//
//接下来需要处理的是符号表的管理及各个数据类型、函数、变量的作用域的问题，这个才是大麻烦
//
//
//