算术表达式解析（第三版）词法分析版

　　以前写过两版算术表达式解析代码，但都是基于栈结构或者树模型的，并不是通用的算法。其实算术表达式解析是最基本的词法分析算法，直到我看了《自制编程语言》里面介绍的递归向下分析法，才明白这种问题的终极解决方案是使用词法分析和语法分析。。

//用于词法定界的头文件 token.h
 1 #ifndef _TOKEN_H_VERSION_20140930
 2 #define _TOKEN_H_VERSION_20140930
 3 
 4 enum TokenKind{
 5     BAD_TOKEN,
 6     NUMBER_TOKEN,
 7     ADD_OPERATOR_TOKEN,
 8     SUB_OPERATOR_TOKEN,
 9     MUL_OPERATOR_TOKEN,
10     DIV_OPERATOR_TOKEN,
11     LEFT_PAREN_TOKEN,
12     RIGHT_PAREN_TOKEN,
13     END_OF_LINE_TOKEN,
14 };
15 
16 #define MAX_TOKEN_SIZE (100)
17 
18 struct Token{
19     TokenKind kind;
20     double value;
21     char str[MAX_TOKEN_SIZE];
22 };
23 
24 void set_line(char* line);
25 void get_token(Token* token);
26 
27 #endif

 

 //词法分析器或者叫单词收割机 lexianalizer.cpp
  1 #include "stdafx.h"
  2 #include "token.h"
  3 #include "stdio.h"
  4 #include "stdlib.h"
  5 #include "ctype.h"
  6 
  7 static char* st_line;
  8 static int st_line_pos;
  9 
 10 typedef enum{
 11     INITIAL_STATUS,
 12     IN_INT_PART_STATUS,
 13     DOT_STATUS,
 14     IN_FRAC_PART_STATUS,
 15 }LexerStatus;
 16 
 17 //只是为了获取一个token，里面的循环是忽略空格和读取数字用的
 18 void get_token(Token* token)
 19 {
 20     int out_pos = 0;
 21     LexerStatus status = INITIAL_STATUS;
 22     char current_char;
 23     
 24     token->kind = BAD_TOKEN;
 25     while(st_line[st_line_pos] != '\0')
 26     {
 27         current_char = st_line[st_line_pos];
 28         //读取数字
 29         if((status == IN_INT_PART_STATUS || status == IN_FRAC_PART_STATUS)
 30             && !isdigit(current_char) && current_char != '.')
 31         {
 32             token->kind = NUMBER_TOKEN;
 33             sscanf_s(token->str, "%lf", &token->value);
 34             return;
 35         }
 36         //忽略空格
 37         if(isspace(current_char))
 38         {
 39             if(current_char == '\n')
 40             {
 41                 token->kind = END_OF_LINE_TOKEN;
 42                 return;
 43             }
 44             st_line_pos++;
 45             continue;
 46         }
 47         //token太长错误
 48         if(out_pos >= MAX_TOKEN_SIZE-1){
 49             fprintf(stderr, "token too long\n");
 50             exit(1);
 51         }
 52         //token收下这个char
 53         token->str[out_pos] = st_line[st_line_pos];
 54         st_line_pos++;
 55         out_pos++;
 56         token->str[out_pos] = '\0';
 57 
 58         //根据这个char判断token的kind
 59         if(current_char == '+'){
 60             token->kind = ADD_OPERATOR_TOKEN;
 61             return;
 62         }
 63         if(current_char == '-'){
 64             token->kind = SUB_OPERATOR_TOKEN;
 65             return;
 66         }
 67         if(current_char == '*'){
 68             token->kind = MUL_OPERATOR_TOKEN;
 69             return;
 70         }
 71         if(current_char == '/'){
 72             token->kind = DIV_OPERATOR_TOKEN;
 73             return;
 74         }
 75         if(current_char == '('){
 76             token->kind = LEFT_PAREN_TOKEN;
 77             return;
 78         }
 79         if(current_char == ')')
 80         {
 81             token->kind = RIGHT_PAREN_TOKEN;
 82             return;
 83         }
 84         if(isdigit(current_char)){
 85             if(status == INITIAL_STATUS)
 86             {
 87                 status = IN_INT_PART_STATUS;
 88             }else if(status == DOT_STATUS)
 89             {
 90                 status = IN_FRAC_PART_STATUS;
 91             }
 92         }else if(current_char == '.')
 93         {
 94             if(status == IN_INT_PART_STATUS){
 95                 status = DOT_STATUS;
 96             }else{
 97                 fprintf(stderr, "syntax error\n");
 98                 exit(1);
 99             }
100         }else{
101             fprintf(stderr, "bad character(%c)\n", current_char);
102             exit(1);
103         }
104     }
105 }
106 
107 
108 void set_line(char* line)
109 {
110     st_line = line;
111     st_line_pos = 0;
112 }
113 
114 void parse_line(char* buf)
115 {
116     Token token;
117     set_line(buf);
118     for(;;)
119     {
120         get_token(&token);
121         if(token.kind == END_OF_LINE_TOKEN){
122             break;
123         }else{
124             printf("kind %d, str %s\n", token.kind, token.str);
125         }
126     }
127 }

 

  //递归向下的语法分析器 parser.cpp
  1 #include "stdafx.h"
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include "token.h"
  5 
  6 #define LINE_BUFF_SIZE (1024)
  7 
  8 static Token st_look_ahead_token;
  9 static int st_look_ahead_token_exists;
 10 
 11 //可以重复利用已经get的token（get_token本来就只能一直向下读）
 12 static void my_get_token(Token* token)
 13 {
 14     if(st_look_ahead_token_exists)
 15     {
 16         *token = st_look_ahead_token;
 17         st_look_ahead_token_exists=0;
 18     }else{
 19         get_token(token);
 20     }
 21 }
 22 
 23 //归还预读的token放到全局变量
 24 static void unget_token(Token* token)
 25 {
 26     st_look_ahead_token = *token;
 27     st_look_ahead_token_exists = 1;
 28 }
 29 double parse_expression();
 30 //解析一元表达式，token必须是数字
 31 static double parse_primary_expressioin()
 32 {
 33     double value;
 34     Token token;
 35     int minus_flag = 0;
 36 
 37     my_get_token(&token);
 38     if(token.kind == SUB_OPERATOR_TOKEN)
 39     {
 40         minus_flag = 1;
 41     }
 42     if(token.kind == NUMBER_TOKEN)
 43     {
 44         value =  token.value;
 45     }else if(token.kind == LEFT_PAREN_TOKEN)
 46     {
 47         value = parse_expression();
 48         my_get_token(&token);
 49         if(token.kind != RIGHT_PAREN_TOKEN)
 50         {
 51             fprintf(stderr, "missing ')' error\n");
 52             exit(1);
 53         }
 54     }else{
 55         unget_token(&token);
 56         fprintf(stderr, "syntax error\n");
 57         exit(1);
 58         return 0.0;
 59 
 60     }
 61     if(minus_flag == 1)
 62     {
 63         value = -value;
 64     }
 65     return value;
 66 
 67 }
 68 
 69 //解析乘除表达式，可以连续的乘除
 70 static double parse_term()
 71 {
 72     double v1,v2;
 73     Token token;
 74 
 75     v1 = parse_primary_expressioin();
 76     for(;;)
 77     {
 78         my_get_token(&token);
 79         if(token.kind != MUL_OPERATOR_TOKEN && token.kind != DIV_OPERATOR_TOKEN)
 80         {
 81             unget_token(&token);
 82             break;
 83         }
 84         v2 = parse_primary_expressioin();
 85         if(token.kind == MUL_OPERATOR_TOKEN)
 86         {
 87             v1 *= v2;
 88         }else if(token.kind == DIV_OPERATOR_TOKEN)
 89         {
 90             v1 /= v2;
 91         }
 92     }
 93     return v1;
 94 }
 95 
 96 //解析加减表达式，可以连续加减
 97 double parse_expression()
 98 {
 99     double v1,v2;
100     Token token;
101 
102     v1=parse_term();
103     for(;;)
104     {
105         my_get_token(&token);
106         if(token.kind != ADD_OPERATOR_TOKEN && token.kind != SUB_OPERATOR_TOKEN)
107         {
108             unget_token(&token);
109             break;
110         }
111 
112         v2 = parse_term();
113         if(token.kind == ADD_OPERATOR_TOKEN)
114         {
115             v1 += v2;
116         }else if(token.kind == SUB_OPERATOR_TOKEN)
117         {
118             v1 -= v2;
119         }
120         
121     }
122     return v1;
123 }
124 
125 double parse_line()
126 {
127     double value;
128     st_look_ahead_token_exists = 0;
129     value = parse_expression();
130     return value;
131 }
132 
133 
134 int _tmain(int argc, _TCHAR* argv[])
135 {
136     char line[LINE_BUFF_SIZE];
137     double value;
138 
139     printf("this is a LL(1) calc parser,version 1.0, copyright @ jwk.\n>");
140     while (fgets(line, LINE_BUFF_SIZE, stdin) != NULL)
141     {
142         set_line(line);
143         value = parse_line();
144         printf("%lf\n>", value);
145     }
146     return 0;
147 }

　　这么经典的算法，有空的时候我得画个图好好演示一下。

posted @ 2015-02-10 22:56  mjwk  阅读(642)  评论(0)  编辑  收藏  举报