如何使用Struct创建带树的表达式解析器
我有一个我不明白的问题。我想创建一个表达式解析器。首先,我为解析器创建了一个树。就是这样如何使用Struct创建带树的表达式解析器,c,parsing,tree,expression,C,Parsing,Tree,Expression,我有一个我不明白的问题。我想创建一个表达式解析器。首先,我为解析器创建了一个树。就是这样 enum{ 整数、加号、减号、倍数、除数、字符串、字符 }; 结构树{ int操作; 结构树*左; 结构树*右; 字符*值; }; 结构树*生成节点(int操作,结构树*左,结构树*右,字符*值){ 结构树*n; n=(结构树*)malloc(sizeof(结构树)); 如果(n==NULL){ printf(“无法malloc\'make\'u node()\'\n”); } n->操作=操作; n->左
enum{
整数、加号、减号、倍数、除数、字符串、字符
};
结构树{
int操作;
结构树*左;
结构树*右;
字符*值;
};
结构树*生成节点(int操作,结构树*左,结构树*右,字符*值){
结构树*n;
n=(结构树*)malloc(sizeof(结构树));
如果(n==NULL){
printf(“无法malloc\'make\'u node()\'\n”);
}
n->操作=操作;
n->左=左;
n->右=右;
n->value=value;
返回n;
}
//打印排序器
整型打印\后序\数据(结构树*n){
如果(n==NULL){
返回0;
}
打印后订单数据(n->左);
打印后订单数据(n->右);
printf(“操作=>%d\t值=>%s\n”,n->操作,n->值);
}
内部主(空){
结构树*m;
//表达式为(2+3*5-8/3)
m=make_节点(加,空,空,空);
m->left=make_节点(减,空,空,空);
m->right=make_节点(整数,NULL,NULL,“2”);
m->left->left=make_节点(多,空,空,空);
m->left->right=make_节点(divis,NULL,NULL,NULL);
m->left->left->left=make_节点(整数,NULL,NULL,“3”);
m->left->left->right=make_节点(整数,NULL,NULL,“5”);
m->left->right->left=make_节点(整数,NULL,NULL,“8”);
m->left->right->right=make_节点(整数,NULL,NULL,“3”);
打印后订单数据(n);
返回0;
}
您可以看到,我已经为expression手动创建了树。表达为2+3*5-8/3
假设这个程序可以将2识别为一个数字,+识别为一个加号等等。我该如何为此编写解析器。也就是说,要创建如上所述的节点吗?你能告诉我这个的代码或伪代码吗
以下是更多信息
例如=>1+2*3
这棵树是,
+
/ \
/ \
* 1
/ \
/ \
2 3
1 + 2 * 3 => 1 + ( 2 * 3 )
所以我可以手动创建这样的树。
结构树*n;
n=make_节点(加,空,空,空);
n->left=make_节点(多,空,空,空);
n->right=make_节点(整数,NULL,NULL,“1”);
n->left->left=make_节点(整数,NULL,NULL,“2”);
n->left->right=make_节点(整数,NULL,NULL,“3”);
我试图创建一个这样的解析器
上瘾的_表达式(){
乘法_表达式()
而(1){
乘法_表达式()
....
}
}
乘法_表达式(){
主_表达式()
而(+| |*| |/){
主_表达式()
....
}
}
主_表达式(){
交换机(当前令牌){
大小写整数:
....
....
}
}
虽然我试图这样做,但我很难想出如何将树连接到它
编辑1
// This is the Source of Struct Tree
struct TREE {
int operation;
struct TREE *left;
struct TREE *right;
char *value;
} Tree;
struct TREE *create_new_node(int operation, struct TREE *left, struct TREE *right, char value[MAX_LENG]) {
struct TREE *n;
n = (struct TREE *) malloc (sizeof(struct TREE));
if(n == NULL) {
fatal("Unable to Malloc New Structure TREE in \'create_new_node()\' Function in tree.c File");
}
n -> operation = operation;
n -> left = left;
n -> right = right;
n -> value = value;
return n;
}
// This is the Source of Parser
int expression(void) {
next_token(); // This Function will get the next Token
addictive_expression();
}
int addictive_expression(void) {
int token_type;
multiplicative_expression();
token_type = Token.current_token; // Token.current_token is the Current Token
if(token_type == END_FILE) {
return 0;
}
while(1) {
next_token();
multiplicative_expression();
token_type = Token.current_token;
if(token_type == END_FILE) { // End File is a Enum
return 0;
}
}
return 0;
}
int multiplicative_expression(void) {
int token_type;
primary_expression();
token_type = Token.current_token;
if(token_type == END_FILE) {
return 0;
}
// O_MLTI, O_DIVS. O_MUDL are the tokens ( Enum )
while(token_type == O_MLTI || token_type == O_DIVS || token_type == O_MUDL) {
next_token();
primary_expression();
token_type = Token.current_token;
if(token_type == END_FILE) {
return 0;
}
}
return 0;
}
int primary_expression(void) {
switch(Token.current_token) {
case INTEGER:
next_token();
break;
case O_PLUS:
case O_MNUS:
case O_MLTI:
case O_DIVS:
case O_MUDL:
next_token();
break;
default:
error_d("Syntax Error in Primary Expression", Token.current_token); // Custom Error Message
break;
}
return 0;
}
/*
struct Tree *m;
m = make_node(plus, NULL, NULL, NULL);
m -> left = make_node(minus, NULL, NULL, NULL);
m -> right = make_node(integer, NULL, NULL, "2");
m -> left -> left = make_node(multi, NULL, NULL, NULL);
m -> left -> right = make_node(divis, NULL, NULL, NULL);
m -> left -> left -> left = make_node(integer, NULL, NULL, "3");
m -> left -> left -> right = make_node(integer, NULL, NULL, "5");
m -> left -> right -> left = make_node(integer, NULL, NULL, "8");
m -> left -> right -> right = make_node(integer, NULL, NULL, "3");
*/
我很难弄清楚如何将树连接到它。你能给我一个解决方案吗?语法的非终结符是由函数实现的,这些函数本身返回一个子表达式,在你的例子中是由
结构树*
表示的
这允许在递归调用时构造树
所以基本上你的上瘾的表达应该是这样的:
static struct Tree *addictive_expression() {
struct Tree *expr = multiplicative_expression();
while (token->type == OPERATOR && (token->op == PLUS || token->op == MINUS)) {
Operator op = token->op;
token = next_token();
struct Tree *expr2 = multiplicative_expression();
switch (op) {
case PLUS:
expr = create_new_node(OPERATOR, PLUS, expr, expr2, NULL);
break;
case MINUS:
expr = create_new_node(OPERATOR, MINUS, expr, expr2, NULL);
break;
}
}
return expr;
}
它是如何工作的:
它调用乘法表达式
,而乘法表达式又调用其他函数来获得表达式。在递归降序解析的简单形式中,每个优先级都有一个单独的函数。由于加号和减号是左关联运算符,因此它们在循环中处理。如果存在具有相同优先级的连续操作,则在创建新节点时,将前一个节点设置为左表达式
为了更好地理解,我在这里添加了一个带有加号和减号的switch语句,但正如您所看到的,您可以将其简化为:
static struct Tree *multiplicative_expression() {
struct Tree *expr = value_expression();
while (token->type == OPERATOR && (token->op == MULT || token->op == DIV)) {
Operator op = token->op;
token = next_token();
struct Tree *expr2 = value_expression();
expr = create_new_node(OPERATOR, op, expr, expr2, NULL);
}
return expr;
}
这里只使用操作符创建一个新节点
数据结构
注:类型和运算符是分开的
typedef enum {
NONE,
END,
NUMERIC,
OPERATOR
} Type;
typedef enum {
INVALID,
PLUS,
MINUS,
MULT,
DIV
} Operator;
typedef struct {
Type type;
Operator op;
char *value;
} Token;
然后,树结构是:
struct Tree {
Type type;
Operator op;
struct Tree *left;
struct Tree *right;
char *value;
};
完整示例
因此,一个小而完整的示例,其中函数名基于问题中的示例代码段,可能看起来像这样,具有两个优先级:
*
和/
+
和-
这看起来像是正确的语法树 也许首先使用Lex/Flex和Yacc/Bison并查看他们的教程会更容易:DOr甚至从O'Reilly@AnttiHaapala非常感谢。但我不喜欢使用Flex、Bison或其他生成工具。对不起!我将把它包含在函数中:)我的意思是,如果您从未编写过解析器或词法分析器,那么您肯定应该首先尝试它们。。。这样一来,你就不会有太多的事情要先考虑了。。。然后,如果您觉得简单的表达式解析是一个相对简单且易于实现的算法,那么您可以将bison、flex生成的代码扔掉。要了解更详细的内容,您可能需要了解如何构建LR解析器或packrat解析器。非常感谢。你把答案解释得很清楚。
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "parser.h"
#include "lexer.h"
static Token *token;
static void fatal(char *msg) {
fprintf(stderr, "%s\n", msg);
exit(1);
}
static struct Tree *create_new_node(Type type,
Operator operation,
struct Tree *left,
struct Tree *right,
char *value) {
struct Tree *n = (struct Tree*) malloc(sizeof(struct Tree));
if (n == NULL) {
fatal("Unable to Malloc New Structure Tree in \'create_new_node()\' Function in tree.c File");
}
n->type = type;
n->op = operation;
n->left = left;
n->right = right;
n->value = value;
return n;
}
static struct Tree *value_expression() {
if (token->type == NUMERIC) {
struct Tree *result = create_new_node(NUMERIC, NONE, NULL, NULL, strdup(token->value));
token = next_token();
return result;
}
fatal("can't determine value for token");
}
static struct Tree *multiplicative_expression() {
struct Tree *expr = value_expression();
while (token->type == OPERATOR && (token->op == MULT || token->op == DIV)) {
Operator op = token->op;
token = next_token();
struct Tree *expr2 = value_expression();
expr = create_new_node(OPERATOR, op, expr, expr2, NULL);
}
return expr;
}
static struct Tree *addictive_expression() {
struct Tree *expr = multiplicative_expression();
while (token->type == OPERATOR && (token->op == PLUS || token->op == MINUS)) {
Operator op = token->op;
token = next_token();
struct Tree *expr2 = multiplicative_expression();
expr = create_new_node(OPERATOR, op, expr, expr2, NULL);
}
return expr;
}
struct Tree *expression() {
token = next_token();
struct Tree *expr = addictive_expression();
putback_token(token);
return expr;
}
#include <stdio.h>
#include <stdlib.h>
#include "lexer.h"
#include "parser.h"
void test_parser();
int main(void) {
test_parser();
return 0;
}
void print_expr(struct Tree *expr, int level) {
for(int i = 0; i < level; i++) {
printf(" | ");
}
switch(expr->type) {
case OPERATOR:
switch(expr->op) {
case INVALID:
fprintf(stderr, "invalid op\n");
exit(1);
case PLUS:
printf("+\n");
print_expr(expr->left, level + 1);
print_expr(expr->right, level + 1);
printf("\n");
break;
case MINUS:
printf("-\n");
print_expr(expr->left, level + 1);
print_expr(expr->right, level + 1);
printf("\n");
break;
case MULT:
printf("*\n");
print_expr(expr->left, level + 1);
print_expr(expr->right, level + 1);
printf("\n");
break;
case DIV:
printf("/\n");
print_expr(expr->left, level + 1);
print_expr(expr->right, level + 1);
printf("\n");
break;
}
break;
case NUMERIC:
printf("%s\n", expr->value);
break;
case NONE:
fprintf(stderr, "unexpected NONE\n");
exit(1);
case END:
fprintf(stderr, "unexpected END\n");
exit(1);
}
}
void test_parser() {
setup_lexer("../input.txt");
struct Tree *expr = expression();
print_expr(expr, 0);
}
-
| +
| | 2
| | *
| | | 3
| | | 5
| /
| | 8
| | 3