上周帮一个刚刚找到自己方向的好友做了一个编译原理的课程实验，要求是做一个词法分析器，具体要求如下：

对下述文法和单词表定义的语言设计编制一个语法分析器。

（1）单词符号及种别表

单词符号

种别编码

单词值

main

1

  

int

2

  

float

3

  

double

4

  

char

5

  

if

6

  

else

7

  

do

8

  

while

9

  

l(l|d)*

10

内部字符串

( +|-|ε ) dd*(.dd* | ε)( e ( +|-|ε ) dd*|ε)

20

二进制数值表示

=

21

  

+

22

  

-

23

  

*

24

  

/

25

  

(

26

  

)

27

  

{

28

  

}

29

  

,

30

  

;

31

  

>

32

  

>=

33

  

<

34

  

&lt;=

35

  

==

36

  

!=

37

  

（2）语法结构定义

&lt;表达式> ::= <项>{ +<项>|-<项>}

<项> ::= <因子>{*<因子>|/<因子>}

<因子> ::=ID|num|(<表达式>)

num::= ( +|-|ε ) 数字数字*(.数字数字* | ε)( e ( +|-|ε ) 数字数字*|ε)

ID::=字母(字母|数字)*

字母::=a|b|c…|z|A|B|C…|Z

数字::=0|1|2…|9

本来不是个很难的程序，但我还是写的较为复杂，有这方面心得的朋友可以和我联系，一起探讨一下吧～～～下面我把自己简陋的代码贴在下面：

  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3. #include <string.h> 
  4.  
  5. #define INVALUECHAR   '.'  //非法字符，用于给token赋初值 
  6. #define MAXCHARNUM    80   //接受字符串输入的长度 
  7. #define TOKENLENGTH   15   //词组的最大长度 
  8. #define RETABLENGTH   9    //关键字的个数 
  9. #define TRUE          0 
  10. #define FALSE         -1 
  11.  
  12. int  syn, sum = 0; 
  13. char token[TOKENLENGTH] = { '\0' }; //记录找到的词组 
  14. char *rwtab[RETABLENGTH] = { "main", "int", "float", "double", "char", "if", "else", "do", "while" }; //记录关键字 
  15.  
  16. int IsNumber(char num); //判断num是否为数字 
  17. int GetSum(int i); //求token前i个数的加权和 
  18. int HoldE(int *local, char *string, int num, int *i); //读取浮点数时进行遇到符号e的操作 
  19. int NumberOP(int *local, char *string, int num, int *i, char c); //读取浮点数时进行遇到非数字字符的操作 
  20. int Analyze(char *string, int num); //搜寻最长字串的函数 
  21.  
  22.  
  23. int main() 
  24. { 
  25.     int p = 0, i, j; 
  26.     char string[MAXCHARNUM] = { '\0' }; 
  27.  
  28.     printf("please input a string:\n"); 
  29.     //读取输入的字符串，超过长度限定就让用户重新输入 
  30.     do { 
  31.         scanf("%c", &string[p++]); 
  32.         if (MAXCHARNUM <= p) { 
  33.             printf("\nYou have input more than 80 characters!\n"); 
  34.             printf("Please input again:\n"); 
  35.             string[0] = '\0'; 
  36.             p = 0; 
  37.         } 
  38.     }while ('\n' != string[p-1]); //字符串以'\n'结束 
  39.  
  40.     //遍历输入的字符串，忽略回车和空格 
  41.     for (i = 0; i < p; i++) { 
  42.         if ((' ' == string[i]) || ('\n' == string[i])) 
  43.             continue; 
  44.         else { 
  45.             j = Analyze(string, i); //当出现错误时Analyze返回FALSE，正确时返回找到字串的最后一个字符的位置 
  46.             if (FALSE == j) { 
  47.                 printf("\nYour input is wrong!\n"); 
  48.                 return 1; 
  49.             } 
  50.             i = j; //将i赋值为查找到字串的最后一个字符的位置 
  51.  
  52.             switch (syn) { 
  53.                 //-1为出现非法字符，0为正常结束，11为整型数的sum输出 
  54.                 case -1: { printf("\nYou have input illegal characters!\nSo it ended!\n");  
  55.                            break; } 
  56.                 case 0: { break; } 
  57.                 case 20: { if (0 != sum) { 
  58.                                printf("( %-5d%15d )\n", syn, sum); 
  59.                                sum = 0; 
  60.                            } 
  61.                            else 
  62.                                printf("( %-5d%15s )\n", syn, token); 
  63.                            break; } 
  64.                 default: { printf("( %-5d%15s )\n", syn, token); 
  65.                            break; } 
  66.             } 
  67.         } 
  68.     } 
  69.     return 0; 
  70. } 
  71.  
  72. //判断num是否为数字 
  73. int IsNumber(char num) 
  74. { 
  75.    if (('0' <= num) && ('9' >= num)) 
  76.        return TRUE; 
  77.    else 
  78.        return FALSE; 
  79. } 
  80.  
  81. //求token前i个数字的加权和 
  82. int GetSum(int i) 
  83. { 
  84.     int sum, j; 
  85.     char a[TOKENLENGTH]; 
  86.     for (j = 0; j < i; j++) 
  87.         a[j] = token[j]; 
  88.     a[j] = '\0'; 
  89.     sum = atoi(a); 
  90.     return sum; 
  91. } 
  92.  
  93. //读取浮点数时遇到e的处理 
  94. int HoldE(int *local, char *string, int num, int *i) 
  95. { 
  96.     char ch = 'e'; 
  97.     token[(*i)++] = ch; 
  98.     ch = string[++num]; 
  99.     //e的后一位为数字 
  100.     if (TRUE == IsNumber(ch)) { 
  101.         token[(*i)++] = ch; 
  102.         ch = string[++num]; 
  103.         while (TRUE == IsNumber(ch)) { 
  104.             token[(*i)++] = ch; 
  105.             ch = string[++num]; 
  106.         } 
  107.         *local = num - 1; //改变string中下标需要指向的位置 
  108.         return TRUE; 
  109.     } 
  110.     //e的后一位为'+'或'-' 
  111.     else if (('+' == ch) || ('-' == ch)) { 
  112.         token[(*i)++] = ch; 
  113.         ch = string[++num]; 
  114.         if (TRUE != IsNumber(ch)) 
  115.             return FALSE; 
  116.         while (TRUE == IsNumber(ch)) { 
  117.             token[(*i)++] = ch; 
  118.             ch = string[++num]; 
  119.         } 
  120.         *local = num - 1; 
  121.         return TRUE; 
  122.     } 
  123.     //其他情况就出现错误 
  124.     else 
  125.         return FALSE; 
  126. } 
  127.  
  128. //读取浮点数时遇到第一个非数字的字符的处理 
  129. int NumberOP(int *local, char *string, int num, int *i, char c) 
  130. { 
  131.     int result = TRUE; 
  132.     char ch = c; 
  133.     //这个非数字字符为小数点 
  134.     if ('.' == ch) { 
  135.         token[(*i)++] = ch; 
  136.         ch = string[++num]; 
  137.         //小数点后一位如果不是数字就出现错误 
  138.         if (TRUE != IsNumber(ch)) 
  139.             return FALSE; 
  140.         while (TRUE == IsNumber(ch)) { 
  141.             token[(*i)++] = ch; 
  142.             ch = string[++num]; 
  143.         } 
  144.         //小数点之后一串数字过后遇到e 
  145.         if ('e' == ch) { 
  146.             result = HoldE(local, string, num, i); 
  147.             if (FALSE == result) 
  148.                 return FALSE; 
  149.         } 
  150.         else 
  151.             *local = num - 1; 
  152.     } 
  153.     //这个字符为e 
  154.     else if ('e' == ch) { 
  155.         result = HoldE(local, string, num, i); 
  156.         if (FALSE == result) 
  157.             return FALSE; 
  158.     } 
  159.     //其他情况就不用再读取了，直接修改local并返回 
  160.     else  
  161.         *local = num - 1; 
  162.     syn = 20; 
  163.     return TRUE; 
  164. } 
  165.  
  166. //查询最长字串 
  167. int Analyze(char *string, int num) 
  168. { 
  169.     int m, i = 0, local = num, n, flag = 0; 
  170.     int result = TRUE; 
  171.     char ch; 
  172.  
  173.     for (m = 0; m < TOKENLENGTH; m++) 
  174.         token[m++] = INVALUECHAR; 
  175.  
  176.     ch = string[num]; 
  177.     //第一种情况为字符 
  178.     if (((ch <= 'z') && (ch >= 'a')) || ((ch <= 'Z') && (ch >= 'A'))) {  
  179.         while(((ch <= 'z') && (ch >= 'a')) || (( ch <= 'Z') && (ch >= 'A')) || (TRUE == IsNumber(ch))) { 
  180.             token[i++] = ch; 
  181.             //token长度限定 
  182.             if (i >= (TOKENLENGTH - 1)) 
  183.                 return FALSE; 
  184.             else 
  185.                 ch = string[++num]; 
  186.         } 
  187.         local = num - 1; 
  188.         //syn预设为l（l | d）*的形式 
  189.         syn = 10; 
  190.         token[i] = '\0'; 
  191.         //遍历关键字数组，如果找到就修改syn并 
  192.         for (n = 0; n < RETABLENGTH; n++) 
  193.             if (0 == strcmp(token, rwtab[n])) { 
  194.                 syn = n + 1; 
  195.                 break; 
  196.             } 
  197.     } 
  198.     //第二种情况为遇到'+'、'-'或数字 
  199.     else if (('+' == ch) || ('-' == ch) || (TRUE == IsNumber(ch))) { 
  200.         token[i++] = ch; 
  201.         //如果为数字就用flag标记一下 
  202.         if (TRUE == IsNumber(ch)) 
  203.             flag = 1; 
  204.         ch = string[++num]; 
  205.         //下一位也为数字 
  206.         if (TRUE == IsNumber(ch)) { 
  207.             token[i++] = ch; 
  208.             ch = string[++num]; 
  209.             while (TRUE == IsNumber(ch)) { 
  210.                 token[i++] = ch; 
  211.                 ch = string[++num]; 
  212.             } 
  213.             //遇到第一个 
  214.             result = NumberOP(&local, string, num, &i, ch); 
  215.             if (FALSE == result) 
  216.                 return FALSE; 
  217.         } 
  218.         //下一位不为数字要分情况，当第一位为数字时执行下列操作， 
  219.         //第一位为'+'、'-'时，下一位必须为数字 
  220.         else if (1 == flag) { 
  221.             result = NumberOP(&local, string, num, &i, ch); 
  222.             if (FALSE == result) 
  223.                 return FALSE;        
  224.         } 
  225.         //当第一位为'+'、'-'时，下一位不为数字证明'+'、'-'已经是最长的字串了 
  226.         else { 
  227.             if ('+' == token[i-1]) 
  228.                 syn = 22; 
  229.             else 
  230.                 syn = 23; 
  231.         } 
  232.     } 
  233.     else { 
  234.         switch (ch) { 
  235.             case '=': { token[i++] = ch; 
  236.                         ch = string[++num]; 
  237.                         if ('=' == ch) { 
  238.                             syn = 36; 
  239.                             token[i++] = ch; 
  240.                             local = num; 
  241.                             break; 
  242.                         } 
  243.                         syn = 21; 
  244.                         break; } 
  245.             case '*': { syn = 24; 
  246.                         token[i++] = ch; 
  247.                         break; } 
  248.             case '/': { syn = 25; 
  249.                         token[i++] = ch; 
  250.                         break; } 
  251.             case '(': { syn = 26; 
  252.                         token[i++] = ch; 
  253.                         break; } 
  254.             case ')': { syn = 27; 
  255.                         token[i++] = ch; 
  256.                         break; } 
  257.             case '{': { syn = 28; 
  258.                         token[i++] = ch; 
  259.                         break; } 
  260.             case '}': { syn = 29; 
  261.                         token[i++] = ch; 
  262.                         break; } 
  263.             case ',': { syn = 30; 
  264.                         token[i++] = ch; 
  265.                         break; } 
  266.             case ';': { syn = 31; 
  267.                         token[i++] = ch; 
  268.                         break; } 
  269.             case '>': { token[i++] = ch; 
  270.                         ch = string[++num]; 
  271.                         if ('=' == ch) { 
  272.                             syn = 33; 
  273.                             token[i++] = ch; 
  274.                             local = num; 
  275.                             break; 
  276.                         } 
  277.                         syn = 32; 
  278.                         break; } 
  279.             case '<': { token[i++] = ch; 
  280.                         ch = string[++num]; 
  281.                         if ('=' == ch) { 
  282.                             syn = 35; 
  283.                             token[i++] = ch; 
  284.                             local = num; 
  285.                             break; 
  286.                         } 
  287.                         syn = 34; 
  288.                         break; } 
  289.             case '!': { token[i++] = ch; 
  290.                         ch = string[++num]; 
  291.                         if ('=' != ch) { 
  292.                             return FALSE; 
  293.                         } 
  294.                         syn = 37; 
  295.                         token[i++] = ch; 
  296.                         local = num; 
  297.                         break; } 
  298.             case '\n': { syn = 0; 
  299.                          token[i++] = ch; 
  300.                          break; } 
  301.             default: { syn = -1; 
  302.                        break; } 
  303.         } 
  304.     } 
  305.     token[i] = '\0'; 
  306.     return local; 
  307. }