码迷，mamicode.com
首页 > 其他好文 > 详细

Lex Yacc (四) 实际应用全代码

时间：2016-05-23 15:07:36      阅读：273      评论：0      收藏：0      [点我收藏+]

标签：

修改后的实际应用全代码 草木瓜（七） 精读 源代码有百度云存盘

  • 复杂的逻辑判断简化成程序判断语句，可便于应用的扩展和维护，也极大增强了代码的可读性。
  • 我们对整体文件划分如下：
  • tree.l
  • tree.y
  • parser.h #内部编译使用的头文件
  • parser.c #内部编译的主函数
  • compile.h #内外部交互的头文件
  • main.c #外部程序

修改说明

    1.将内部使用变量，函数，结构体和宏定义集中到parser.h
    2.将yyparser的输入进行重定义，见#undef YY_INPUT部分
    3.提供一个回调函数接口 extern void (* G_LoadVar)(char *, float *); /* 函数指针 */
    4.内部创建可供外部调用的函数接口，FormulaParser FormulaVarGet
    5.提供一个内外部交互的定义文件compile.h，暂时的内容只是保持数组大小一致性。
    6.外部程序通过输入文件进行编译处理
  • 这样在外部程序main.c，直接可以实现公式编译和变量访问控制。
  • 生成静态库文件：
  • bison -d tree.y
  • lex tree.l
  • gcc -g -c lex.yy.c tree.tab.c parser.c 有Waring，忽略之 -c 只编译不链接
  • ar -rl compile.a *.o
  • 使用静态库文件编译外部程序：
  • gcc -g -o lw main.c compile.a
  • 运行编译显示结果：
  • ./lw input
    1
    Ret:0
    i:1
  • 只要参数中有-c，总是生成目标文件.o；
  • 只要参数中无-c而只有-o，则总是生成执行文件。
  • ar 命令维护链接编辑器使用的索引库。ar 命令将一个或多个指定的文件并入单个写成 ar 压缩文档格式的压缩文档文件。当 ar 命令创建库时，它创建可传输格式的报头；当它创建或更新库时，它重建符号表。有关格式和索引压缩文档和符号表的结构的信息
  • 在企业的应用中，本示例提供的功能还略显浅薄，主要有如下一些缺点：
    1.目前仅支持浮点整型，不支持字符型
    2.不支持switch分支结构
    3.不支持return,break,goto,continue等跳转语句
  • 这些用目前的语法树也不是不能实现，不过语法树需要做大量的递归操作，在效率上存在一些问题。
  • 后面的系列文章中会逐渐引入堆栈来处理语法编译的问题，也可能会对现有的语法树做些优化。Lex和Yacc系列到现在都是在Linux下面说事，我们也不能忽略Windows下的情况。诸如此类，只有花时间慢慢琢磨了。

input内容：

i=i+1;print(i);

tree.l

%{
#include <stdlib.h>
#include "parser.h"
#include "tree.tab.h"
struct VarDefine G_Def[MAX_DEFS];             /* 存储的变量数组 */
char G_sBuff[MAX_BUFF_ROWS][MAX_BUFF_COLS];   /* 存储分析语句   */
int G_iBuffRowCount = 0;     /* 当前语句行数 */
int G_iBuffColCount = 0;     /* 当前语句列数 */
%}
/* 使用代变量表示任意字符 */
any .
%%
#{any}*[\n]  {
    add_buff(yytext);
    G_iBuffColCount = 0;
    G_iBuffRowCount++;
} /* 单行注释 */
[\n] {
    G_iBuffColCount = 0;
    G_iBuffRowCount++;
} /* 回车 */
"for"   {
    yylval.index = FOR - USER_DEF_NUM;
    G_Def[yylval.index].name = "for";
    add_buff(yytext);
    return FOR;
}
"while" {
    yylval.index = WHILE - USER_DEF_NUM;
    G_Def[yylval.index].name = "while";
    add_buff(yytext);
    return WHILE;
}
"if"    {
    yylval.index = IF - USER_DEF_NUM;
    G_Def[yylval.index].name = "if";
    add_buff(yytext);
    return IF;
}
"else"  {
    yylval.index = ELSE - USER_DEF_NUM;
    G_Def[yylval.index].name = "else";
    add_buff(yytext);
    return ELSE;
}
"print" {
    yylval.index = PRINT - USER_DEF_NUM ;
    G_Def[yylval.index].name = "print";
    add_buff(yytext);
    return PRINT;
}
[a-zA-Z][a-zA-Z0-9]* {
    add_var(yytext);
    yylval.index = G_iVarCurIndex;
    add_buff(yytext);
    return VARIABLE;
}
[0-9]+ {
    yylval.val = atof(yytext);
    add_buff(yytext);
    return NUMBER;
}
[0-9]*\.[0-9]+ {
    yylval.val = atof(yytext);
    add_buff(yytext);
    return NUMBER;
}
"++" { yylval.index = ADD_T - USER_DEF_NUM; G_Def[yylval.index].name = "++"; G_Def[yylval.index + 1].name = "++";  add_buff(yytext); return ADD_T; }
"--" { yylval.index = MUS_T - USER_DEF_NUM; G_Def[yylval.index].name = "--"; G_Def[yylval.index + 1].name = "++";  add_buff(yytext); return MUS_T; }
">=" { yylval.index = GE - USER_DEF_NUM;  G_Def[yylval.index].name = ">=";  add_buff(yytext); return GE;}
"<=" { yylval.index = LE - USER_DEF_NUM;  G_Def[yylval.index].name = "<=";  add_buff(yytext); return LE;}
"==" { yylval.index = EQ - USER_DEF_NUM;  G_Def[yylval.index].name = "==";  add_buff(yytext); return EQ;}
"!=" { yylval.index = NE - USER_DEF_NUM;  G_Def[yylval.index].name = "!=";  add_buff(yytext); return NE;}
"&&" { yylval.index = AND - USER_DEF_NUM; G_Def[yylval.index].name = "&&";  add_buff(yytext); return AND;}
"||" { yylval.index = OR - USER_DEF_NUM;  G_Def[yylval.index].name = "||";  add_buff(yytext); return OR; }
[()<>=+\-*/;{}.] {
    yylval.index = *yytext;  /* 存储运算符 */
    add_buff(yytext);
    return *yytext;
}
[\t]    { add_buff(yytext); } /* 去除TAB  */
[ ]     { add_buff(yytext); }  /* 去除空格 */
{any}   { printf("Ignore Unknow Symbol:[%s]\n", yytext); }
%%
void add_buff(char * buff) {
    strcat(G_sBuff[G_iBuffRowCount], buff);
    G_iBuffColCount = G_iBuffColCount + strlen(buff);
}
int yywrap(void) {
    return 1;
}

tree.y

%{
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "parser.h"
#include "compile.h"
int G_iVarMaxIndex = 0;  /* 变量最大个数 */
int G_iVarCurIndex = -1; /* 变量当前索引 */
struct VarIndex G_Var[MAX_VARS];  /* 变量内存数组 */
char G_sFormula[MAX_FORMULA_LEN];  /* 全局变量，存储公式内容 */
int  G_iFormulaPos = 0;                /* 全局变量，存储公式当前的处理位置 */
void (* G_LoadVar)(char *, float *);
%}
%union {
    float val; /* 变量值 */
    int index; /* 变量数组索引 */
    Node *node; /* 结点地址 */
};
%token <val> NUMBER
%token <index> VARIABLE
%token PRINT
%token FOR WHILE
%nonassoc IF
%nonassoc ELSE
%left AND OR
%left GE LE EQ NE ‘>‘ ‘<‘
%left ‘+‘ ‘-‘
%left ‘*‘ ‘/‘
%left ADD_T ADD_TT MUS_T MUS_TT
%nonassoc UMINUS
%type <node> stmt stmt_list expr_set expr_setself expr_comp expr
%%
program:
function {}
;
function:
function stmt { NodeExecute($2); NodeFree($2); }
| /* NULL */
;
stmt:
‘;‘                 {
    $$ = opr(‘;‘, 2, NULL, NULL); debug_vsp(yyval, ";", yyvsp, "0");
}
| expr_set ‘;‘      {
    $$ = $1; debug_vsp(yyval, "es;", yyvsp, "01");
}
| PRINT expr ‘;‘    {
    $$ = opr(PRINT, 1, $2); debug_vsp(yyval, "p(e);", yyvsp, "401");
}
| PRINT expr_set ‘;‘    {
    $$ = opr(PRINT, 1, $2); debug_vsp(yyval, "p(es);", yyvsp, "401");
}
| FOR ‘(‘ expr_set ‘;‘ expr_comp ‘;‘ expr_set ‘)‘ stmt {
    $$ = opr(FOR, 4, $3, $5, $7, $9); debug_vsp(yyval, "for(es;ec;es) st", yyvsp, "410101010");
}
| WHILE ‘(‘ expr_comp ‘)‘ stmt       {
    $$ = opr(WHILE, 2, $3, $5); debug_vsp(yyval, "while(ec) st", yyvsp, "41010");
}
| IF ‘(‘ expr_comp ‘)‘ stmt %prec IF {
    $$ = opr(IF, 2, $3, $5);    debug_vsp(yyval, "if(ec) st", yyvsp, "41010");
}
| IF ‘(‘ expr_comp ‘)‘ stmt ELSE stmt %prec ELSE       {
    $$ = opr(IF, 3, $3, $5, $7);      debug_vsp(yyval, "if(ec)else st", yyvsp, "4101040");
}
| ‘{‘ stmt_list ‘}‘ {
    $$ = $2; debug_vsp(yyval, "{stl}", yyvsp, "101");
}
;
stmt_list:
stmt                {
    $$ = $1;  debug_vsp(yyval, "st", yyvsp, "0");
}
| stmt_list stmt  {
    $$ = opr(‘;‘, 2, $1, $2); debug_vsp(yyval, "stl st", yyvsp, "00");
}
;
expr_set:
VARIABLE ‘=‘ expr {
    $$ = opr(‘=‘, 2, set_index($1), $3); debug_vsp(yyval, "v=e", yyvsp, "210");
}
| VARIABLE ‘=‘ expr_setself {
    $$ = opr(‘=‘, 2, set_index($1), $3); debug_vsp(yyval, "v=ess", yyvsp, "210");
}
| expr_setself
;
expr_setself:
ADD_T VARIABLE  {
    $$ = opr(ADD_T, 1, set_index($2));  debug_vsp(yyval, "++v", yyvsp, "42");
}
| MUS_T VARIABLE  {
    $$ = opr(MUS_T, 1, set_index($2));  debug_vsp(yyval, "--v", yyvsp, "42");
}
| VARIABLE ADD_T  {
    $$ = opr(ADD_TT, 1, set_index($1));  debug_vsp(yyval, "v++", yyvsp, "24");
}
| VARIABLE MUS_T  {
    $$ = opr(MUS_TT, 1, set_index($1));  debug_vsp(yyval, "v--", yyvsp, "24");
}
| ‘(‘ expr_setself ‘)‘ {
    $$ = $2; debug_vsp(yyval, "(ess)", yyvsp, "101");
}
;

expr_comp:
expr ‘<‘ expr   {
    $$ = opr(‘<‘, 2, $1, $3); debug_vsp(yyval, "e<e", yyvsp, "010");    }
| expr ‘>‘ expr   {
    $$ = opr(‘>‘, 2, $1, $3); debug_vsp(yyval, "e>e", yyvsp, "010");    }
| expr GE expr    {
    $$ = opr(GE, 2, $1, $3);  debug_vsp(yyval, "e>=e", yyvsp, "040");   }
| expr LE expr    {
    $$ = opr(LE, 2, $1, $3);  debug_vsp(yyval, "e<=e", yyvsp, "040");   }
| expr NE expr    {
    $$ = opr(NE, 2, $1, $3);  debug_vsp(yyval, "e!=e", yyvsp, "040");   }
| expr EQ expr    {
    $$ = opr(EQ, 2, $1, $3);  debug_vsp(yyval, "e==e", yyvsp, "040");   }
| expr_comp AND expr_comp {
    $$ = opr(AND, 2, $1, $3); debug_vsp(yyval, "ec&&ec", yyvsp, "040"); }
| expr_comp OR expr_comp  {
    $$ = opr(OR, 2, $1, $3);  debug_vsp(yyval, "ec||ec", yyvsp, "040"); }
| ‘(‘ expr_comp ‘)‘       {
    $$ = $2;                  debug_vsp(yyval, "(ec)", yyvsp, "101");
}
;
expr:
NUMBER            {
    $$ = set_content($1);      debug_vsp(yyval, "f", yyvsp, "3");
}
| VARIABLE        {
    $$ = set_index($1);        debug_vsp(yyval, "v", yyvsp, "2");
}
| ‘-‘ NUMBER %prec UMINUS {
    $$ = set_content(-$2);   debug_vsp(yyval, "-e", yyvsp, "13");
}
| expr ‘+‘ expr   {
    $$ = opr(‘+‘, 2, $1, $3);  debug_vsp(yyval, "e+e", yyvsp, "010");
}
| expr ‘-‘ expr   {
    $$ = opr(‘-‘, 2, $1, $3);  debug_vsp(yyval, "e-e", yyvsp, "010");
}
| expr ‘*‘ expr   {
    $$ = opr(‘*‘, 2, $1, $3);  debug_vsp(yyval, "e*e", yyvsp, "010");
}
| expr ‘/‘ expr   {
    $$ = opr(‘/‘, 2, $1, $3);  debug_vsp(yyval, "e/e", yyvsp, "010");
}
| ‘(‘ expr ‘)‘    {
    $$ = $2;                   debug_vsp(yyval, "(e)", yyvsp, "101");
}
;
%%
#define SIZE_OF_NODE ((char *)&p->content - (char *)p)
Node *set_content(float value) {
    Node *p;
    size_t sizeNode;
    /* 分配结点空间 */
    sizeNode = SIZE_OF_NODE + sizeof(float);
    if ((p = malloc(sizeNode)) == NULL)
        yyerror("out of memory");
    /* 复制内容 */
    p->type = TYPE_CONTENT;
    p->content = value;
    return p;

}
Node *set_index(int value) {
    Node *p;
    size_t sizeNode;
    /* 分配结点空间 */
    sizeNode = SIZE_OF_NODE + sizeof(int);
    if ((p = malloc(sizeNode)) == NULL)
        yyerror("out of memory");
    /* 复制内容 */
    p->type = TYPE_INDEX;
    p->index = value;
    return p;
}
Node *opr(int name, int num, ...) {
    va_list valist;
    Node *p;
    size_t sizeNode;
    int i;
    /* 分配结点空间 */
    sizeNode = SIZE_OF_NODE + sizeof(OpNode) + (num - 1) * sizeof(Node*);
    if ((p = malloc(sizeNode)) == NULL)
        yyerror("out of memory");
    /* 复制内容 */
    p->type = TYPE_OP;
    p->op.name = name;
    p->op.num = num;
    va_start(valist, num);
    for (i = 0; i < num; i++)
        p->op.node[i] = va_arg(valist, Node*);
    va_end(valist);
    return p;
}
/**/
void debug_vsp(YYSTYPE yval, char * info, YYSTYPE * vsp, char * mark) {
#ifdef PARSE_DEBUG
    printf("\n -RULE  0x%x  %s \n ", yval.node, info  );
    int i;
    int ilen = strlen(mark);
    for (i = 1 - ilen; i <= 0; i++) {
        switch (mark[ilen + i - 1]) {
        case ‘0‘:
            printf(" [ 0x%x ", vsp[i].node); //「」
            switch (vsp[i].node->type) {
            case TYPE_CONTENT:
                printf("%g ] ", vsp[i].node->content);
                break;
            case TYPE_INDEX:
                printf("%s ] ", G_Var[vsp[i].node->index].mark);
                break;
            case TYPE_OP:
                if (vsp[i].node->op.name < USER_DEF_NUM)
                    printf("%c ] ", vsp[i].node->op.name);
                else
                    printf("%s ] ", G_Def[vsp[i].node->op.name - USER_DEF_NUM].name);
                break;
            }
            break;
        case ‘1‘:
            printf(" %c ", vsp[i].index);  /* 打印运算符 */
            break;
        case ‘2‘:
            printf(" %s ", G_Var[vsp[i].index].mark);
            break;
        case ‘3‘:
            printf(" %g ", vsp[i].val);
            break;
        case ‘4‘:
            printf(" %s ", G_Def[vsp[i].index].name);
            break;
        }
    }
    printf("\n");
    print_stmt();
#endif
}
void add_var(char *mark) {
    if (G_iVarMaxIndex == 0) {
        strcpy(G_Var[0].mark, mark);
        G_iVarMaxIndex++;
        G_iVarCurIndex = 0;
        if (G_LoadVar != 0)
            G_LoadVar(mark, &G_Var[0].val);
        return;
    }
    int i;
    for (i = 0; i <= G_iVarMaxIndex - 1; i++) {
        if (strcmp(G_Var[i].mark, mark) == 0) {
            G_iVarCurIndex = i;
            return;
        }
    }
    strcpy(G_Var[G_iVarMaxIndex].mark, mark);
    G_iVarCurIndex = G_iVarMaxIndex;
    if (G_LoadVar != 0)
        G_LoadVar(mark, &G_Var[G_iVarCurIndex].val);
    G_iVarMaxIndex++;
}
void print_stmt() {
    printf(" -STMT: \n");
    /*
    int i;
    for(i=0;i<=G_iBuffRowCount;i++)
     printf("%s \n",G_sBuff[i]);
    */
    if (G_iBuffColCount == 0)
        printf("  %s \n", G_sBuff[G_iBuffRowCount - 1]);
    else
        printf("  %s \n", G_sBuff[G_iBuffRowCount]);
    printf("\n");
}
void NodeFree(Node *p) {
    int i;
    if (!p) return;
    if (p->type == TYPE_OP) {
        for (i = 0; i < p->op.num; i++)
            NodeFree(p->op.node[i]);
    }
    free (p);
}
int GetParserInput(char *buf, int maxlen) {
    int i;
    if (G_iFormulaPos >= strlen(G_sFormula))
        return 0;
    for (i = 0; i < maxlen && G_sFormula[G_iFormulaPos] != ‘\0‘; i++)
        buf[i] = G_sFormula[G_iFormulaPos++];
    return i;
}
void yyerror(char *s) {
    //fprintf(stdout, "%s\n", s);
    printf("<Parser Error> Line %d ,Col %d \n", G_iBuffRowCount + 1, G_iBuffColCount + 1);
    printf(" %s\n", G_sBuff[G_iBuffRowCount]);
}

parser.h #内部编译使用的头文件

#include "compile.h"
//------------------------------------------------------------
//lex yacc 定义的结构体
/* 定义树结点的权举类型 */
typedef enum { TYPE_CONTENT, TYPE_INDEX, TYPE_OP } NodeEnum;
/* 操作符 */
typedef struct {
    int name; /* 操作符名称 */
    int num; /* 操作元个数 */
    struct NodeTag * node[1]; /* 操作元地址 可扩展 */
} OpNode;
/* 树结点 */
typedef struct NodeTag {
    NodeEnum type; /* 树结点类型 */
    /* Union 必须是最后一个成员 */
    union {
        float content; /* 内容 */
        int index; /* 索引 */
        OpNode op; /* 操作符对象 */
    };
} Node;
/* 变量结构 */
struct VarIndex
{
    float val;
    char mark[10];
};
/* 系统保留字 */
struct VarDefine
{
    int index;
    char * name;
};
//------------------------------------------------------------
//lex yacc 宏定义
#undef YY_INPUT
#define YY_INPUT(buf, ret, maxlen) (ret = GetParserInput(buf, maxlen))
/* yystype */
typedef union {
    float val;  /* 变量值 */
    int index;  /* 用于存放 变量数组索引 或 一元操作符值 或 多元操作符索引 */
    Node *node; /* 结点地址 */
} yystype;
#define YYSTYPE yystype

#define USER_DEF_NUM 259 /* Yacc编译的保留字开始索引 */

#define MAX_VARS 100     /* 最多变量数 */
#define MAX_DEFS 20      /* 最多保留字数 */

#define MAX_BUFF_COLS 40   /* 分析语句最多行数 */
#define MAX_BUFF_ROWS 40   /* 分析语句每行最多字符数 */
/* 是否打印调试信息的开关 */
#define PARSE_DEBUG
//------------------------------------------------------------
//lex yacc 全局变量
extern struct VarIndex G_Var[MAX_VARS];  /* 存储的变量数组 */
extern struct VarDefine G_Def[MAX_DEFS]; /* 系统保留字变量 */

extern int G_iVarMaxIndex;   /* 变量目前总数 */
extern int G_iVarCurIndex;   /* 当前操作变量索引 */

extern char G_sBuff[MAX_BUFF_ROWS][MAX_BUFF_COLS];  /* 存储分析语句 */
extern int G_iBuffRowCount;  /* 当前语句行数 */
extern int G_iBuffColCount;  /* 当前语句列数 */

extern char G_sFormula[MAX_FORMULA_LEN];  /* 全局变量，存储公式内容 */
extern int  G_iFormulaPos;                /* 全局变量，存储公式当前的处理位置 */

extern void (* G_LoadVar)(char *, float *); /* 函数指针 */
//------------------------------------------------------------
//lex yacc 函数定义
void add_var(char *);  /* 在内存中添加变量 */
void add_buff(char *); /* 在内存中添加语句 */
/* 打印分析调试信息 */
void debug_vsp(YYSTYPE , char * , YYSTYPE *, char * );
void print_stmt();
/* 属性操作类型 */
Node *opr(int name, int num, ...);
Node *set_index(int value);
Node *set_content(float value);
/* 树结点操作 */
void NodeFree(Node *p);
float NodeExecute(Node *p);
void yyerror(char *);

parser.c #内部编译的主函数

#include <stdio.h>
#include "parser.h"
#include "tree.tab.h"
float NodeExecute(Node *p) {
    if (!p) return 0;
    switch (p->type) {
    case TYPE_CONTENT: return p->content;
    case TYPE_INDEX:   return G_Var[p->index].val;
    case TYPE_OP:
        switch (p->op.name) {
        case WHILE:  while (NodeExecute(p->op.node[0]))NodeExecute(p->op.node[1]);
            return 0;
        case FOR:    NodeExecute(p->op.node[0]);
            while (NodeExecute(p->op.node[1])) {
                NodeExecute(p->op.node[3]);
                NodeExecute(p->op.node[2]);
            }
            return 0;
        case IF:     if (NodeExecute(p->op.node[0]))
                NodeExecute(p->op.node[1]);
            else if (p->op.num > 2)
                NodeExecute(p->op.node[2]);
            return 0;
        case PRINT:  printf("%g\n", NodeExecute(p->op.node[0]));
            return 0;
        case ‘;‘:    NodeExecute(p->op.node[0]);
            return NodeExecute(p->op.node[1]);
        case ‘=‘:    return G_Var[p->op.node[0]->index].val = NodeExecute(p->op.node[1]);
        case UMINUS: return NodeExecute(p->op.node[0]);
        case ‘+‘:    return NodeExecute(p->op.node[0]) + NodeExecute(p->op.node[1]);
        case ‘-‘:    return NodeExecute(p->op.node[0]) - NodeExecute(p->op.node[1]);
        case ‘*‘:    return NodeExecute(p->op.node[0]) * NodeExecute(p->op.node[1]);
        case ‘/root/include‘:    return NodeExecute(p->op.node[0]) / NodeExecute(p->op.node[1]);
        case ‘<‘:    return NodeExecute(p->op.node[0]) < NodeExecute(p->op.node[1]);
        case ‘>‘:    return NodeExecute(p->op.node[0]) > NodeExecute(p->op.node[1]);
        case GE:     return NodeExecute(p->op.node[0]) >= NodeExecute(p->op.node[1]);
        case LE:     return NodeExecute(p->op.node[0]) <= NodeExecute(p->op.node[1]);
        case NE:     return NodeExecute(p->op.node[0]) != NodeExecute(p->op.node[1]);
        case EQ:     return NodeExecute(p->op.node[0]) == NodeExecute(p->op.node[1]);
        case AND:    return NodeExecute(p->op.node[0]) && NodeExecute(p->op.node[1]);
        case OR:     return NodeExecute(p->op.node[0]) || NodeExecute(p->op.node[1]);
        case ADD_T:  return ++G_Var[p->op.node[0]->index].val;
        case MUS_T:  return --G_Var[p->op.node[0]->index].val;
        case ADD_TT: return G_Var[p->op.node[0]->index].val++;
        case MUS_TT: return G_Var[p->op.node[0]->index].val--;
        }
    }
    return 0;
}
int FormulaVarGet(char * mark, float * val) {
    int i;
    for (i = 0; i <= G_iVarMaxIndex; i++)
        if (strcmp(mark, G_Var[i].mark) == 0) {
            *val = G_Var[i].val;
            return 0;
        }
    return 1;
}
int FormulaParser(char * cmd, void (* loadvar)(char *, float *)) {
    printf("hello4\n");
    G_iFormulaPos = 0;
    G_LoadVar = loadvar;
    strcpy(G_sFormula, cmd);
    return yyparse();
}

compile.h #内外部交互的头文件

#define MAX_FORMULA_LEN 350

main.c #外部程序

#include <stdio.h>
#include "compile.h"
void loadvar(char * mark, float * val) {
    if (strcmp(mark, "xxxx") == 0) {
        *val = 6;
        return;
    }
    if (strcmp(mark, "xxxx") == 0) {
        *val = 6.99789;
        return;
    }
}
int main(int argc, char *argv[]) {
    int iRet;
    /**/
    char sFile[MAX_FORMULA_LEN] = {0};
    FILE *fp;
    if (argc != 2) {
        printf("Error: command filename\n");
        exit(-1);
    }
    fp = fopen(argv[1], "r");
    if (fp == NULL) {
        printf("Error: Cannot open file\n");
        exit(-1);
    }
    fread(sFile, sizeof(char), MAX_FORMULA_LEN, fp);
    fclose(fp);
    printf("hello\n");
    iRet = FormulaParser(sFile, loadvar);
    printf("hello2\n");
    printf("\nRet:%d\n", iRet );
    float fVal;
    iRet = FormulaVarGet("i", &fVal);
    if (iRet == 0)
        printf("i:%g\n", fVal );
}

Lex Yacc (四) 实际应用全代码

标签：

原文地址：http://blog.csdn.net/u014015972/article/details/51480742
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！