minic 词法单元建立

 #include <stdio.h>
 #include "symbol_table_def.h"
 //前面的那个词法和文法说明只是大概的说明，现在又有了改动，把指针运算符改为了@,把取地址运算符改为了$
 //但是类型声明的时候的指针类型仍然是*
 //现在所有的符号都用了，除了让人恶心的逗号和问号
 //现在开始定义词法单元的枚举类型
 enum lex_type
 {
     name,//代表字符串，包括所有的关键字和变量声明
     delimit,//代表分号,以及大括号
     char_type,//代表字符
     an_operator,//代表操作符
     constant,//代表常量
     string_phrase,//代表字符串
     new_line//代表换行，因为在处理的时候换行是一个很重要的符号
 };
 enum basic_operator_type
 {
     array_op=,//代表数组分量运算
     parenthesis,//代表括号
     p_str_sub,//代表结构体指针分量运算
     str_sub,//代表结构体分量运算
     not,//代表!
     bit_rev,//代表~
     get_adr,//代表$
     get_mem,//代表@
     type_cast,//代表强制类型转换
     negative,//代表负号运算
     get_size,//代表sizeof
     multi,//代表乘法
     div,//代表除法
     module,//代表模
     add,//代表加法
     minus,//代表减法
     left_shift,//左移
     right_shift,//右移
     larger,//大于
     smaller,//小于
     lar_eqa,//大于等于
     sma_eqa,//小于等于
     equal,//等于
     nequal,//不等于
     bit_and,//&
     bit_xor,//^
     bit_or,//|
     and,//&&
     or// ||
 };

 struct first_lex_token
 {
     enum lex_type current_lex_type;//在第一遍处理的时候我们把所有的词素分为前面所说的六种
     char* token_name;
 };
 struct first_token_chain//这个链表将所有的词法单元串联起来
 {
     struct first_lex_token* current_first_token;
     struct first_token_chain* next;
 };
 struct first_token_chain* first_chain_head=NULL;//这里是所有节点的头节点
 struct first_token_chain* first_chain_tail=NULL;//这里是所有节点的末尾节点，为了插入用.
 //在第一趟处理的时候我们开两个2000个字节的缓冲区，用来读文件，并不断的切换
 //为了表明文件的结束，我们找来了我们的老朋友 '17' ，我们用这个字符来表示缓冲区的文件末尾
 char end_of_file=;
 char* buff_zone[];//这个代表两个缓冲区
 int buffer_pointer;//这个代表在缓冲区内的偏移
 int file_read_byte;//这个代表在读取文件到缓冲区的时候，读取了多少个字符
 int buff_zone_index;//代表使用的是那一个缓冲区
 char* current_buff;//这个代表当前的缓冲区
 int seek_begin(void )
 {
     //吃掉所有的空格和制表符
     while(buffer_pointer<)
     {
         switch(*(buffer_zone[buffer_zone_index]+buffer_pointer))
         {
         case :
             return -;//直接返回，文件已经处理完毕了
             break;
         case ' ':
             buffer_pointer++;
             break;
         case '\t':
             buffer_pointer++;
             break;
         default:
             break;
         }
     }
     if(buffer_pointer==)//越过缓冲区了
     {
         buffer_zone_index=-buffer_zone_index;//切换缓冲区
         current_buff=buff_zone[buff_zone_index];
         file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
         if(file_read_byte!=)//如果碰到文件的结束了
         {
             *(current_buff+file_read_byte)=;//标记为文件末尾
             //因为我们遇到的是字符文件，所以不会出现17这个字符
         }
         buffer_pointer=;
         //重新开始读取输入，这里我们默认制表符和空格符不会占用整个缓冲
         //吃掉所有的空格和制表符
         while(buffer_pointer<)
         {
             switch(buffer_zone[buffer_zone_index]+buffer_pointer)
             {
             case :
                 return -;//直接返回，文件已经处理完毕了
                 break;
             case ' ':
                 buffer_pointer++;
                 break;
             case '\t':
                 buffer_pointer++;
                 break;
             default:
                 break;
             }
         }
     }

     return ;//代表正常的返回
 }
 int lex_char_type(char current)//返回当前字符的前缀集
 {
     char test;
     test=current;
     if((test>='a'&&test<='z')||(test>='A'&&test<='Z')||(test=='_'))
     {
         return ;//代表名字
     }
     else
     {
         if(test>=''&&test<='')
         {
             return ;//数字
         }
         else
         {
             if(test==';'||test=='{'||test=='}')
             {
                 return ;//代表分隔符
             }
             else
             {
                 if(test=='\'')
                 {
                     return ;//代表字符
                 }
                 else
                 {
                     if(test=='\"')
                     {
                         return ;//代表字符串
                     }
                     else
                     {
                         return ;//代表运算符
                     }
                 }
             }
         }
     }
 }

 void first_procedure(FILE* input_file_name)
 {
     char* temp_name;//代表词法单元的内容
     int token_length;//代表读取的词法单元的长度
     int lex_mode;//代表开始字符所处的token种类
     int seek_return;
     char current_char;
     int for_i,for_j;
     struct first_lex_token* temp_token;
     struct first_token_chain token_chain_node;
     current_buff=malloc(sizeof(char)*);
     buff_zone[]=current_buff;
     buff_zone[]=current_buff+;
     //这里我们其实上把一个4000的缓冲区分裂为两个缓冲区了，这样可以让这两个缓冲区的空间连续
     file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
     if(file_read_byte!=)//如果碰到文件的结束了
     {
         *(current_buff+file_read_byte)=;//标记为文件末尾
         //因为我们遇到的是字符文件，所以不会出现17这个字符
     }
     buff_zone_index=;//首先使用第一个缓冲区
     buffer_pointer=;
     seek_return=seek_begin();
     while(seek_return!=-)//只要还没有到达末尾
     {
         current_char=*(buff_zone[buff_zone_index]+buffer_pointer);
         lex_mode=lex_char_type(current_char);
         switch(lex_mode)
         {
         case ://代表名字
             token_length=;
             while((current_char>='a'&&current_char<='z')||(current_char>='A'&&current_char<='Z')||current_char=='_')
             {
                 token_length++;
                 buffer_pointer++;
                 if(buffer_pointer==)
                 {
                     buff_zone_index=-buff_zone_index;
                     current_buff=buff_zone[buff_zone_index];
                     file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                     if(file_read_byte!=)//如果碰到文件的结束了
                     {
                         *(current_buff+file_read_byte)=;//标记为文件末尾
                         //因为我们遇到的是字符文件，所以不会出现17这个字符
                     }
                     buffer_pointer=;
                 }
                 current_char=current_buff[buffer_pointer];
             }
             temp_name=malloc(sizeof(char)*(token_length+));
             if(token_length<=buffer_pointer)
             {
                 for(for_i=;for_i<token_length;for_i++)
                 {
                     temp_name[for_i]=current_buff[buffer_pointer-token_length+for_i];
                 }
             }
             else
             {
                 current_buff=buff_zone[-buff_zone_index];
                 for_j=token_length-buffer_pointer;
                 for(for_i=;for_i<for_j;for_i++)
                 {
                     temp_name[for_i]=current_buff[-for_j+for_i];
                 }
                 current_buff=buff_zone[buff_zone_index];
                 for(for_i=;for_i<buffer_pointer;for_i++)
                 {
                     temp_name[for_j+for_i]=current_buff[for_i];
                 }
             }
             temp_name[token_length]='\0';
             temp_token=malloc(sizeof(struct first_lex_token));
             temp_token->token_name=temp_name;
             if(strcmp("sizeof",temp_name)==)
             {
                 temp_token->current_lex_type=an_operator;
             }
             else
             {
                 temp_token->current_lex_type=name;
             }
             break;
         case ://对应数字常量的情况
             token_length=;
             while((current_char>=''&&current_char<='')||(current_char>='A'&&current_char<='F')||\
                 (current_char>='a'&&current_char<='f')||current_char=='x'||current_char=='X'||current_char=='.')
             {
                 token_length++;
                 buffer_pointer++;
                 if(buffer_pointer==)
                 {
                     buff_zone_index=-buff_zone_index;
                     current_buff=buff_zone[buff_zone_index];
                     file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                     if(file_read_byte!=)//如果碰到文件的结束了
                     {
                         *(current_buff+file_read_byte)=;//标记为文件末尾
                         //因为我们遇到的是字符文件，所以不会出现17这个字符
                     }
                     buffer_pointer=;
                 }
                 current_char=current_buff[buffer_pointer];
             }
             temp_name=malloc(sizeof(char)*(token_length+));
             if(token_length<=buffer_pointer)
             {
                 for(for_i=;for_i<token_length;for_i++)
                 {
                     temp_name[for_i]=current_buff[buffer_pointer-token_length+for_i];
                 }
             }
             else
             {
                 current_buff=buff_zone[-buff_zone_index];
                 for_j=token_length-buffer_pointer;
                 for(for_i=;for_i<for_j;for_i++)
                 {
                     temp_name[for_i]=current_buff[-for_j+for_i];
                 }
                 current_buff=buff_zone[buff_zone_index];
                 for(for_i=;for_i<buffer_pointer;for_i++)
                 {
                     temp_name[for_j+for_i]=current_buff[for_i];
                 }
             }
             temp_name[token_length]='\0';
             temp_token=malloc(sizeof(struct first_lex_token));
             temp_token->token_name=temp_name;
             temp_token->current_lex_type=constant;
             break;
         case ://对应分隔符
             temp_name=malloc(sizeof(char)*);
             temp_name[]=current_buff[buffer_pointer];
             temp_name[]='\0';
             buffer_pointer++;
             if(buffer_pointer==)
             {
                 buff_zone_index=-buff_zone_index;
                 current_buff=buff_zone[buff_zone_index];
                 file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                 if(file_read_byte!=)//如果碰到文件的结束了
                 {
                     *(current_buff+file_read_byte)=;//标记为文件末尾
                     //因为我们遇到的是字符文件，所以不会出现17这个字符
                 }
                 buffer_pointer=;
             }
             current_char=current_buff[buffer_pointer];
             temp_token=malloc(sizeof(struct first_lex_token));
             temp_token->token_name=temp_name;
             temp_token->current_lex_type=delimit;
             break;
         case ://对应字符
             token_length=;
             buffer_pointer++;
             if(buffer_pointer==)
             {
                 buff_zone_index=-buff_zone_index;
                 current_buff=buff_zone[buff_zone_index];
                 file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                 if(file_read_byte!=)//如果碰到文件的结束了
                 {
                     *(current_buff+file_read_byte)=;//标记为文件末尾
                     //因为我们遇到的是字符文件，所以不会出现17这个字符
                 }
                 buffer_pointer=;
             }
             current_char=current_buff[buffer_pointer];
             while(current_char!='\'')
             {
                 token_length++;
                 buffer_pointer++;
                 if(buffer_pointer==)
                 {
                     buff_zone_index=-buff_zone_index;
                     current_buff=buff_zone[buff_zone_index];
                     file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                     if(file_read_byte!=)//如果碰到文件的结束了
                     {
                         *(current_buff+file_read_byte)=;//标记为文件末尾
                         //因为我们遇到的是字符文件，所以不会出现17这个字符
                     }
                     buffer_pointer=;
                 }
                 current_char=current_buff[buffer_pointer];
             }
             temp_name=malloc(sizeof(char)*(token_length));
             if(token_length<=buffer_pointer)
             {
                 for(for_i=;for_i<token_length;for_i++)
                 {
                     temp_name[for_i]=current_buff[buffer_pointer-token_length+for_i];
                 }
             }
             else
             {
                 current_buff=buff_zone[-buff_zone_index];
                 for_j=token_length-buffer_pointer;
                 for(for_i=;for_i<for_j;for_i++)
                 {
                     temp_name[for_i]=current_buff[-for_j+for_i];
                 }
                 current_buff=buff_zone[buff_zone_index];
                 for(for_i=;for_i<buffer_pointer;for_i++)
                 {
                     temp_name[for_j+for_i]=current_buff[for_i];
                 }
             }
             buffer_pointer++;
             if(buffer_pointer==)
             {
                 buff_zone_index=-buff_zone_index;
                 current_buff=buff_zone[buff_zone_index];
                 file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                 if(file_read_byte!=)//如果碰到文件的结束了
                 {
                     *(current_buff+file_read_byte)=;//标记为文件末尾
                     //因为我们遇到的是字符文件，所以不会出现17这个字符
                 }
                 buffer_pointer=;
             }
             temp_name[token_length-]='\0';
             if(temp_name[]=='\\')//处理转义字符
             {
                 switch(temp_name[])
                 {
                 case 'n':
                     temp_name[]='\n';
                     temp_name[]='\0';
                     break;
                 case 't':
                     temp_name[]='\t';
                     temp_name[]='\0';
                     break;
                 case '':
                     temp_name[]='\0';
                     break;
                 case '\\':
                     temp_name[]='\0';
                     break;
                 case '\'':
                     temp_name[]='\'';
                     temp_name[]='\0';
                     break;
                 case '\"':
                     temp_name[]='\"';
                     temp_name[]='\0';
                     break;
                 default:
                     break;
                 }
             }
             temp_token=malloc(sizeof(struct first_lex_token));
             temp_token->token_name=temp_name;
             temp_token->current_lex_type=constant;
             break;
         case ://代表字符串
             token_length=;
             buffer_pointer++;
             if(buffer_pointer==)
             {
                 buff_zone_index=-buff_zone_index;
                 current_buff=buff_zone[buff_zone_index];
                 file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                 if(file_read_byte!=)//如果碰到文件的结束了
                 {
                     *(current_buff+file_read_byte)=;//标记为文件末尾
                     //因为我们遇到的是字符文件，所以不会出现17这个字符
                 }
                 buffer_pointer=;
             }
             current_char=current_buff[buffer_pointer];
             while()
             {
                 while(current_char!='\"'）
                 {
                     token_length++;
                     buffer_pointer++;
                     if(buffer_pointer==)
                     {
                         buff_zone_index=-buff_zone_index;
                         current_buff=buff_zone[buff_zone_index];
                         file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                         if(file_read_byte!=)//如果碰到文件的结束了
                         {
                             *(current_buff+file_read_byte)=;//标记为文件末尾
                             //因为我们遇到的是字符文件，所以不会出现17这个字符
                         }
                         buffer_pointer=;
                     }
                     current_char=current_buff[buffer_pointer];
                 }
                 if(buffer_pointer==)//判断是否是字符串的结尾
                 {
                     if(*(buff_zone[-buff_zone_index]+)!='\\')
                     {
                         break;
                     }
                     else
                     {
                         token_length++;
                         buffer_pointer++;
                         //继续下次循环
                     }
                 }
                 else
                 {
                     if(current_buff[buffer_pointer-]!='\\')
                     {
                         break;
                     }
                     else
                     {
                         token_length++;
                         buffer_pointer++;
                         if(buffer_pointer==)
                         {
                             buff_zone_index=-buff_zone_index;
                             current_buff=buff_zone[buff_zone_index];
                             file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                             if(file_read_byte!=)//如果碰到文件的结束了
                             {
                                 *(current_buff+file_read_byte)=;//标记为文件末尾
                                 //因为我们遇到的是字符文件，所以不会出现17这个字符
                             }
                             buffer_pointer=;
                         }
                         current_char=current_buff[buffer_pointer];
                     }
                 }

             }
             temp_name=malloc(sizeof(char)*(token_length+));
             if(token_length<=buffer_pointer)
             {
                 for(for_i=;for_i<token_length;for_i++)
                 {
                     temp_name[for_i]=current_buff[buffer_pointer-token_length+for_i];
                 }
             }
             else
             {
                 current_buff=buff_zone[-buff_zone_index];
                 for_j=token_length-buffer_pointer;
                 for(for_i=;for_i<for_j;for_i++)
                 {
                     temp_name[for_i]=current_buff[-for_j+for_i];
                 }
                 current_buff=buff_zone[buff_zone_index];
                 for(for_i=;for_i<buffer_pointer;for_i++)
                 {
                     temp_name[for_j+for_i]=current_buff[for_i];
                 }
             }
             temp_name[token_length]='\0';
             buffer_pointer++;
             temp_token=malloc(sizeof(struct first_lex_token));
             temp_token->token_name=temp_name;
             temp_token->current_lex_type=string_phrase;
             break;
         case ://代表操作符
             temp_name=malloc(sizeof(char)*);
             temp_name[]=current_buff[buffer_pointer];
             temp_name[]='\0';
             buffer_pointer++;
             if(buffer_pointer==)
             {
                 buff_zone_index=-buff_zone_index;
                 current_buff=buff_zone[buff_zone_index];
                 file_read_byte=fread(current_buff,sizeof(char),,input_file_name);
                 if(file_read_byte!=)//如果碰到文件的结束了
                 {
                     *(current_buff+file_read_byte)=;//标记为文件末尾
                     //因为我们遇到的是字符文件，所以不会出现17这个字符
                 }
                 buffer_pointer=;
             }
             temp_token=malloc(sizeof(struct first_lex_token));
             temp_token->token_name=temp_name;
             temp_token->current_lex_type=an_operator;
             break;
         default:
             printf(" un_recognised type\n");
             break;
         }
         token_chain_node=malloc(sizeof(struct first_token_chain));
         token_chain_node->next=NULL;
         token_chain_node->current_first_token=temp_token;
         if(token_chain_tail==NULL)
         {
             token_chain_tail=token_chain_node;
             token_chain_head=token_chain_node;
         }
         else
         {
             token_chain_tail->next=token_chain_node;
             token_chain_tail=token_chain_node;
         }
         seek_return=seek_begin();
     }
 }