1 #include "token_define.h"
2 //这个文件是用来处理句型的，对于算术表达式都是放在前面的那个头文件中来处理
3 typedef struct _handle_tree_node//句型语法树的节点
4 {
5 union
6 {
7 int handle_type;//1代表基本句型，2代表代码块，
8 enum keywords_type keyword;//代表关键字的类型
9 }
10 union//产生体
11 {
12 phrase_tree_node* orginal_phrase_node;//代表单个基本句型
13 struct
14 {
15 struct _handle_tree_node* for_initiate;
16 struct _handle_tree_node* for_judge;
17 struct _handle_tree_node* for_modify;
18 struct _handle_tree_node* for_codeblock;
19 }for_code;//代表for句型
20 struct
21 {
22 struct _handle_tree_node* while_judge;
23 struct _handle_tree_node* while_codeblock;
24 }while_code;//代表while句型
25 struct
26 {
27 struct _handle_tree_node* branch_judge;
28 struct _handle_tree_node* if_code;
29 struct _handle_tree_node* else_code;
30 }branch_code;//代表if else句型
31 };
32 }handle_tree_node;
33 //上面的是动作执行代码，根据我们对文法的定义，还有类型定义部分，函数定义部分，变量声明部分
34 //其中函数定义部分里面比较复杂，会有递归，我们放到最后去考虑
35 //下面先谈最简单的变量声明部分，变量声明部分中最重要的是声明头部，因为声明头经常会被使用。
36 //注意这里的声明头部与c语言不一样的地方就是*是跟着声明头的，而不是跟着变量名
37 //对于声明头的结构，我们在符号表中已经定义过了
38 //这里我们再次定义一下
39 //对于变量的结构，在符号表中也已经定义过了
40 //typedef struct _var_hash_node
41 //{
42 // pbasic_type_pattern current;
43 // char* var_name;
44 // int pointer_layer;//代表指针的级数，我们限制为8级，即只占一个字节，其他三个字节以后再使用，先留着
45 // parray_description array_layer;//这里是数组描述，以链表串起多级数组
46 // ptype_avl_tree current_type;//代表分量的类型
47 //}var_hash_node,*pvar_hash_node;
48 //变量声明的产生式
49 //list_name: new_name|list_name[unsign_constant_int] 对应数组的情形
50 //data_type_basic_body: int |char|float|double|long|unsigned 基础类型体
51 //data_type_basic_pointer: data_type_basic *|data_type_basic_pointer * 基础类型的指针
52 //data_type_basic:data_type_basic_body|data_type_basic_pointer 基础类型（包括指针）
53 //data_type_struct:data_type_struct_body|data_type_struct_pointer 结构体类型声明头部
54 //data_type_union:data_type_union_body|data_type_union_pointer 联合类型声明头部
55 //data_type_head:data_type_basic|data_type_struct|data_type_union 所有的类型头部
56 //data_var_decl: data_type_head list_name; 所有的显示变量声明
57 //注意我们这里只允许一次生命一个变量名
58 //实际处理的时候我们并不是按照前面的产生体严格执行的，我们在遇到变量声明的时候，首先查看第一个name
59 //如果不是struct和union,则对这个名字进行查找类型avl，如果存在，则获得这个类型，然后再处理指针
60 //然后是变量名字，然后是数组描述，这些工作很简单，我们没有必要去放到lr文法分析中去，那样只会增加复杂度
61 //如果是struct和union，则获得下一个token，对这个token执行上述操作，都是一样的
62 //所以我们碰到变量声明的时候，直接处理然后把data_var_decl放到句型栈中，让文法分析来处理
63 //
64 //
65 //
66 //现在来处理类型定义，由于类型定义也是嵌套的，所以我们也需要使用一个栈来处理类型定义，同时为当前定义
67 //构建一个语法分析树来处理，但是类型定义除了嵌套定义外，还存在自引用定义，为此，我们每次处理符合类型的时候
68 //首先记录各个分量的变量名字和类型名字（这里要求各个分量的类型名都已经被处理了）。当得到所有的分量之后
69 //另外分配空间来构造产生体链表，并把类型名字通过查找avl来获得相应的avl节点，并把类型名修改为avl节点的指针
70 //注意这里还有自引用，因此我们在插入avl的时候，只是先把产生体链表构造为空，插入之后再去填充产生体链表。
71 //注意在处理类型声明的时候，我们还要为代码块维护一个类型链表，按照拓扑序来排列
72 //因此在每处理完一个复合类型之后就插入到当前的类型链表中
73 //我们对于每一个代码块都有一个类型链表，而每个函数又是一个代码块，因此会有嵌套的处理
74 //为此我们又需要维护一个栈，栈中存放的是当前的类型链表。
75 //我们为每一个函数代码块维护一个类型链表、一个变量链表、一个代码块语法树的头、一个参数链表
76 //每当调用一个函数的时候，我们就把类型链表、变量链表、参数链表挂载到符号表里面，然后再用后序遍历语法树
77 //来执行代码。
78 //在调用返回之后，按照插入序的逆序来删除所有插入到符号表里面的项
79 //至此一个代码块里面的类型链表已经构建完成了
80 //由于这里只是构建链表，所以所有的类型都是靠名称来索引的，而不是靠指针来索引
81 int code_scope;//这个用来表示当前的代码域
82 struct _composition_list* current_block_pattern_list_rear;//这个代表了当前代码块的类型链表的末尾
83 struct var_decl_link//这个是代码块的变量链表
84 {
85 struct _var_hash_node* current_var_node;
86 struct var_decl_link* next;
87 };
88 struct type_decl_link//这个是代码块的类型链表
89 {
90 struct _type_description_ current_type_node;
91 struct type_decl_link* next;
92 };
93 struct function_description
94 {
95 struct var_decl_link* current_var_link;
96 struct type_decl_link* current_type_link;
97 struct _handle_tree_node* current_action_link;//代表动作链表
98 };
99
100 int check_constant_type(char* in_constant)//1代表小数，0代表整数
101 {
102 while(*(in_constant)!='\0')
103 {
104 if(*(in_constant)=='.')
105 {
106 return 1;
107 }
108 else
109 {
110 in_constant++;
111 }
112 }
113 return 0;
114 }
115 int check_duplicated_name( struct _composition_list list_head,char* in_name)//检查当前的产生体链表是不是已经有重名了
116 {
117 while(list_head!=NULL)
118 {
119 if(strcmp(list_head->current->faction_name,in_name)==0)
120 {
121 return 1;
122 }
123 else
124 {
125 list_head=list_head->next;
126 }
127 }
128 return 0;
129 }
130 struct _composition_list* tackle_type_define(struct type_decl_link** type_link_head)
131 //这个函数是用来处理内部定义的，在处理之前，头部信息已经被插入到了avl树中
132 //只不过生成体没有初始化，这样做的意义就是为了达到结构体自引用
133 //结构体自引用只会在代码最外层的符合类型定义时才使用，对于内部的复合类型，自引用是被禁止的。
134 //所以这个函数在碰到嵌套的符合类型定义的时候,会进行递归调用，
135 //如果未初始化，则将类型名称域与变量名称域指向同一个字符串
136 {
137 //这里还没有写完，以后再写，先写最简单的
138 struct first_token_chain* current_chain_node;
139 struct first_token_chain* next_chain_node;
140 struct first_lex_token* current_lex_node;
141 struct first_lex_token* next_lex_node;
142 struct type_decl_link* return_decl_link;//作为插入到目前代码块的类型链表的节点，从头部插入
143 struct _composition_list return_list_head;//代表返回链表的头部
144 struct _composition_list return_list_rear;//代表返回链表的尾部，作为插入用
145 struct _composition_list temp_list_node;//在遇到内部的符合类型声明的时候来使用的
146 struct _basic_type_pattern temp_sub_pattern;//代表遇到的分量节点
147 struct _type_description temp_type_desc;//代表查询avl得到的名称类型
148 struct _type_description new_type_desc;//代表在遇到一个复合类型声明的时候新建的类型描述
149 struct _array_description temp_array_desc;//代表临时的数组描述符
150 return_list_head=return_list_rear=NULL;
151 current_chain_node=first_chain_head;
152 first_chain_head=first_chain_head->next;
153 current_lex_node=current_chain_node->current_first_token;
154 free(current_lex_node->token_name);
155 free(current_lex_node);
156 free(current_chain_node);
157 current_chain_node=first_chain_head;
158 current_lex_node=current_chain_node->current_first_token;
159 //这里我们都已经做好参数检查了，所以没有必要再去检查，第一个词法单元应该是大括号,而且我们在传参
160 //的时候已经检查过了
161 while(*(current_lex_node->token_name)!='}')//对于内部嵌套的大括号，会被递归处理掉，因此不用担心
162 {
163 switch(current_lex_node->current_lex_type)
164 {
165 case new_line:
166 first_chain_head=first_chain_head->next;
167 free(current_lex_node->token_name);
168 free(current_lex_node);
169 free(current_chain_node);
170 current_chain_node=first_chain_head;
171 current_lex_node=current_chain_node->current_first_token;
172 break;
173 case name:
174 temp_type_desc=search_avl_tree(current_lex_node->token_name);
175 if(temp_type_desc->type_type!=4)//如果开头不是关键字
176 {
177 printf("unexpected %s at the begining of declare statement \n",current_lex_node->token_name);
178 exit();
179 }
180 else
181 {
182 switch(*(current_lex_node->token_name))
183 {
184 case 'i'://对应的是整数
185 case 'c'://对应的是字符
186 case 'f'://对应的是单精度浮点
187 case 'l'://对应的是长整数
188 case 'd'://对应的是双精度浮点
189 temp_sub_pattern=malloc(sizeof(struct _basic_type_pattern));
190 temp_sub_pattern->pointer_layer=0;
191 temp_sub_pattern->array_layer=NULL;
192 temp_sub_pattern->pattern_name=current_lex_node->token_name;
193 first_chain_head=first_chain_head->next;
194 free(current_lex_node->token_name);
195 free(current_lex_node);
196 free(current_chain_node);
197 current_chain_node=first_chain_head;
198 current_lex_node=current_chain_node->current_first_token;
199 while(*(current_lex_node->token_name)=='*')//处理指针
200 {
201 temp_sub_pattern->pointer_layer=temp_sub_pattern->pointer_layer<<1+1;
202 first_chain_head=first_chain_head->next;
203 free(current_lex_node->token_name);
204 free(current_lex_node);
205 free(current_chain_node);
206 current_chain_node=first_chain_head;
207 current_lex_node=current_chain_node->current_first_token;
208 }
209 //现在开始来处理名字
210 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
211 {
212 printf("unexpected %s as var_name\n",current_lex_node->token_name);
213 exit();
214 }
215 else//如果遇到的是名字，则需要考虑当前产生体中是否已经有重名的了
216 {
217 if(return_list_head==NULL)//如果为空的话，就没必要去考虑了直接插入
218 {
219 temp_sub_pattern->faction_name=current_lex_node->token_name;
220 return_list_head=return_list_rear=temp_sub_pattern;
221 }
222 else
223 {
224 if(!check_duplicated_name(return_list_head,current_lex_node->token_name))
225 {
226 temp_sub_pattern->faction_name=current_lex_node->token_name;
227 }
228 else
229 {
230 printf("duplicated name %s encounted \n",current_lex_node->token_name);
231 exit();
232 }
233 }
234 //名称检查已经完成，现在来处理数组
235 temp_list_node=malloc(sizeof(struct _composition_list));
236 temp_list_node->current=temp_sub_pattern;
237 temp_list_node->next=NULL;
238 if(return_list_head==NULL)
239 {
240 return_list_head=return_list_rear=temp_list_node;
241 }
242 else
243 {
244 return_list_rear->next=temp_list_node;
245 return_list_rear=temp_list_node;
246 }
247 first_chain_head=first_chain_head->next;
248 free(current_lex_node);
249 free(current_chain_node);
250 current_chain_node=first_chain_head;
251 current_lex_node=current_chain_node->current_first_token;
252 while(*(current_lex_node->token_name)=='[')//处理指针
253 {
254 first_chain_head=first_chain_head->next;
255 free(current_lex_node->token_name);
256 free(current_lex_node);
257 free(current_chain_node);
258 current_chain_node=first_chain_head;
259 current_lex_node=current_chain_node->current_first_token;
260 //处理数组索引
261 if(current_lex_node->current_lex_type!=constant)
262 {
263 printf("need constant in array decl\n");
264 exit();
265 }
266 else
267 {
268 if(check_constant_type(current_lex_node->token_name))
269 {
270 printf("need integer in array decl\n");
271 exit();
272 }
273 else
274 {
275 temp_array_desc=malloc(sizeof(struct _array_description));
276 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
277 temp_array_desc->next=temp_sub_pattern->array_layer;
278 temp_sub_pattern->array_layer=temp_array_desc;
279 }
280
281
282 }
283 first_chain_head=first_chain_head->next;
284 free(current_lex_node->token_name);
285 free(current_lex_node);
286 free(current_chain_node);
287 current_chain_node=first_chain_head;
288 current_lex_node=current_chain_node->current_first_token;
289 if(*(current_lex_node->token_name)!=']')
290 {
291 printf("need ] while encount %s \n",current_lex_node->token_name);
292 exit();
293 }
294 else
295 {
296 first_chain_head=first_chain_head->next;
297 free(current_lex_node->token_name);
298 free(current_lex_node);
299 free(current_chain_node);
300 current_chain_node=first_chain_head;
301 current_lex_node=current_chain_node->current_first_token;
302 }
303 }
304 if(current_lex_node->current_lex_type==delimit)//吃掉分号
305 {
306 first_chain_head=first_chain_head->next;
307 free(current_lex_node->token_name);
308 free(current_lex_node);
309 free(current_chain_node);
310 current_chain_node=first_chain_head;
311 current_lex_node=current_chain_node->current_first_token;
312 }
313 else
314 {
315 printf("delimit needed after decl\n");
316 exit();
317 }
318 }
319 break;
320 case 'u'://这里有两种情况，一个是联合，一个是无符号整形，我们需要看到第三个字母才能判断
321 if(*(current_lex_node->token_name+2)=='i')//对应的是联合体
322 {
323 temp_sub_pattern=malloc(sizeof(struct _basic_type_pattern));
324 temp_sub_pattern->parray_description=NULL;
325 temp_sub_pattern->pointer_layer=0;
326 temp_sub_pattern->pattern_name=NULL;
327 first_chain_head=first_chain_head->next;
328 free(current_lex_node->token_name);
329 free(current_lex_node);
330 free(current_chain_node);
331 current_chain_node=first_chain_head;
332 current_lex_node=current_chain_node->current_first_token;
333 if(*(current_lex_node->token_name)!='{')//如果后面接的不是大括号，则开始进行联合类型检查
334 {
335 first_chain_head=first_chain_head->next;
336 free(current_lex_node->token_name);
337 free(current_lex_node);
338 free(current_chain_node);
339 current_chain_node=first_chain_head;
340 current_lex_node=current_chain_node->current_first_token;
341 //这里需要检查一下这个结构体是否已经声明了
342 temp_type_desc=search_avl_tree(current_lex_node->token_name);
343 if(temp_type_desc==NULL)
344 {
345 printf("invalid union name %s encounted\n",current_lex_node->token_name);
346 exit();
347 }
348 else
349 {
350 //确定类型
351 temp_sub_pattern->pattern_name=current_lex_node->token_name;
352 while(*(current_lex_node->token_name)=='*')//处理指针
353 {
354 temp_sub_pattern->pointer_layer=temp_sub_pattern->pointer_layer<<1+1;
355 first_chain_head=first_chain_head->next;
356 free(current_lex_node);
357 free(current_chain_node);
358 current_chain_node=first_chain_head;
359 current_lex_node=current_chain_node->current_first_token;
360 }
361 //现在开始来处理名字
362 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
363 {
364 printf("unexpected %s as var_name\n",current_lex_node->token_name);
365 exit();
366 }
367 else//如果遇到的是名字，则需要考虑当前产生体中是否已经有重名的了
368 {
369 if(return_list_head==NULL)//如果为空的话，就没必要去考虑了直接插入
370 {
371 temp_sub_pattern->faction_name=current_lex_node->token_name;
372 return_list_head=return_list_rear=temp_sub_pattern;
373 }
374 else
375 {
376 if(!check_duplicated_name(return_list_head,current_lex_node->token_name))
377 {
378 temp_sub_pattern->faction_name=current_lex_node->token_name;
379 }
380 else
381 {
382 printf("duplicated name %s encounted \n",current_lex_node->token_name);
383 exit();
384 }
385 }
386 //名称检查已经完成，现在来处理数组
387 temp_list_node=malloc(sizeof(struct _composition_list));
388 temp_list_node->current=temp_sub_pattern;
389 temp_list_node->next=NULL;
390 if(return_list_head==NULL)
391 {
392 return_list_head=return_list_rear=temp_list_node;
393 }
394 else
395 {
396 return_list_rear->next=temp_list_node;
397 return_list_rear=temp_list_node;
398 }
399 first_chain_head=first_chain_head->next;
400 free(current_lex_node);
401 free(current_chain_node);
402 current_chain_node=first_chain_head;
403 current_lex_node=current_chain_node->current_first_token;
404 while(*(current_lex_node->token_name)=='[')//处理指针
405 {
406 first_chain_head=first_chain_head->next;
407 free(current_lex_node->token_name);
408 free(current_lex_node);
409 free(current_chain_node);
410 current_chain_node=first_chain_head;
411 current_lex_node=current_chain_node->current_first_token;
412 //处理数组索引
413 if(current_lex_node->current_lex_type!=constant)
414 {
415 printf("need constant in array decl\n");
416 exit();
417 }
418 else
419 {
420 if(check_constant_type(current_lex_node->token_name))
421 {
422 printf("need integer in array decl\n");
423 exit();
424 }
425 else
426 {
427 temp_array_desc=malloc(sizeof(struct _array_description));
428 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
429 temp_array_desc->next=temp_sub_pattern->array_layer;
430 temp_sub_pattern->array_layer=temp_array_desc;
431 }
432
433
434 }
435 first_chain_head=first_chain_head->next;
436 free(current_lex_node->token_name);
437 free(current_lex_node);
438 free(current_chain_node);
439 current_chain_node=first_chain_head;
440 current_lex_node=current_chain_node->current_first_token;
441 if(*(current_lex_node->token_name)!=']')
442 {
443 printf("need ] while encount %s \n",current_lex_node->token_name);
444 exit();
445 }
446 else
447 {
448 first_chain_head=first_chain_head->next;
449 free(current_lex_node->token_name);
450 free(current_lex_node);
451 free(current_chain_node);
452 current_chain_node=first_chain_head;
453 current_lex_node=current_chain_node->current_first_token;
454 }
455 }
456 if(current_lex_node->current_lex_type==delimit)//吃掉分号
457 {
458 first_chain_head=first_chain_head->next;
459 free(current_lex_node->token_name);
460 free(current_lex_node);
461 free(current_chain_node);
462 current_chain_node=first_chain_head;
463 current_lex_node=current_chain_node->current_first_token;
464 }
465 else
466 {
467 printf("delimit needed after decl\n");
468 exit();
469 }
470 }
471 }
472
473 }
474 else//这里是联合类型声明
475 {
476 new_type_desc=malloc(sizeof(struct _type_description));
477 new_type_desc->current_gen_list=tackle_type_define(type_link_head);
478 new_type_desc->type_type=3;
479 return_decl_link=malloc(sizeof(struct type_decl_link));
480 return_decl_link->current_type_node=new_type_desc;
481 return_decl_link->next=(*type_link_head);
482 (*type_link_head)=return_decl_link;
483 //下面是抛弃大括号
484 current_chain_node=first_chain_head;
485 current_lex_node=current_chain_node->current_first_token;
486 //现在来获得分量名字
487 if(current_lex_node->current_lex_type!=name)//类型检查
488 {
489 printf("need name as union name while encounted %s\n",current_lex_node->token_name);
490 exit();
491 }
492 else//检查重名
493 {
494 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果有重名的
495 {
496 printf("duplicated type name %s \n",current_lex_node->token_name);
497 exit();
498 }
499 else
500 {
501 if(check_duplicated_name(return_list_head,current_lex_node->token_name))
502 {
503 printf("duplicated var name %s\n",current_lex_node->token_name);
504 exit();
505 }
506 else//如果没有重名的
507 {
508 new_type_desc->name=current_lex_node->token_name;
509 insert_avl_node(new_type_desc);
510 //这里将这个类型插入到avl符号表中
511 //然后还要插入分量列表中
512 temp_sub_pattern->faction_name=current_lex_node->token_name;
513 temp_sub_pattern->pattern_name=current_lex_node->token_name;
514 temp_list_node=malloc(sizeof(struct _composition_list));
515 temp_list_node->current=temp_sub_pattern;
516 temp_list_node->next=NULL;
517 if(return_list_head==NULL)
518 {
519 return_list_head=return_list_rear=temp_list_head;
520 }
521 else
522 {
523 return_list_rear->next=temp_list_head;
524 return_list_rear=temp_list_head;
525 }
526 //至此类型分量也已经插入完毕了
527 first_chain_head=first_chain_head->next;
528 free(current_lex_node);
529 free(current_chain_node);
530 current_chain_node=first_chain_head;
531 current_lex_node=current_chain_node->current_first_token;
532 //再次吃掉分号
533 if(*(current_lex_node->token_name)!=';')
534 {
535 printf("missing ; after type define\n");
536 exit();
537 }
538 else
539 {
540 first_chain_head=first_chain_head->next;
541 free(current_lex_node->token_name);
542 free(current_lex_node);
543 free(current_chain_node);
544 current_chain_node=first_chain_head;
545 current_lex_node=current_chain_node->current_first_token;
546 //然后再吃掉所有的换行符
547 }
548 }
549 }
550 }
551 }
552 }
553 else//对应的是无符号整数
554 {
555 temp_sub_pattern=malloc(sizeof(struct _basic_type_pattern));
556 temp_sub_pattern->pointer_layer=0;
557 temp_sub_pattern->array_layer=NULL;
558 temp_sub_pattern->pattern_name=current_lex_node->token_name;
559 first_chain_head=first_chain_head->next;
560 free(current_lex_node);
561 free(current_chain_node);
562 current_chain_node=first_chain_head;
563 current_lex_node=current_chain_node->current_first_token;
564 while(*(current_lex_node->token_name)=='*')//处理指针
565 {
566 temp_sub_pattern->pointer_layer=temp_sub_pattern->pointer_layer<<1+1;
567 first_chain_head=first_chain_head->next;
568 free(current_lex_node->token_name);
569 free(current_lex_node);
570 free(current_chain_node);
571 current_chain_node=first_chain_head;
572 current_lex_node=current_chain_node->current_first_token;
573 }
574 //现在开始来处理名字
575 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
576 {
577 printf("unexpected %s as var_name\n",current_lex_node->token_name);
578 exit();
579 }
580 else//如果遇到的是名字，则需要考虑当前产生体中是否已经有重名的了
581 {
582 if(return_list_head==NULL)//如果为空的话，就没必要去考虑了直接插入
583 {
584 temp_sub_pattern->faction_name=current_lex_node->token_name;
585 return_list_head=return_list_rear=temp_sub_pattern;
586 }
587 else
588 {
589 if(!check_duplicated_name(return_list_head,current_lex_node->token_name))
590 {
591 temp_sub_pattern->faction_name=current_lex_node->token_name;
592 }
593 else
594 {
595 printf("duplicated name %s encounted \n",current_lex_node->token_name);
596 exit();
597 }
598 }
599 //名称检查已经完成
600 first_chain_head=first_chain_head->next;
601 free(current_lex_node);
602 free(current_chain_node);
603 current_chain_node=first_chain_head;
604 current_lex_node=current_chain_node->current_first_token;
605 while(*(current_lex_node->token_name)=='[')//处理数组
606 {
607 first_chain_head=first_chain_head->next;
608 free(current_lex_node->token_name);
609 free(current_lex_node);
610 free(current_chain_node);
611 current_chain_node=first_chain_head;
612 current_lex_node=current_chain_node->current_first_token;
613 //处理数组索引
614 if(current_lex_node->current_lex_type!=constant)//判断是不是常数
615 {
616 printf("need constant in array decl\n");
617 exit();
618 }
619 else
620 {
621 if(check_constant_type(current_lex_node->token_name))//判断是不是整数
622 {
623 printf("need integer in array decl\n");
624 exit();
625 }
626 else
627 {
628 temp_array_desc=malloc(sizeof(struct _array_description));
629 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
630 temp_array_desc->next=temp_sub_pattern->array_layer;
631 temp_sub_pattern->array_layer=temp_array_desc;
632 }
633 }
634 first_chain_head=first_chain_head->next;
635 free(current_lex_node->token_name);
636 free(current_lex_node);
637 free(current_chain_node);
638 current_chain_node=first_chain_head;
639 current_lex_node=current_chain_node->current_first_token;
640 if(*(current_lex_node->token_name)!=']')
641 {
642 printf("need ] while encount %s \n",current_lex_node->token_name);
643 exit();
644 }
645 else
646 {
647 first_chain_head=first_chain_head->next;
648 free(current_lex_node->token_name);
649 free(current_lex_node);
650 free(current_chain_node);
651 current_chain_node=first_chain_head;
652 current_lex_node=current_chain_node->current_first_token;
653 }
654 }
655 temp_list_node=malloc(sizeof(struct _composition_list));
656 temp_list_node->current=temp_sub_pattern;
657 temp_list_node->next=NULL;
658 //进行分量的插入
659 if(return_list_head==NULL)
660 {
661 return_list_head=return_list_rear=temp_list_node;
662 }
663 else
664 {
665 return_list_rear->next=temp_list_node;
666 return_list_rear=temp_list_node;
667 }
668 if(current_lex_node->current_lex_type==delimit)//吃掉分号
669 {
670 first_chain_head=first_chain_head->next;
671 free(current_lex_node->token_name);
672 free(current_lex_node);
673 free(current_chain_node);
674 current_chain_node=first_chain_head;
675 current_lex_node=current_chain_node->current_first_token;
676 }
677 else
678 {
679 printf("delimit needed after decl\n");
680 exit();
681 }
682 }
683 }
684 break;
685 case 's'://对应的是结构体
686 temp_sub_pattern=malloc(sizeof(struct _basic_type_pattern));
687 temp_sub_pattern->parray_description=NULL;
688 temp_sub_pattern->pointer_layer=0;
689 temp_sub_pattern->pattern_name=NULL;
690 first_chain_head=first_chain_head->next;
691 free(current_lex_node->token_name);
692 free(current_lex_node);
693 free(current_chain_node);
694 current_chain_node=first_chain_head;
695 current_lex_node=current_chain_node->current_first_token;
696 if(*(current_lex_node->token_name)!='{')//如果后面接的不是大括号，开始变量声明
697 {
698 first_chain_head=first_chain_head->next;
699 free(current_lex_node->token_name);
700 free(current_lex_node);
701 free(current_chain_node);
702 current_chain_node=first_chain_head;
703 current_lex_node=current_chain_node->current_first_token;
704 //这里需要检查一下这个结构体是否已经声明了
705 temp_type_desc=search_avl_tree(current_lex_node->token_name);
706 if(temp_type_desc==NULL)//检查结构体的名字是否有效
707 {
708 printf("unknown struct name %s encounted \n",current_lex_node->token_name);
709 exit();
710 }
711 else//结构体类型有效
712 {
713 temp_sub_pattern=malloc(sizeof(struct _basic_type_pattern));
714 temp_sub_pattern->pointer_layer=0;
715 temp_sub_pattern->array_layer=NULL;
716 temp_sub_pattern->pattern_name=current_lex_node->token_name;
717 first_chain_head=first_chain_head->next;
718 free(current_lex_node);
719 free(current_chain_node);
720 current_chain_node=first_chain_head;
721 current_lex_node=current_chain_node->current_first_token;
722 while(*(current_lex_node->token_name)=='*')//处理指针
723 {
724 temp_sub_pattern->pointer_layer=temp_sub_pattern->pointer_layer<<1+1;
725 first_chain_head=first_chain_head->next;
726 free(current_lex_node->token_name);
727 free(current_lex_node);
728 free(current_chain_node);
729 current_chain_node=first_chain_head;
730 current_lex_node=current_chain_node->current_first_token;
731 }
732 //现在开始来处理名字
733 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
734 {
735 printf("unexpected %s as var_name\n",current_lex_node->token_name);
736 exit();
737 }
738 else//如果遇到的是名字，则需要考虑当前产生体中是否已经有重名的了
739 {
740 if(return_list_head==NULL)//如果为空的话，就没必要去考虑了直接插入
741 {
742 temp_sub_pattern->faction_name=current_lex_node->token_name;
743 return_list_head=return_list_rear=temp_sub_pattern;
744 }
745 else
746 {
747 if(!check_duplicated_name(return_list_head,current_lex_node->token_name))
748 {
749 temp_sub_pattern->faction_name=current_lex_node->token_name;
750 }
751 else
752 {
753 printf("duplicated name %s encounted \n",current_lex_node->token_name);
754 exit();
755 }
756 }
757 //名称检查已经完成，现在来处理数组
758 temp_list_node=malloc(sizeof(struct _composition_list));
759 temp_list_node->current=temp_sub_pattern;
760 temp_list_node->next=NULL;
761 if(return_list_head==NULL)
762 {
763 return_list_head=return_list_rear=temp_list_node;
764 }
765 else
766 {
767 return_list_rear->next=temp_list_node;
768 return_list_rear=temp_list_node;
769 }
770 first_chain_head=first_chain_head->next;
771 free(current_lex_node);
772 free(current_chain_node);
773 current_chain_node=first_chain_head;
774 current_lex_node=current_chain_node->current_first_token;
775 while(*(current_lex_node->token_name)=='[')//处理指针
776 {
777 first_chain_head=first_chain_head->next;
778 free(current_lex_node->token_name);
779 free(current_lex_node);
780 free(current_chain_node);
781 current_chain_node=first_chain_head;
782 current_lex_node=current_chain_node->current_first_token;
783 //处理数组索引
784 if(current_lex_node->current_lex_type!=constant)
785 {
786 printf("need constant in array decl\n");
787 exit();
788 }
789 else
790 {
791 if(check_constant_type(current_lex_node->token_name))
792 {
793 printf("need integer in array decl\n");
794 exit();
795 }
796 else
797 {
798 temp_array_desc=malloc(sizeof(struct _array_description));
799 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
800 temp_array_desc->next=temp_sub_pattern->array_layer;
801 temp_sub_pattern->array_layer=temp_array_desc;
802 }
803 }
804 first_chain_head=first_chain_head->next;
805 free(current_lex_node->token_name);
806 free(current_lex_node);
807 free(current_chain_node);
808 current_chain_node=first_chain_head;
809 current_lex_node=current_chain_node->current_first_token;
810 if(*(current_lex_node->token_name)!=']')
811 {
812 printf("need ] while encount %s \n",current_lex_node->token_name);
813 exit();
814 }
815 else
816 {
817 first_chain_head=first_chain_head->next;
818 free(current_lex_node->token_name);
819 free(current_lex_node);
820 free(current_chain_node);
821 current_chain_node=first_chain_head;
822 current_lex_node=current_chain_node->current_first_token;
823 }
824 }
825 if(current_lex_node->current_lex_type==delimit)//吃掉分号
826 {
827 first_chain_head=first_chain_head->next;
828 free(current_lex_node->token_name);
829 free(current_lex_node);
830 free(current_chain_node);
831 current_chain_node=first_chain_head;
832 current_lex_node=current_chain_node->current_first_token;
833 }
834 else
835 {
836 printf("delimit needed after decl\n");
837 exit();
838 }
839 }
840 }
841 }
842 else//如果是大括号，则开始内部类型声明
843 {
844 new_type_desc=malloc(sizeof(struct _type_description));
845 new_type_desc->current_gen_list=tackle_type_define();
846 new_type_desc->type_type=2;
847 return_decl_link=malloc(sizeof(struct type_decl_link));
848 return_decl_link->current_type_node=new_type_desc;
849 return_decl_link->next=(*type_link_head);
850 (*type_link_head)=return_decl_link;
851 //下面是抛弃大括号
852 current_chain_node=first_chain_head;
853 current_lex_node=current_chain_node->current_first_token;
854 //现在来获得分量名字
855 if(current_lex_node->current_lex_type!=name)//类型检查
856 {
857 printf("need name as struct name while encounted %s\n",current_lex_node->token_name);
858 exit();
859 }
860 else//检查重名
861 {
862 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果有重名的
863 {
864 printf("duplicated type name %s \n",current_lex_node->token_name);
865 exit();
866 }
867 else
868 {
869 if(check_duplicated_name(return_list_head,current_lex_node->token_name))
870 {
871 printf("duplicated var name %s\n",current_lex_node->token_name);
872 exit();
873 }
874 else//如果没有重名的
875 {
876 new_type_desc->name=current_lex_node->token_name;
877 insert_avl_node(new_type_desc);
878 temp_sub_pattern->faction_name=current_lex_node->token_name;
879 temp_sub_pattern->pattern_name=current_lex_node->token_name;
880 temp_list_node=malloc(sizeof(struct _composition_list));
881 temp_list_node->current=temp_sub_pattern;
882 temp_list_node->next=NULL;
883 if(return_list_head==NULL)
884 {
885 return_list_head=return_list_rear=temp_list_head;
886 }
887 else
888 {
889 return_list_rear->next=temp_list_head;
890 return_list_rear=temp_list_head;
891 }
892 //至此类型分量也已经插入完毕了
893 first_chain_head=first_chain_head->next;
894 free(current_lex_node);
895 free(current_chain_node);
896 current_chain_node=first_chain_head;
897 current_lex_node=current_chain_node->current_first_token;
898 //再次吃掉分号
899 if(*(current_lex_node->token_name)!=';')
900 {
901 printf("missing ; after type define\n");
902 exit();
903 }
904 else
905 {
906 first_chain_head=first_chain_head->next;
907 free(current_lex_node->token_name);
908 free(current_lex_node);
909 free(current_chain_node);
910 current_chain_node=first_chain_head;
911 current_lex_node=current_chain_node->current_first_token;
912 }
913 }
914 }
915 }
916 }
917 break;
918 default:
919 printf("unexpected token %s as type \n",current_lex_node->token_name);
920 exit();
921 }
922 }
923 break;
924 default:
925 printf("unexpected token %s at the begining of new_line\n",current_lex_node->token_name);
926 exit();
927 }
928 }
929 //释放掉这个大括号
930 first_chain_head=first_chain_head->next;
931 free(current_lex_node->token_name);
932 free(current_lex_node);
933 free(current_chain_node);
934 return return_list_head;
935 }
936 struct var_hash_node* tackle_var_decl(void )//这里处理的是变量声明，不是函数声明,而且我们不进行重名检查
937 //等函数返回之后再去进行重名检查
938 {
939 struct first_token_chain* current_chain_node;
940 struct first_token_chain* next_chain_node;
941 struct first_lex_token* current_lex_node;
942 struct first_lex_token* next_lex_node;
943 struct _type_description* temp_type_desc;//代表查询avl得到的名称类型
944 struct _var_hash_node* return_var_node;//代表返回的值
945 struct _array_description temp_array_desc;//代表临时的数组描述符
946 current_chain_node=first_chain_head;
947 current_lex_node=current_chain_node->current_first_token;
948 temp_type_desc=search_avl_tree(current_lex_node->token_name);
949 if(temp_type_desc->type_type!=4)//如果开头不是关键字
950 {
951 printf("unexpected %s at the begining of declare statement \n",current_lex_node->token_name);
952 exit();
953 }
954 else
955 {
956 switch(*(current_lex_node->token_name))
957 {
958 case 'i':
959 case 'l':
960 case 'f':
961 case 'd':
962 case 'c':
963 case 'v'://差点忘了这个货
964 return_var_node=malloc(sizeof(struct _var_hash_node));
965 return_var_node->var_type=temp_type_desc;
966 return_var_node->array_layer=NULL;
967 return_var_node->pointer_layer=0;
968 first_chain_head=first_chain_head->next;
969 free(current_lex_node->token_name);
970 free(current_lex_node);
971 free(current_chain_node);
972 current_chain_node=first_chain_head;
973 current_lex_node=current_chain_node->current_first_token;
974 while(*(current_lex_node->token_name)=='*')//处理指针
975 {
976 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
977 first_chain_head=first_chain_head->next;
978 free(current_lex_node->token_name);
979 free(current_lex_node);
980 free(current_chain_node);
981 current_chain_node=first_chain_head;
982 current_lex_node=current_chain_node->current_first_token;
983 }
984 //现在开始来处理名字
985 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
986 {
987 printf("unexpected %s as var_name\n",current_lex_node->token_name);
988 exit();
989 }
990 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
991 //返回之后再去考虑
992 {
993 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
994 {
995 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
996 exit();
997 }
998 //名称检查已经完成，现在来处理数组
999 return_var_node->var_name=current_lex_node->token_name;
1000 first_chain_head=first_chain_head->next;
1001 free(current_lex_node);
1002 free(current_chain_node);
1003 current_chain_node=first_chain_head;
1004 current_lex_node=current_chain_node->current_first_token;
1005 while(*(current_lex_node->token_name)=='[')//处理指针
1006 {
1007 first_chain_head=first_chain_head->next;
1008 free(current_lex_node->token_name);
1009 free(current_lex_node);
1010 free(current_chain_node);
1011 current_chain_node=first_chain_head;
1012 current_lex_node=current_chain_node->current_first_token;
1013 //处理数组索引
1014 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1015 {
1016 printf("need constant in array decl\n");
1017 exit();
1018 }
1019 else//检查是不是整数
1020 {
1021 if(check_constant_type(current_lex_node->token_name))
1022 {
1023 printf("need integer in array decl\n");
1024 exit();
1025 }
1026 else
1027 {
1028 temp_array_desc=malloc(sizeof(struct _array_description));
1029 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1030 temp_array_desc->next=return_var_node->array_layer;
1031 return_var_node->array_layer=temp_array_desc;
1032 }
1033 }
1034 first_chain_head=first_chain_head->next;
1035 free(current_lex_node->token_name);
1036 free(current_lex_node);
1037 free(current_chain_node);
1038 current_chain_node=first_chain_head;
1039 current_lex_node=current_chain_node->current_first_token;
1040 if(*(current_lex_node->token_name)!=']')
1041 {
1042 printf("need ] while encount %s \n",current_lex_node->token_name);
1043 exit();
1044 }
1045 else
1046 {
1047 first_chain_head=first_chain_head->next;
1048 free(current_lex_node->token_name);
1049 free(current_lex_node);
1050 free(current_chain_node);
1051 current_chain_node=first_chain_head;
1052 current_lex_node=current_chain_node->current_first_token;
1053 }
1054 }
1055 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1056 {
1057 first_chain_head=first_chain_head->next;
1058 free(current_lex_node->token_name);
1059 free(current_lex_node);
1060 free(current_chain_node);
1061 current_chain_node=first_chain_head;
1062 current_lex_node=current_chain_node->current_first_token;
1063 }
1064 else
1065 {
1066 printf("delimit needed after decl\n");
1067 exit();
1068 }
1069 }
1070
1071
1072
1073
1074 break;
1075 case 's'://结构体
1076 first_chain_head=first_chain_head->next;
1077 free(current_lex_node->token_name);
1078 free(current_lex_node);
1079 free(current_chain_node);
1080 current_chain_node=first_chain_head;
1081 current_lex_node=current_chain_node->current_first_token;
1082 temp_type_desc=search_avl_tree(current_lex_node->token_name);
1083 if(temp_type_desc==NULL)
1084 {
1085 printf(" invalid type_name %s is encounted \n",current_lex_node->token_name);
1086 exit();
1087 }
1088 else
1089 {
1090 if(temp_type_desc->type_type!=2)
1091 {
1092 printf("the typename %s is not struct \n",current_lex_node->token_name);
1093 exit();
1094 }
1095 }
1096 //至此参数检查完成
1097 return_var_node=malloc(sizeof(struct _var_hash_node));
1098 return_var_node->var_type=temp_type_desc;
1099 return_var_node->array_layer=NULL;
1100 return_var_node->pointer_layer=0;
1101 first_chain_head=first_chain_head->next;
1102 free(current_lex_node->token_name);
1103 free(current_lex_node);
1104 free(current_chain_node);
1105 current_chain_node=first_chain_head;
1106 current_lex_node=current_chain_node->current_first_token;
1107 while(*(current_lex_node->token_name)=='*')//处理指针
1108 {
1109 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
1110 first_chain_head=first_chain_head->next;
1111 free(current_lex_node->token_name);
1112 free(current_lex_node);
1113 free(current_chain_node);
1114 current_chain_node=first_chain_head;
1115 current_lex_node=current_chain_node->current_first_token;
1116 }
1117 //现在开始来处理名字
1118 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
1119 {
1120 printf("unexpected %s as var_name\n",current_lex_node->token_name);
1121 exit();
1122 }
1123 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
1124 //返回之后再去考虑
1125 {
1126 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
1127 {
1128 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
1129 exit();
1130 }
1131 //名称检查已经完成，现在来处理数组
1132 return_var_node->var_name=current_lex_node->token_name;
1133 first_chain_head=first_chain_head->next;
1134 free(current_lex_node);
1135 free(current_chain_node);
1136 current_chain_node=first_chain_head;
1137 current_lex_node=current_chain_node->current_first_token;
1138 while(*(current_lex_node->token_name)=='[')//处理指针
1139 {
1140 first_chain_head=first_chain_head->next;
1141 free(current_lex_node->token_name);
1142 free(current_lex_node);
1143 free(current_chain_node);
1144 current_chain_node=first_chain_head;
1145 current_lex_node=current_chain_node->current_first_token;
1146 //处理数组索引
1147 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1148 {
1149 printf("need constant in array decl\n");
1150 exit();
1151 }
1152 else//检查是不是整数
1153 {
1154 if(check_constant_type(current_lex_node->token_name))
1155 {
1156 printf("need integer in array decl\n");
1157 exit();
1158 }
1159 else
1160 {
1161 temp_array_desc=malloc(sizeof(struct _array_description));
1162 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1163 temp_array_desc->next=return_var_node->array_layer;
1164 return_var_node->array_layer=temp_array_desc;
1165 }
1166 }
1167 first_chain_head=first_chain_head->next;
1168 free(current_lex_node->token_name);
1169 free(current_lex_node);
1170 free(current_chain_node);
1171 current_chain_node=first_chain_head;
1172 current_lex_node=current_chain_node->current_first_token;
1173 if(*(current_lex_node->token_name)!=']')
1174 {
1175 printf("need ] while encount %s \n",current_lex_node->token_name);
1176 exit();
1177 }
1178 else
1179 {
1180 first_chain_head=first_chain_head->next;
1181 free(current_lex_node->token_name);
1182 free(current_lex_node);
1183 free(current_chain_node);
1184 current_chain_node=first_chain_head;
1185 current_lex_node=current_chain_node->current_first_token;
1186 }
1187 }
1188 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1189 {
1190 first_chain_head=first_chain_head->next;
1191 free(current_lex_node->token_name);
1192 free(current_lex_node);
1193 free(current_chain_node);
1194 current_chain_node=first_chain_head;
1195 current_lex_node=current_chain_node->current_first_token;
1196 }
1197 else
1198 {
1199 printf("delimit needed after decl\n");
1200 exit();
1201 }
1202 }
1203 break;
1204 case 'u':
1205 if(*(current_lex_node->token_name+2)=='s')//代表的是无符号数
1206 {
1207 return_var_node=malloc(sizeof(struct _var_hash_node));
1208 return_var_node->var_type=temp_type_desc;
1209 return_var_node->array_layer=NULL;
1210 return_var_node->pointer_layer=0;
1211 first_chain_head=first_chain_head->next;
1212 free(current_lex_node->token_name);
1213 free(current_lex_node);
1214 free(current_chain_node);
1215 current_chain_node=first_chain_head;
1216 current_lex_node=current_chain_node->current_first_token;
1217 while(*(current_lex_node->token_name)=='*')//处理指针
1218 {
1219 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
1220 first_chain_head=first_chain_head->next;
1221 free(current_lex_node->token_name);
1222 free(current_lex_node);
1223 free(current_chain_node);
1224 current_chain_node=first_chain_head;
1225 current_lex_node=current_chain_node->current_first_token;
1226 }
1227 //现在开始来处理名字
1228 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
1229 {
1230 printf("unexpected %s as var_name\n",current_lex_node->token_name);
1231 exit();
1232 }
1233 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
1234 //返回之后再去考虑
1235 {
1236 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
1237 {
1238 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
1239 exit();
1240 }
1241 //名称检查已经完成，现在来处理数组
1242 return_var_node->var_name=current_lex_node->token_name;
1243 first_chain_head=first_chain_head->next;
1244 free(current_lex_node);
1245 free(current_chain_node);
1246 current_chain_node=first_chain_head;
1247 current_lex_node=current_chain_node->current_first_token;
1248 while(*(current_lex_node->token_name)=='[')//处理指针
1249 {
1250 first_chain_head=first_chain_head->next;
1251 free(current_lex_node->token_name);
1252 free(current_lex_node);
1253 free(current_chain_node);
1254 current_chain_node=first_chain_head;
1255 current_lex_node=current_chain_node->current_first_token;
1256 //处理数组索引
1257 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1258 {
1259 printf("need constant in array decl\n");
1260 exit();
1261 }
1262 else//检查是不是整数
1263 {
1264 if(check_constant_type(current_lex_node->token_name))
1265 {
1266 printf("need integer in array decl\n");
1267 exit();
1268 }
1269 else
1270 {
1271 temp_array_desc=malloc(sizeof(struct _array_description));
1272 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1273 temp_array_desc->next=return_var_node->array_layer;
1274 return_var_node->array_layer=temp_array_desc;
1275 }
1276 }
1277 first_chain_head=first_chain_head->next;
1278 free(current_lex_node->token_name);
1279 free(current_lex_node);
1280 free(current_chain_node);
1281 current_chain_node=first_chain_head;
1282 current_lex_node=current_chain_node->current_first_token;
1283 if(*(current_lex_node->token_name)!=']')
1284 {
1285 printf("need ] while encount %s \n",current_lex_node->token_name);
1286 exit();
1287 }
1288 else
1289 {
1290 first_chain_head=first_chain_head->next;
1291 free(current_lex_node->token_name);
1292 free(current_lex_node);
1293 free(current_chain_node);
1294 current_chain_node=first_chain_head;
1295 current_lex_node=current_chain_node->current_first_token;
1296 }
1297 }
1298 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1299 {
1300 first_chain_head=first_chain_head->next;
1301 free(current_lex_node->token_name);
1302 free(current_lex_node);
1303 free(current_chain_node);
1304 current_chain_node=first_chain_head;
1305 current_lex_node=current_chain_node->current_first_token;
1306 }
1307 else
1308 {
1309 printf("delimit needed after decl\n");
1310 exit();
1311 }
1312 }
1313 }
1314 else
1315 {
1316 first_chain_head=first_chain_head->next;
1317 free(current_lex_node->token_name);
1318 free(current_lex_node);
1319 free(current_chain_node);
1320 current_chain_node=first_chain_head;
1321 current_lex_node=current_chain_node->current_first_token;
1322 temp_type_desc=search_avl_tree(current_lex_node->token_name);
1323 if(temp_type_desc==NULL)
1324 {
1325 printf(" invalid type_name %s is encounted \n",current_lex_node->token_name);
1326 exit();
1327 }
1328 else
1329 {
1330 if(temp_type_desc->type_type!=3)
1331 {
1332 printf("the typename %s is not union \n",current_lex_node->token_name);
1333 exit();
1334 }
1335 }
1336 //至此参数检查完成
1337 return_var_node=malloc(sizeof(struct _var_hash_node));
1338 return_var_node->var_type=temp_type_desc;
1339 return_var_node->array_layer=NULL;
1340 return_var_node->pointer_layer=0;
1341 first_chain_head=first_chain_head->next;
1342 free(current_lex_node->token_name);
1343 free(current_lex_node);
1344 free(current_chain_node);
1345 current_chain_node=first_chain_head;
1346 current_lex_node=current_chain_node->current_first_token;
1347 while(*(current_lex_node->token_name)=='*')//处理指针
1348 {
1349 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
1350 first_chain_head=first_chain_head->next;
1351 free(current_lex_node->token_name);
1352 free(current_lex_node);
1353 free(current_chain_node);
1354 current_chain_node=first_chain_head;
1355 current_lex_node=current_chain_node->current_first_token;
1356 }
1357 //现在开始来处理名字
1358 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
1359 {
1360 printf("unexpected %s as var_name\n",current_lex_node->token_name);
1361 exit();
1362 }
1363 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
1364 //返回之后再去考虑
1365 {
1366 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
1367 {
1368 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
1369 exit();
1370 }
1371 //名称检查已经完成，现在来处理数组
1372 return_var_node->var_name=current_lex_node->token_name;
1373 first_chain_head=first_chain_head->next;
1374 free(current_lex_node);
1375 free(current_chain_node);
1376 current_chain_node=first_chain_head;
1377 current_lex_node=current_chain_node->current_first_token;
1378 while(*(current_lex_node->token_name)=='[')//处理指针
1379 {
1380 first_chain_head=first_chain_head->next;
1381 free(current_lex_node->token_name);
1382 free(current_lex_node);
1383 free(current_chain_node);
1384 current_chain_node=first_chain_head;
1385 current_lex_node=current_chain_node->current_first_token;
1386 //处理数组索引
1387 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1388 {
1389 printf("need constant in array decl\n");
1390 exit();
1391 }
1392 else//检查是不是整数
1393 {
1394 if(check_constant_type(current_lex_node->token_name))
1395 {
1396 printf("need integer in array decl\n");
1397 exit();
1398 }
1399 else
1400 {
1401 temp_array_desc=malloc(sizeof(struct _array_description));
1402 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1403 temp_array_desc->next=return_var_node->array_layer;
1404 return_var_node->array_layer=temp_array_desc;
1405 }
1406 }
1407 first_chain_head=first_chain_head->next;
1408 free(current_lex_node->token_name);
1409 free(current_lex_node);
1410 free(current_chain_node);
1411 current_chain_node=first_chain_head;
1412 current_lex_node=current_chain_node->current_first_token;
1413 if(*(current_lex_node->token_name)!=']')
1414 {
1415 printf("need ] while encount %s \n",current_lex_node->token_name);
1416 exit();
1417 }
1418 else
1419 {
1420 first_chain_head=first_chain_head->next;
1421 free(current_lex_node->token_name);
1422 free(current_lex_node);
1423 free(current_chain_node);
1424 current_chain_node=first_chain_head;
1425 current_lex_node=current_chain_node->current_first_token;
1426 }
1427 }
1428 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1429 {
1430 first_chain_head=first_chain_head->next;
1431 free(current_lex_node->token_name);
1432 free(current_lex_node);
1433 free(current_chain_node);
1434 current_chain_node=first_chain_head;
1435 current_lex_node=current_chain_node->current_first_token;
1436 }
1437 else
1438 {
1439 printf("delimit needed after decl\n");
1440 exit();
1441 }
1442 }
1443 }
1444 break;
1445 default:
1446 printf("unexpected decl_head %s is encounted \n",current_lex_node->token_name);
1447 exit();
1448 break;
1449 }
1450 }
1451 return return_var_node;
1452 }
1453 struct var_decl_link* tackle_func_arg(void)
1454 {
1455 struct _var_hash_node* return_var_node;//代表临时得到的单个参数
1456 struct var_decl_link* return_list_head;
1457 struct var_decl_link* return_list_rear;
1458 struct var_decl_link* temp_list_node;//这个是为了建立链表用的
1459 struct first_token_chain* current_chain_node;
1460 struct first_token_chain* next_chain_node;
1461 struct first_lex_token* current_lex_node;
1462 struct first_lex_token* next_lex_node;
1463 struct _type_description* temp_type_desc;//代表查询avl得到的名称类型
1464 struct _var_hash_node* return_var_node;//代表返回的值
1465 struct _array_description temp_array_desc;//代表临时的数组描述符
1466 return_list_head=return_list_rear=NULL;
1467 current_chain_node=first_chain_head;
1468 first_chain_head=first_chain_head->next;
1469 current_lex_node=current_chain_node->current_first_token;
1470 free(current_lex_node->token_name);
1471 free(current_lex_node);
1472 free(current_chain_node);
1473 current_chain_node=first_chain_head;
1474 current_lex_node=current_chain_node->current_first_token;
1475 while(*(current_lex_node->token_name)!=')')
1476 {
1477 while(current_lex_node->current_lex_type==new_line)
1478 {
1479 first_chain_head=first_chain_head->next;
1480 current_lex_node=current_chain_node->current_first_token;
1481 free(current_lex_node->token_name);
1482 free(current_lex_node);
1483 free(current_chain_node);
1484 current_chain_node=first_chain_head;
1485 current_lex_node=current_chain_node->current_first_token;
1486 }
1487 switch(*(current_lex_node->token_name))
1488 {
1489 case 'i':
1490 case 'l':
1491 case 'f':
1492 case 'd':
1493 case 'c':
1494 case 'v'://差点忘了这个货
1495 return_var_node=malloc(sizeof(struct _var_hash_node));
1496 return_var_node->var_type=temp_type_desc;
1497 return_var_node->array_layer=NULL;
1498 return_var_node->pointer_layer=0;
1499 first_chain_head=first_chain_head->next;
1500 free(current_lex_node->token_name);
1501 free(current_lex_node);
1502 free(current_chain_node);
1503 current_chain_node=first_chain_head;
1504 current_lex_node=current_chain_node->current_first_token;
1505 while(*(current_lex_node->token_name)=='*')//处理指针
1506 {
1507 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
1508 first_chain_head=first_chain_head->next;
1509 free(current_lex_node->token_name);
1510 free(current_lex_node);
1511 free(current_chain_node);
1512 current_chain_node=first_chain_head;
1513 current_lex_node=current_chain_node->current_first_token;
1514 }
1515 //现在开始来处理名字
1516 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
1517 {
1518 printf("unexpected %s as var_name\n",current_lex_node->token_name);
1519 exit();
1520 }
1521 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
1522 //返回之后再去考虑
1523 {
1524 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
1525 {
1526 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
1527 exit();
1528 }
1529 //名称检查已经完成，现在来处理数组
1530 return_var_node->var_name=current_lex_node->token_name;
1531 first_chain_head=first_chain_head->next;
1532 free(current_lex_node);
1533 free(current_chain_node);
1534 current_chain_node=first_chain_head;
1535 current_lex_node=current_chain_node->current_first_token;
1536 while(*(current_lex_node->token_name)=='[')//处理指针
1537 {
1538 first_chain_head=first_chain_head->next;
1539 free(current_lex_node->token_name);
1540 free(current_lex_node);
1541 free(current_chain_node);
1542 current_chain_node=first_chain_head;
1543 current_lex_node=current_chain_node->current_first_token;
1544 //处理数组索引
1545 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1546 {
1547 printf("need constant in array decl\n");
1548 exit();
1549 }
1550 else//检查是不是整数
1551 {
1552 if(check_constant_type(current_lex_node->token_name))
1553 {
1554 printf("need integer in array decl\n");
1555 exit();
1556 }
1557 else
1558 {
1559 temp_array_desc=malloc(sizeof(struct _array_description));
1560 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1561 temp_array_desc->next=return_var_node->array_layer;
1562 return_var_node->array_layer=temp_array_desc;
1563 }
1564 }
1565 first_chain_head=first_chain_head->next;
1566 free(current_lex_node->token_name);
1567 free(current_lex_node);
1568 free(current_chain_node);
1569 current_chain_node=first_chain_head;
1570 current_lex_node=current_chain_node->current_first_token;
1571 if(*(current_lex_node->token_name)!=']')
1572 {
1573 printf("need ] while encount %s \n",current_lex_node->token_name);
1574 exit();
1575 }
1576 else
1577 {
1578 first_chain_head=first_chain_head->next;
1579 free(current_lex_node->token_name);
1580 free(current_lex_node);
1581 free(current_chain_node);
1582 current_chain_node=first_chain_head;
1583 current_lex_node=current_chain_node->current_first_token;
1584 }
1585 }
1586 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1587 {
1588 first_chain_head=first_chain_head->next;
1589 free(current_lex_node->token_name);
1590 free(current_lex_node);
1591 free(current_chain_node);
1592 current_chain_node=first_chain_head;
1593 current_lex_node=current_chain_node->current_first_token;
1594 }
1595 else
1596 {
1597 printf("delimit needed after decl\n");
1598 exit();
1599 }
1600 }
1601 break;
1602 case 's'://结构体
1603 first_chain_head=first_chain_head->next;
1604 free(current_lex_node->token_name);
1605 free(current_lex_node);
1606 free(current_chain_node);
1607 current_chain_node=first_chain_head;
1608 current_lex_node=current_chain_node->current_first_token;
1609 temp_type_desc=search_avl_tree(current_lex_node->token_name);
1610 if(temp_type_desc==NULL)
1611 {
1612 printf(" invalid type_name %s is encounted \n",current_lex_node->token_name);
1613 exit();
1614 }
1615 else
1616 {
1617 if(temp_type_desc->type_type!=2)
1618 {
1619 printf("the typename %s is not struct \n",current_lex_node->token_name);
1620 exit();
1621 }
1622 }
1623 //至此参数检查完成
1624 return_var_node=malloc(sizeof(struct _var_hash_node));
1625 return_var_node->var_type=temp_type_desc;
1626 return_var_node->array_layer=NULL;
1627 return_var_node->pointer_layer=0;
1628 first_chain_head=first_chain_head->next;
1629 free(current_lex_node->token_name);
1630 free(current_lex_node);
1631 free(current_chain_node);
1632 current_chain_node=first_chain_head;
1633 current_lex_node=current_chain_node->current_first_token;
1634 while(*(current_lex_node->token_name)=='*')//处理指针
1635 {
1636 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
1637 first_chain_head=first_chain_head->next;
1638 free(current_lex_node->token_name);
1639 free(current_lex_node);
1640 free(current_chain_node);
1641 current_chain_node=first_chain_head;
1642 current_lex_node=current_chain_node->current_first_token;
1643 }
1644 //现在开始来处理名字
1645 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
1646 {
1647 printf("unexpected %s as var_name\n",current_lex_node->token_name);
1648 exit();
1649 }
1650 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
1651 //返回之后再去考虑
1652 {
1653 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
1654 {
1655 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
1656 exit();
1657 }
1658 //名称检查已经完成，现在来处理数组
1659 return_var_node->var_name=current_lex_node->token_name;
1660 first_chain_head=first_chain_head->next;
1661 free(current_lex_node);
1662 free(current_chain_node);
1663 current_chain_node=first_chain_head;
1664 current_lex_node=current_chain_node->current_first_token;
1665 while(*(current_lex_node->token_name)=='[')//处理指针
1666 {
1667 first_chain_head=first_chain_head->next;
1668 free(current_lex_node->token_name);
1669 free(current_lex_node);
1670 free(current_chain_node);
1671 current_chain_node=first_chain_head;
1672 current_lex_node=current_chain_node->current_first_token;
1673 //处理数组索引
1674 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1675 {
1676 printf("need constant in array decl\n");
1677 exit();
1678 }
1679 else//检查是不是整数
1680 {
1681 if(check_constant_type(current_lex_node->token_name))
1682 {
1683 printf("need integer in array decl\n");
1684 exit();
1685 }
1686 else
1687 {
1688 temp_array_desc=malloc(sizeof(struct _array_description));
1689 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1690 temp_array_desc->next=return_var_node->array_layer;
1691 return_var_node->array_layer=temp_array_desc;
1692 }
1693 }
1694 first_chain_head=first_chain_head->next;
1695 free(current_lex_node->token_name);
1696 free(current_lex_node);
1697 free(current_chain_node);
1698 current_chain_node=first_chain_head;
1699 current_lex_node=current_chain_node->current_first_token;
1700 if(*(current_lex_node->token_name)!=']')
1701 {
1702 printf("need ] while encount %s \n",current_lex_node->token_name);
1703 exit();
1704 }
1705 else
1706 {
1707 first_chain_head=first_chain_head->next;
1708 free(current_lex_node->token_name);
1709 free(current_lex_node);
1710 free(current_chain_node);
1711 current_chain_node=first_chain_head;
1712 current_lex_node=current_chain_node->current_first_token;
1713 }
1714 }
1715 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1716 {
1717 first_chain_head=first_chain_head->next;
1718 free(current_lex_node->token_name);
1719 free(current_lex_node);
1720 free(current_chain_node);
1721 current_chain_node=first_chain_head;
1722 current_lex_node=current_chain_node->current_first_token;
1723 }
1724 else
1725 {
1726 printf("delimit needed after decl\n");
1727 exit();
1728 }
1729 }
1730 break;
1731 case 'u':
1732 if(*(current_lex_node->token_name+2)=='s')//代表的是无符号数
1733 {
1734 return_var_node=malloc(sizeof(struct _var_hash_node));
1735 return_var_node->var_type=temp_type_desc;
1736 return_var_node->array_layer=NULL;
1737 return_var_node->pointer_layer=0;
1738 first_chain_head=first_chain_head->next;
1739 free(current_lex_node->token_name);
1740 free(current_lex_node);
1741 free(current_chain_node);
1742 current_chain_node=first_chain_head;
1743 current_lex_node=current_chain_node->current_first_token;
1744 while(*(current_lex_node->token_name)=='*')//处理指针
1745 {
1746 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
1747 first_chain_head=first_chain_head->next;
1748 free(current_lex_node->token_name);
1749 free(current_lex_node);
1750 free(current_chain_node);
1751 current_chain_node=first_chain_head;
1752 current_lex_node=current_chain_node->current_first_token;
1753 }
1754 //现在开始来处理名字
1755 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
1756 {
1757 printf("unexpected %s as var_name\n",current_lex_node->token_name);
1758 exit();
1759 }
1760 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
1761 //返回之后再去考虑
1762 {
1763 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
1764 {
1765 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
1766 exit();
1767 }
1768 //名称检查已经完成，现在来处理数组
1769 return_var_node->var_name=current_lex_node->token_name;
1770 first_chain_head=first_chain_head->next;
1771 free(current_lex_node);
1772 free(current_chain_node);
1773 current_chain_node=first_chain_head;
1774 current_lex_node=current_chain_node->current_first_token;
1775 while(*(current_lex_node->token_name)=='[')//处理指针
1776 {
1777 first_chain_head=first_chain_head->next;
1778 free(current_lex_node->token_name);
1779 free(current_lex_node);
1780 free(current_chain_node);
1781 current_chain_node=first_chain_head;
1782 current_lex_node=current_chain_node->current_first_token;
1783 //处理数组索引
1784 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1785 {
1786 printf("need constant in array decl\n");
1787 exit();
1788 }
1789 else//检查是不是整数
1790 {
1791 if(check_constant_type(current_lex_node->token_name))
1792 {
1793 printf("need integer in array decl\n");
1794 exit();
1795 }
1796 else
1797 {
1798 temp_array_desc=malloc(sizeof(struct _array_description));
1799 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1800 temp_array_desc->next=return_var_node->array_layer;
1801 return_var_node->array_layer=temp_array_desc;
1802 }
1803 }
1804 first_chain_head=first_chain_head->next;
1805 free(current_lex_node->token_name);
1806 free(current_lex_node);
1807 free(current_chain_node);
1808 current_chain_node=first_chain_head;
1809 current_lex_node=current_chain_node->current_first_token;
1810 if(*(current_lex_node->token_name)!=']')
1811 {
1812 printf("need ] while encount %s \n",current_lex_node->token_name);
1813 exit();
1814 }
1815 else
1816 {
1817 first_chain_head=first_chain_head->next;
1818 free(current_lex_node->token_name);
1819 free(current_lex_node);
1820 free(current_chain_node);
1821 current_chain_node=first_chain_head;
1822 current_lex_node=current_chain_node->current_first_token;
1823 }
1824 }
1825 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1826 {
1827 first_chain_head=first_chain_head->next;
1828 free(current_lex_node->token_name);
1829 free(current_lex_node);
1830 free(current_chain_node);
1831 current_chain_node=first_chain_head;
1832 current_lex_node=current_chain_node->current_first_token;
1833 }
1834 else
1835 {
1836 printf("delimit needed after decl\n");
1837 exit();
1838 }
1839 }
1840 }
1841 else
1842 {
1843 first_chain_head=first_chain_head->next;
1844 free(current_lex_node->token_name);
1845 free(current_lex_node);
1846 free(current_chain_node);
1847 current_chain_node=first_chain_head;
1848 current_lex_node=current_chain_node->current_first_token;
1849 temp_type_desc=search_avl_tree(current_lex_node->token_name);
1850 if(temp_type_desc==NULL)
1851 {
1852 printf(" invalid type_name %s is encounted \n",current_lex_node->token_name);
1853 exit();
1854 }
1855 else
1856 {
1857 if(temp_type_desc->type_type!=3)
1858 {
1859 printf("the typename %s is not union \n",current_lex_node->token_name);
1860 exit();
1861 }
1862 }
1863 //至此参数检查完成
1864 return_var_node=malloc(sizeof(struct _var_hash_node));
1865 return_var_node->var_type=temp_type_desc;
1866 return_var_node->array_layer=NULL;
1867 return_var_node->pointer_layer=0;
1868 first_chain_head=first_chain_head->next;
1869 free(current_lex_node->token_name);
1870 free(current_lex_node);
1871 free(current_chain_node);
1872 current_chain_node=first_chain_head;
1873 current_lex_node=current_chain_node->current_first_token;
1874 while(*(current_lex_node->token_name)=='*')//处理指针
1875 {
1876 return_var_node->pointer_layer=return_var_node->pointer_layer<<1+1;
1877 first_chain_head=first_chain_head->next;
1878 free(current_lex_node->token_name);
1879 free(current_lex_node);
1880 free(current_chain_node);
1881 current_chain_node=first_chain_head;
1882 current_lex_node=current_chain_node->current_first_token;
1883 }
1884 //现在开始来处理名字
1885 if(current_lex_node->current_lex_type!=name)//如果遇到的不是名字
1886 {
1887 printf("unexpected %s as var_name\n",current_lex_node->token_name);
1888 exit();
1889 }
1890 else//如果遇到的是名字，则需要考虑是否与类型重名了,这里我们就不去考虑变量重名了
1891 //返回之后再去考虑
1892 {
1893 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果与类型重名了
1894 {
1895 printf("var name %s is duplicated with type name\n",current_lex_node->token_name);
1896 exit();
1897 }
1898 //名称检查已经完成，现在来处理数组
1899 return_var_node->var_name=current_lex_node->token_name;
1900 first_chain_head=first_chain_head->next;
1901 free(current_lex_node);
1902 free(current_chain_node);
1903 current_chain_node=first_chain_head;
1904 current_lex_node=current_chain_node->current_first_token;
1905 while(*(current_lex_node->token_name)=='[')//处理指针
1906 {
1907 first_chain_head=first_chain_head->next;
1908 free(current_lex_node->token_name);
1909 free(current_lex_node);
1910 free(current_chain_node);
1911 current_chain_node=first_chain_head;
1912 current_lex_node=current_chain_node->current_first_token;
1913 //处理数组索引
1914 if(current_lex_node->current_lex_type!=constant)//检查是不是常量
1915 {
1916 printf("need constant in array decl\n");
1917 exit();
1918 }
1919 else//检查是不是整数
1920 {
1921 if(check_constant_type(current_lex_node->token_name))
1922 {
1923 printf("need integer in array decl\n");
1924 exit();
1925 }
1926 else
1927 {
1928 temp_array_desc=malloc(sizeof(struct _array_description));
1929 temp_array_desc->array_size=atoi(currrent_lex_node->token_name);
1930 temp_array_desc->next=return_var_node->array_layer;
1931 return_var_node->array_layer=temp_array_desc;
1932 }
1933 }
1934 first_chain_head=first_chain_head->next;
1935 free(current_lex_node->token_name);
1936 free(current_lex_node);
1937 free(current_chain_node);
1938 current_chain_node=first_chain_head;
1939 current_lex_node=current_chain_node->current_first_token;
1940 if(*(current_lex_node->token_name)!=']')
1941 {
1942 printf("need ] while encount %s \n",current_lex_node->token_name);
1943 exit();
1944 }
1945 else
1946 {
1947 first_chain_head=first_chain_head->next;
1948 free(current_lex_node->token_name);
1949 free(current_lex_node);
1950 free(current_chain_node);
1951 current_chain_node=first_chain_head;
1952 current_lex_node=current_chain_node->current_first_token;
1953 }
1954 }
1955 if(current_lex_node->current_lex_type==delimit)//吃掉分号
1956 {
1957 first_chain_head=first_chain_head->next;
1958 free(current_lex_node->token_name);
1959 free(current_lex_node);
1960 free(current_chain_node);
1961 current_chain_node=first_chain_head;
1962 current_lex_node=current_chain_node->current_first_token;
1963 }
1964 else
1965 {
1966 printf("delimit needed after decl\n");
1967 exit();
1968 }
1969 }
1970 }
1971 break;
1972 default:
1973 printf("unexpected decl_head %s is encounted \n",current_lex_node->token_name);
1974 exit();
1975 break;
1976 }
1977 temp_list_node=malloc(sizeof(struct var_decl_link));
1978 temp_list_node->current_var_node=return_var_node;
1979 temp_list_node->next=NULL;
1980 if(return_list_head==NULL)
1981 {
1982 return_list_rear=return_list_head=temp_list_node;
1983 }
1984 else
1985 {
1986 return_list_rear->next=temp_list_node;
1987 return_list_rear=temp_list_node;
1988 }
1989
1990 }
1991 //吃掉括号
1992 first_chain_head=first_chain_head->next;
1993 current_lex_node=current_chain_node->current_first_token;
1994 free(current_lex_node->token_name);
1995 free(current_lex_node);
1996 free(current_chain_node);
1997 current_chain_node=first_chain_head;
1998 current_lex_node=current_chain_node->current_first_token;
1999 //吃掉换行
2000 while(current_lex_node->current_lex_type==new_line)
2001 {
2002 first_chain_head=first_chain_head->next;
2003 current_lex_node=current_chain_node->current_first_token;
2004 free(current_lex_node->token_name);
2005 free(current_lex_node);
2006 free(current_chain_node);
2007 current_chain_node=first_chain_head;
2008 current_lex_node=current_chain_node->current_first_token;
2009 }
2010 return return_list_head;
2011 }
2012
2013
2014
2015 void tackle_type_name(struct type_decl_link** type_link_head)
2016 //这里我们要求这个函数被调用的时候已经做过参数检查了
2017 //这里我们对于类型的插入是从头端插入的
2018 //这里我们会吃掉分号
2019 {
2020 //这个函数是用来处理结构体、联合体声明的
2021 struct first_token_chain* current_chain_node;
2022 struct first_token_chain* next_chain_node;
2023 struct first_lex_token* current_lex_node;
2024 struct first_lex_token* next_lex_node;
2025 struct _composition_list temp_com_list;//作为当前类型的产生体链表
2026 struct _type_description* result_type_desc;
2027 struct type_decl_link* return_decl_link;
2028 result_type_desc=malloc(sizeof(struct _type_description));
2029 current_chain_node=first_chain_head;
2030 current_lex_node=current_chain_node->current_first_token;
2031 if(*(current_lex_node->token_name)=='s')
2032 {
2033 result_type_desc->type_type=2;
2034 }
2035 else
2036 {
2037 result_type_desc->type_type=3;
2038 }
2039 first_chain_head=first_chain_head->next;
2040 free(current_lex_node->token_name);
2041 free(current_lex_node);
2042 free(current_chain_node);
2043 current_chain_node=first_chain_head;
2044 current_lex_node=current_chain_node->current_first_token;
2045 if(search_avl_tree(current_lex_node->token_name)!=NULL)//如果已经有重名的了，则报错
2046 {
2047 printf("duplicated type_name %s \n",current_lex_node->token_name);
2048 exit();
2049 }
2050 else
2051 {
2052 result_type_desc->name=current_lex_node->token_name;
2053 insert_avl_node(result_type_desc);
2054 //这里要先插入到avl符号表中，用来自引用的
2055 first_chain_head=first_chain_head->next;
2056 free(current_lex_node);
2057 free(current_chain_node);
2058 current_chain_node=first_chain_head;
2059 current_lex_node=current_chain_node->current_first_token;
2060 //吃掉换行
2061 while(current_lex_node->current_lex_type==new_line)
2062 {
2063 first_chain_head=first_chain_head->next;
2064 free(current_lex_node->token_name);
2065 free(current_lex_node);
2066 free(current_chain_node);
2067 current_chain_node=first_chain_head;
2068 current_lex_node=current_chain_node->current_first_token;
2069 }
2070 if(*(current_lex_node->token_name)!='{')
2071 {
2072 printf("missing { in struct decl\n");
2073 exit();
2074 }
2075 result_type_desc->current_gen_list=tackle_type_define(type_link_head);
2076 result_type_desc->function_zone=NULL;
2077 //吃掉分号
2078 current_chain_node=first_chain_head;
2079 current_lex_node=current_chain_node->current_first_token;
2080 if(*(current_lex_node->token_name)!=';')
2081 {
2082 printf(" missing ; after type decl\n");
2083 exit();
2084 }
2085 //扔掉分号
2086 first_chain_head=first_chain_head->next;
2087 free(current_lex_node->token_name);
2088 free(current_lex_node);
2089 free(current_chain_node);
2090 }
2091 return_decl_link=malloc(sizeof(struct type_decl_link));
2092 return_decl_link->current_type_node=result_type_desc;
2093 return_decl_link->next=(*type_link_head);
2094 (*type_link_head)=return_decl_link;
2095 }
2096
2097
2098 struct _handle_tree_node* tackle_action()
2099 struct function_description* tackle_code_scope(void)
2100 {
2101 struct first_token_chain* current_chain_node;
2102 struct first_token_chain* next_chain_node;
2103 struct first_lex_token* current_lex_node;
2104 struct first_lex_token* next_lex_node;
2105 struct function_description* return_function;
2106 struct var_decl_link* current_scope_var;//代表当前代码域的变量链表
2107 struct type_decl_link* current_scope_type;//代表当前代码域的类型链表
2108 //这两个链表我们都采取在头部插入的方法
2109 struct _handle_tree_node* current_scope_action;//代表当前代码域的动作链表
2110 struct var_decl_link* temp_var_link;
2111 current_scope_var=current_scope_type=current_scope_action=NULL;
2112 current_chain_node=first_chain_head;
2113 current_lex_node=current_chain_node->current_first_token;
2114 first_chain_head=first_chain_head->next;
2115 free(current_lex_node->token_name);
2116 free(current_lex_node->current_lex_type);
2117 free(current_chain_node);
2118 current_chain_node=first_chain_head;
2119 current_lex_node=current_chain_node->current_first_token;
2120 //现在开始处理类型声明
2121 while((strcmp(current_lex_node->token_name,"union")==0)||(strcmp(current_lex_node->token_name,"struct")))
2122 {
2123 //这个while是用来处理复合结构的声明的
2124 next_chain_node=current_chain_node->next;
2125 if(next_chain_node==NULL)
2126 {
2127 printf("unexpected end of file\n");
2128 }
2129 next_chain_node=next_chain_node->next;
2130 if(next_chain_node->current_first_token->current_lex_type==new_line)//注意这里有一个换行符
2131 {
2132 tackle_type_name(¤t_scope_type);
2133 current_chain_node=first_chain_head;
2134 current_lex_node=current_chain_node->current_first_token;
2135 while(current_lex_node->current_lex_type==new_line)//吃掉之后的换行
2136 {
2137 first_chain_head=first_chain_head->next;
2138 free(current_lex_node->token_name);
2139 free(current_lex_node->current_lex_type);
2140 free(current_chain_node);
2141 current_chain_node=first_chain_head;
2142 current_lex_node=current_chain_node->current_first_token;
2143 }
2144 }
2145 else
2146 {
2147 break;//开始处理变量定义
2148 }
2149 }
2150 //现在开始处理变量定义
2151 while(search_avl_tree(current_lex_node->token_name)->type_type==4)
2152 {
2153 temp_var_link=malloc(sizeof(struct var_decl_link));
2154 temp_var_link->current_var_node=tackle_var_decl();
2155 temp_var_link->next=current_scope_var;
2156 current_scope_var=temp_var_link;
2157 //然后吃掉所有的换行
2158 current_chain_node=first_chain_head;
2159 current_lex_node=current_chain_node->current_first_token;
2160 while(current_lex_node->current_lex_type==new_line)//吃掉之后的换行
2161 {
2162 first_chain_head=first_chain_head->next;
2163 free(current_lex_node->token_name);
2164 free(current_lex_node->current_lex_type);
2165 free(current_chain_node);
2166 current_chain_node=first_chain_head;
2167 current_lex_node=current_chain_node->current_first_token;
2168 }
2169 }
2170 //现在开始处理动作列表
2171 current_scope_action=tackle_action();
2172 return_function=malloc(sizeof(struct function_description));
2173 return_function->current_action_link=current_scope_action;
2174 return_function->current_type_link=current_scope_type;
2175 return_function->current_var_link=current_scope_var;
2176 }
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
