个人的一些脚本和代码，经常会分散在不同的地方，管理起来并不方便，例如给WordPress编写的Plugin、测试MySQL时使用的一些脚本等，所以打算全部使用GitHub管理起来。对于个人使用，GitHub提供了私人仓库以存储代码，可以较为方便的管理一些还没有公开的个人代码。

建立个人Git和GitHub环境

GitHub CLI是一个具体简单交互式操作的命令行，可以完成与GitHub相关的一些交互与操作。对应的软件包/命令是gh。

安装gh-cli

参考：Installing gh on Linux and BSD。Amazon Linux 2上安装：

sudo yum-config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo
sudo yum install gh

使用gh配置GitHub授权

接着，就可以使用gh auth login命令来进行GitHub的认证了（gh cli manual）。这是一个简单的交互式命令，这里使用https+token的方式完成认证（也可以使用浏览器的方式辅助完成命令行认证）：

gh auth login
? What account do you want to log into? GitHub.com
? What is your preferred protocol for Git operations on this host? HTTPS
? Authenticate Git with your GitHub credentials? Yes
? How would you like to authenticate GitHub CLI? Paste an authentication token
Tip: you can generate a Personal Access Token here https://github.com/settings/tokens
The minimum required scopes are 'repo', 'read:org', 'workflow'.
? Paste your authentication token: *********************************************************************************************
- gh config set -h github.com git_protocol https
✓ Configured git protocol
! Authentication credentials saved in plain text
✓ Logged in as orczhou

关于Token的配置与获取，可以参考：GitHub->Settings->Developer Settings ，这里不再详述。注意，Token意味着分配的所有的仓库权限，必须妥善保管，否则可能会带来巨大的安全隐患。

如果要登出的话，则可以简单的使用如下命令：

gh auth logout

在本地pull与push仓库

• 首先，在git中配置本地身份（用户名与）

git config --global user.name "orczhou"
git config --global user.email "orczhou@orczhou"

• 首先，新建一个本地模板，并使用git命令初始化

mkdir  terraform && cd terraform
git init

• 配置远端（remote）分支；并拉取远端代码

git remote add origin https://github.com/orczhou/cloud-mysql-benchmark.git
git pull origin main

向远端push代码

这时，如果修改了仓库中的代码，则可以使用push命令向远端发起提交请求。

修改、测试并本地提交代码：

vi gcp_rds_ins/all_in_one/README.md
git add gcp_rds_ins/all_in_one/README.md
git commit -m "gcp readme updated"

向远端push修改：

git push -u origin main

该操作会向远端仓库的main分支，提交代码。

向main分之合并代码

可以在GitHub仓库页面，对比并创建一个pull request。

发起pr之后，代码仓库则可以进行merge操作，将代码合并到main分之。

在新增远程代码库(origin)

git remote add origin https://github.com/orczhou/testing-delete-repo-if-u-like.git

将本地代码，提交到远程代码库（origin）的main分支：

git push -u origin main

上面的，-u origin main ，其中-u参数表示push的目标代码库-u | --set-upstream

在现有仓库的main分之上开发

经常需要做这个动作，常用的命令比较简单，这里记录如下：

mkdir repo_bench && cd repo_bench
git init
git branch -M main
git remote add origin https://...
git pull origin main

直接修改本地main中的代码并提交到源端：

cat "..." > README.md
git add README.md
git commit -m "first commit" --dry-run
git commit -m "first commit"
git push -u origin main

使用gitignore忽略文件

在代码开发过程中，由于编译、运行等原因会产生很多的中间文件，而这些中间文件时无需提交到代码仓库的。这时候，需要使用gitignore来忽略这部分文件。详细完整的gitignore的使用可以参考man gitignore。

常用的gitignore是可以通过.gitignore文件来实现，即在代码的根目录中新建该文件，那么在代码处理时，就会根据根据该文件的规则进行忽略。例如Terraform脚本常用的gitignore文件可以参考：

• Terraform.gitignore
• terraform-guides /.gitignore

所以，一个Terraform脚本的.gitignore可以依次作参考：

# Compiled files
*.tfstate
*.tfstate.backup
*.tfstate.lock.info

# Directories
.terraform/
.vagrant/

# SSH Keys
*.pem

# Ignored Terraform files
*gitignore*.tf

master分支与main分支

在搜索git/github的相关资料的时候，经常还会搜索到master分支作为主分支的资料或者仓库。在2020年的George Floyd的案件发生后，美国的Black_Lives_Matter运动达到了前所未有的高度，最终也影响到在计算机领域的master/slave 一词的使用。更多的参考：Renaming the default branch from master@GitHub、Why GitHub renamed its master branch to main@theserverside。

不过，git在本地默认还是使用默认的master分支，所以如果没有手动切换分支，则还是会经常“默认的”创建master分支。

查看未提交的修改

git面向的场景就是分布式、多任务的开发代码管理，其独特的”three tree“模型可以很巧妙的实现这些能力。这也给初学者带来了很多理解上的障碍。

git diff与git diff HEAD

如果，想要查看自上次commit以来的所有变更，则需要试用git diff HEAD命令，通常HEAD指向的是，最后一次commit时的位置。

# diff between "working" and "staging"
git diff

# diff between "working" and "repository"
git diff HEAD

# diff between "staging" and "repository"
git diff --cached

同步远程更新

个人代码仓库管理中，有时候会有这样的情况：直接在远程仓库中修改了一些文件，然后如何让本地和远程保持同步。考虑这样的场景：直接在GitHub上对README.md文件进行了编辑，那么本地代码仓库如何保持这个更新。

当然，这样做，通常可能会很危险：可能会覆盖掉你本地所做的更改，但是基于上面的场景，所以，有时候会需要这么做。Stackoverflow上有几个相关的问题，非常详细的介绍了做法：

• How do I pull files from remote without overwriting local files?
• What is the difference between ‘git pull’ and ‘git fetch’?

这里的推荐做法是这样，如果本地仓库的修改确定不要了（通常这是很危险的）：

git pull

如果本地仓库修改都还需要：

git stash
git pull 
git stash pop

还可以：

• 先使用 git fetch更新origin/main
• 然后使用git diff main origin/main查看本地与远程的差异
• 最后使用git merge将origin/main与本地合并，并保持在本地

这样origin/main是最新的，且本地分支也是最新的了

git fetch
git diff main origin/main
git merge

参考链接

• Installing gh on Linux and BSD
• GitHub->Settings->Developer Settings
• gh cli manual
• Renaming the default branch from master@GitHub
• Why GitHub renamed its master branch to main@theserverside
• Git reset

引言

这是一个系列文章，旨在了解如何使用Flex/Lex和Yacc/Bison进行词法和语法解析。在前面，已经完成了使用Lex/flex做基础的词法解析、实现一个简单的计算器。开始这个系列的第三部分，使用flex和bison完成一个更加复杂的的编译程序。整体上有一定的复杂度，所以分上下篇分别介绍。上篇介绍：实现概要、语法、，下篇介绍数据结构与实现（包括解析树实现、执行）。

• 下篇介绍：数据结构与实现
  • 与Grammar对应的“解析树”
  • “解析树”的执行
  • 解析树的节点，Terminals 和 Non-Terminals
  • 一个“简单语句”的解析树结构
  • 一个“略微复杂语句”的解析树结构

解析与执行包含赋值、IF、WHILE等语句的程序

在前面的案例中，我们实现了一个简单的加减乘运算的计算器程序。这里我们尝试实现一个更复杂一些的编译程序，语法能够支持如下内容：

• 包含了变量，可以对变量赋值，也可以在表达式中使用变量。但是为了简化程序，这里变量仅限于使用单个小写字母，即[a-z]
• 支持条件运算，这里定义简单的语法如下：if ( expr ) expre ; （忽略了else语法）
• 支持比较运算符，包括大于、小于
• 支持循环运算，支持while循环
• 和前面案例的一样，仅处理整数，故不处理除法，也不考虑整数溢出等边界问题

我们用这几个能力，可以编写如下的程序：

i = 1;
a = 0;
while ( a < 100 ) {
  i = i + 1;
  a = a + i;
}
print i;

这个程序实现了一个简单的功能，解决的问题是：在自然数序列（1、2、4…）中，前面多少个自然数的和首次大于100。你可以使用上面的命令编写其他的任意程序。

解析树的节点

如果只是使用前面的指令，似乎难以实现对if/while语句的支持。这里，就需要使用典型的编译与执行思路了，先使用语法解析构建一个“语法树”（也叫“解析树”），然后再执行该解析树。具体的，一些设计如下：

• 使用一个全局数组（int * var[26]）存储变量，因为在前面限制了变量名只能是[a-z]
• 每个grammar rule对应一个tree node，并依次构建一棵语法树
• 语法树的节点设计如下：

typedef struct t_node{
    enum NODETYPE nt;
    struct t_node* left;
    struct t_node* right;
    int i;  // for NT_INTEGER NT_VAR_NAME node
}t_node;

这里为了简化：

• 所有语法节点都存放在该结构中
• 对于变量名，本应该是一个字符，这里在存储时，直接使用其ASCII码将其存储为整数

语法规则设计

在开始实现与执行解析树之前，我们先定义语法规则，以支持赋值、if、while、print等语法。语法规则定义时，需要注意尽量避免出现shift/reduce冲突，并且这里的语法规则不包含Action部分：

//start symbol
program: 
        | program statement_block   { printf("\n job done! \n"); }
;

statement_block: 
        | statement_block statement
;

statement: assignment
        | print_func
        | if_block
        | while_block 
;

while_block: WHILE '('  bool_expr ')' '{' statement_block '}'

if_block: IF '(' bool_expr ')' '{' statement_block '}'

assignment: VAR_NAME '=' expression ';'

print_func : PRINT expression ';'  
        | PRINT VAR_NAME ';'

bool_expr: expression GT expression
        |  expression LT expression

expression: INTEGER
        | VAR_NAME
        | expression O_ADD expression
        | expression O_MINUS expression
        | expression O_MULTIPLY expression

节点分析

节点分析：INTEGER VAR_NAME

• 节点类型（enum NODETYPE）分别是：NT_INTEGER NT_VAR_NAME
• 没有子节点，故left/right node都是NULL
• 在初始化时，
  • 对于INTEGER：t_node.a 存储的是具体的整数
  • 对于VAR_NAME：则存储的变量名，这了变量名为[a-z]，则将其ASCII存放于t_node.a

节点分析：expression 与 O_ADD O_MINUS O_MULTIPLY

expression对应的语法规则如下

expression: INTEGER
        | VAR_NAME
        | expression O_ADD expression
        | expression O_MINUS expression
        | expression O_MULTIPLY expression

那么，再看看O_ADD O_MINUS O_MULTIPLY这类节点：

• NODETYPE 分别是 NT_O_ADD NT_O_MINUS NT_O_MULTIPLY
• 都有两个子节点，left / right
• 在execute之后存储，各个expression计算的结果值t_node.a中
• 注意，在这个设计中，无需有一个独立的expression节点

bool表达式（bool_expr），通常用于条件判断

bool_expr: expression GT expression 
        |  expression LT expression 

• 节点类型（enum NODETYPE）为 NT_BOOL_EXPR
• 有两个子节点，执行该节点时，需要执行两个子节点之后，获得两个子节点的结果值，再进行比较
• 返回值为为bool型，这里使用int存储，0表示FALSE 1表示TRUE

print_func节点

这个节点实现一个打印整数值的功能，参数可以是一个变量，也可以是一个表达式：

print_func : PRINT expression ';'  
        | PRINT VAR_NAME ';' 

• NODETYPE为 NT_PRINT_FUNC
• 只有一个子节点，为一个 expression 或 VAR_NAME （注：这里应该只用expression就可以了，因为VAR_NAME也是expression）
• 执行该节点时，则需要实际调用一次打印函数，向标准输出打印expression的结果值

assignment 赋值语句

assignment: VAR_NAME '=' expression ';'

赋值语句左边是变量名，这里定义是[a-z]，右边是一个表达式，语句以分号结束。

• 其节点类型（NODETYPE）为：NT_ASSIGNMENT
• 左子节点为 VAR_NAME ，右子节点为 expression
• 其执行时，需要将expression的结果值，存储到变量数组对应的整型变量中

while_block WHILE子句

while_block: WHILE '('  bool_expr ')' '{' statement_block '}'

• 其节点类型（NODETYPE）为：NT_WHILE
• 左子节点为: bool_expr 右子节点为 : statement_block
• 执行该节点时，也是也while循环执行，条件部分是执行并判断bool_expr的真假，再决定是否执行右子节点。这里需要注意，每次获取bool_expr的时候，都需要先执行一次该节点。

if_block IF子句

if_block: IF '(' bool_expr ')' '{' statement_block '}'

• 其节点类型（NODETYPE）为：NT_IF
• 左子结点为 bool_expr 右子节点 : statement_block
• 执行时，先执行左子节点，再获取其结果的真/假，再判断是否执行右子节点

statement

statement: assignment
        | print_func
        | if_block
        | while_block

可以看到，statement由assignment、print_func、if_block、while_block是这些中的任何一个。所以，在实际构建中，并不会有该节点。与expression类似。

statement_block 多个statement

statement_block: 
        | statement_block statement
;

• 其节点类型（NODETYPE）为：NT_STATEMENT_BLOCK
• 左子节点为 : statement_block，即为statement_block或者assignment、print_func、if_block、while_block中的任意一个；右子节点为 : assignment、print_func、if_block、while_block
• 执行时，先执行左子节点，再执行右子节点

program

program:
        | program statement_block  { printf("\n job done! \n"); }
;

主要的数据结构与函数

• build_node：构建当前语法规则的节点，该函数返回当前构建出来节点的指针，通常也是各个语法规则Action部分的返回值。

t_node* build_node( 
    enum NODETYPE nt,
    t_node* left,
    t_node* right,
    int i)

• exec_node：执行某个节点，并执行其左/右子节点（如果存在的话）。不同的节点的执行操作会有一些不同，例如：
  • if节点需要做一些判断，再决定是否执行；
  • while节点则需要循环bool_expr以决定是否执行某段代码。
  • 加法节点，则需要执行左右子节点执行结果，并相加

各类节点的exec操作可以参考上一节的详细描述。该函数定义如下

int exec_node(t_node *n)

• 解析树的节点与节点类型

typedef struct t_node{
    enum NODETYPE nt;
    struct t_node* left;
    struct t_node* right;
    struct t_node* rrnode;
    int i;  // for NT_INTEGER NT_VAR_NAME node
}t_node;

enum NODETYPE{
    NT_STATEMENT,
    NT_IF,
    NT_WHILE,
    NT_PROGRAM,
    NT_STATEMENT_BLOCK,
    NT_O_ADD,
    NT_O_MINUS,
    NT_O_MULTIPLY,
    NT_INTEGER,
    NT_VAR_NAME,
    NT_BOOL_EXPR_GT,
    NT_BOOL_EXPR_LT,
    NT_PRINT,
    NT_ASSIGNMENT
};

下一篇，我们将基于此完成完整的代码。

不包含Action代码的语法

补充完整的语法文件cal.y

包括：

• 入口函数
• NODETYPE 定义
• 解析树的节点 t_node
• 声明节点便利函数 exec_node
• 用于存储变量的数组 int var[26];
• YYSTYPE （似乎是不需要）
• 定义lex需要处理的TOKEN
• 定义运算符优先级、结合律

%{
// 入口函数

#include <stdio.h>

int main (){
    yyparse();
    return 0;
}

enum NODETYPE{
    NT_PROGRAM,
    NT_STATEMENT_BLOCK,
    NT_STATEMENT,
    NT_IF,
    NT_WHILE,
    NT_O_ADD, 
    NT_O_MINUS,
    NT_O_MULTIPLY,
    NT_INTEGER,
    NT_VAR_NAME
};

typedef struct t_node{
    enum NODETYPEP nt;
    t_node * left;
    t_node * right;
    t_node * rrnode;
    YYSTYPE yval;
}t_node;

//递归执行整个parser tree
int exec_node(t_node *n){
    return 0;
}

int var[26];

%}

// 定义YYSTYPE
%union {
    int a;  // for integer
    char c; // for var_name
    bool b; // for bool_expr
}


// 定义Token
%token <c> VAR_NAME 
%token <a> INTEGER
%token O_ADD O_MINUS O_MULTIPLY 

%token GT LT

%token WHILE IF
%token PRINT

// 定义运算符
%left O_ADD O_MINUS
%left O_MULTIPLY

补充Lex文件

%{
    #include "cal.tab.h"
%}
%option noyywrap
%%
[[:digit:]]+ {
    yylval.a = atoi(yytext);
    return INTEGER;
}

[a-z] {
    yylval.c = yytext[0];
    return VAR_NAME;
}

"+" { return O_ADD;};
"-" { return O_MINUS;};
"*" { return O_MULTIPLY;};

"while"  {return WHILE;}
"if"  {return IF;}
"print"  {return PRINT;}

">" {return GT;}
"<" {return LT;}

[();={}]  {return yylval.c = *yytext;}

%%

生成代码并编译、修改

lex cal.l 
bison -d cal.y 
gcc cal.tab.c lex.yy.c -o a.out


bison -W -d cal.y

cal.y:62.8: warning: empty rule without %empty [-Wempty-rule]
 program:
        ^
cal.y:66.16: warning: empty rule without %empty [-Wempty-rule]
 statement_block:
                ^
cal.y: warning: 6 shift/reduce conflicts [-Wconflicts-sr]

错误1：这里的 PRINT expression ‘;’ PRINT VAR_NAME ‘;’ 是有包含关系，重复的。因为VAR_NAME本身也是一个expression。故修改如下：

print_func : PRINT expression ';'  
        | PRINT VAR_NAME ';' 

expression: INTEGER
        | VAR_NAME
        | expression O_ADD expression
        | expression O_MINUS expression
        | expression O_MULTIPLY expression

疑问与思考：左边/右边的表达有什么不同。（注意，左边的表达会报shift/reduce conflict）

program: 
        | program statement_block 
;

statement_block: 
        | statement_block statement
;

statement: assignment
        | print_func
        | if_block
        | while_block 
;

program: statement_block 
;


statement_block:
        | statement_block statement
;

statement: assignment 
        | print_func 
        | if_block 
        | while_block 
;

修改后的cal.y文件，仅语法部分，不包含Action

%%
program:  statement_block { printf("\n job done! \n");}
;

statement_block:
        | statement_block statement
;

statement: assignment 
        | print_func 
        | if_block 
        | while_block 
;

if_block: IF '(' bool_expr ')' '{' statement_block '}' 

while_block: WHILE '('  bool_expr ')' '{' statement_block '}' 

assignment: VAR_NAME '=' expression ';'

print_func : PRINT expression ';'

bool_expr: expression GT expression
        |  expression LT expression

expression: INTEGER
        | VAR_NAME
        | expression O_ADD expression
        | expression O_MINUS expression
        | expression O_MULTIPLY expression

引言

这是一个系列文章，旨在了解如何使用Flex/Lex和Yacc/Bison进行词法和语法解析。在前面，已经完成了使用Lex/flex做基础的词法解析。接着，开始这个系列的第二部分，使用flex和bison完成一个简单的计算器。

为了简化实现，将注意力放在简单flex和bison使用上，这里对计算器做了几个简化：

• 只支持加、减、乘计算，暂时不支持除法，除法可能涉及到浮点类型，故暂时忽略
• 不考虑整数溢出的问题，这里使用int类型（那么他存储与计算范围是有限的）

也就是该程序可以计算加法、减法、乘法，以及他们的任意组合，如： 3+4、 3+4*2、 3+4*2-3、 3+4*2-3*2

后续，还将考虑增加更急复杂的计算器，包括：

• 实现，带有变量的计算器程序
• 实现带来循环、带有条件判断的程序

这里先从简单的开始。

初次手写一个cal.l和cal.y

这是在vim中写出的第一遍代码，包含了词法文件cal.l和语法文件cal.y，详细如下。这其中当然是有很多错误的，之所以，依旧写出来，是为了和正确代码对比，以此看看对哪些概念理解有偏差。如果你是找一个正确例子的话，可以跳过这一段。

%{
#inlcude <stdlib.h>
%}
/* 十进制整数 */
%token INTEGER

%union { 
    int a;
}

/* 操作符 + - * / */
%token OPERATOR

%%
program:
    program expression \n { printf("%d",$2); }   // 这里就是以回车结尾，也可以考虑使用 = 结尾
    |

expression:
		  INTEGER
		| expression '+' expression {$$ = $1 + $2}
		| expression '-' expression {$$ = $1 - $2}
		| expression '*' expression {$$ = $1 * $2}

dec_integer: 
		INTEGER
			{
			$$ = $1.a;
			}

这里也有几个已知的问题，例如：运算符的优先级没有定义，也就说4+3*2可能会算成14。没错，如果眼尖的话，还发现有一些拼写错误。

接着是cal.l文件：

#inlcude <stdlib.h>
#include "y.tab.h"
​
%}
[:digit:]+ {
            yylval.a = atoi(yytext)
            RETURN INTEGER;
}

当然，这里面有很多的错误。一会儿来看后面正确的内容。

修改cal.l和cal.y

• 首先，是去解决已知的问题：运算符优先级如何去解决？关于什么是优先级、什么是结合律这里不做详述，这里有一篇文章讲得比较细致，几幅图也非常直观：Precedence and Associativity of Operators in Python。虽然是不同的语言，但意思是一样的。理解这个点还是比较重要的，例如在关系型数据库中，之前有遇到过这样的案例，可以思考一下如下的表达式 t.col < 2 or t.col < 11 and t.col > 4 是什么意思：

-- 猜测一下，如下的 SELECT 查询是否能够返回记录：

CREATE TABLE t(col INT); 

INSERT INTO t values (1);

WHERE t.col < 2 or  t.col < 11 and  t.col > 4

扯远了，再回到cal.y文件，优先级和结合律需要进行如下修改，以定义”*”优先级高于”+”、”-“：

%left '+' '-'
%left '*'

这里的代码先后，就定义了优先级；优先级越高，定义在越在后面；left表示，左结合。

• 除了优先级，在cal.y语法规则中的定义部分，如果有字符，并没有使用引号。例如上面的cal.y的第17行的\n，是需要加上引号的，即 '\n' 。

• 对于cal.y的中定义的语法规则，并没有定义返回值存储在联合体（YYSTYPE，也就是如下这里cal.y定义的唯一的那个联合体）哪个类型中。例如，没有定义”expression”这个语法规则，返回值是使用哪个值，虽然这里的联合体只定义了一个类型（即int a）。具体的，添加了如下代码：

%token <a> INTEGER
%type <a> expression

完成这样的定义后，在lex的文件cal.l中，就可以对yylval进行赋值，如：yylval.a = atoi(yytext); 这时，对于yacc文件中cal.y，如果引用这个TOKEN，就可以使用$1（或者是$2、$3）来引用lex解析后的返回值，如：expression: INTEGER { $$ = $1;}。

• 于是，重新使用了独立的Token重新定义了运算符，并定义了优先级，如下：

cat cal.y
...
%token O_ADD O_MINUS O_MULTIPLY O_EQ

%left O_ADD O_MINUS
%left O_MULTIPLY 

%token <a> INTEGER
%type <a> expression
...

cat cal.l
...
"=" { return O_EQ;};
"+" { return O_ADD;};
"-" { return O_MINUS;};
"*" { return O_MULTIPLY;};
...

• 没有定义 yyerror 函数，程序也会编译不过去，会报如下错误：

cal.tab.c:(.text+0x53b): undefined reference to `yyerror'

按照文档，可以定义一个最简单的yerror函数（参考：The Error Reporting Function yyerror），如下：

void
yyerror (char const *s)
{
  fprintf (stderr, "something error: %s\n over", s);
}

• 删除了无效的dec_integer规则，如果有无效的规则，也会失败
• 将[:digit:]修改为[0-9]+。至于为什么[:digit:]不生效，后面做了一些搜索。为了避免歧义，需要额外再加一层中括号，写法也就是[[:digit:]]。详细参考：Patterns@Lexical Analysis With Flex

完整的计算器程序文件cal.l cal.y

补充一个main入口函数，修改cal.l、cal.y即可。

修正后的cal.l

%{
    #include "cal.tab.h"
    #include <stdio.h> 
%}
%option noyywrap
%%
[0-9]+ {
			yylval.a = atoi(yytext);
			return INTEGER;
    	   }

"=" { return O_EQ;};
"+" { return O_ADD;};
"-" { return O_MINUS;};
"*" { return O_MULTIPLY;};

%%

修正后的cal.y

%{
	#include <stdlib.h>
	#include <stdio.h>


int main(){
	yyparse();
}

void
yyerror (char const *s)
{
  fprintf (stderr, "something error: %s\n over", s);
}

%}


%union { 
    int a;
}

%token O_ADD O_MINUS O_MULTIPLY O_EQ
%token <a> INTEGER

%left O_ADD O_MINUS
%left O_MULTIPLY 
%type <a> expression

%%
program:
    |
    program expression O_EQ { printf("result is : %d",$2); }   
;
expression:
		  INTEGER { $$ = $1;}
		| expression O_ADD expression {$$ = $1 + $3; }
		| expression O_MINUS expression {$$ = $1 - $3; }
		| expression O_MULTIPLY expression {$$ = $1 * $3;}
;

编译与执行

然后，就可以生成c文件并编译可执行文件了：

lex cal.l 
bison -d cal.y 
gcc cal.tab.c lex.yy.c -o a.out
./a.out
4+3*2=

也可以像这样：
lex cal.l && bison -d cal.y && gcc cal.tab.c lex.yy.c -o a.out && ./a.out

附带注释说明的cal.y文件

%{                                    // %{ ... %}  包含了完整的C语言代码        
	#include <stdlib.h>           // 这里包含需要的头文件、入口函数main
	#include <stdio.h>            //    以及一个简答的yyerror函数


int main(){
	yyparse();
}

void
yyerror (char const *s)
{
  fprintf (stderr, "something error: %s\n over", s);
}

%}


%union {                             // 这是一个非常重要的联合体，用于定义
    int a;                           // 各种不同类型的Token所返回的数据
}                                    // 广泛的被yylex使用，并用于与.yy文件共享数据
                                     // 也就是 YYSTYPE 

%token O_ADD O_MINUS O_MULTIPLY O_EQ
%token <a> INTEGER                   // 这里表示INTEGER(这是一个被lex识别的token）
                                     // INTEGER（被lex识别的token返回值为YYSTYPE.a
%left O_ADD O_MINUS                  // 这里定义 + -为左结合律
%left O_MULTIPLY                     // 这里定义 * 为左结合律，并且优先级高于 + -
%type <a> expression                 // 这里定义语法规则(grammer rule)expression
                                     // 的返回值为 YYSTYPE.a
%%
program:                             // 这是start symbol，所有的program都需要符合该定义
    |
    program expression O_EQ { printf("result is : %d",$2); }   
;
expression:
		  INTEGER { $$ = $1;}
		| expression O_ADD expression {$$ = $1 + $3; }
		| expression O_MINUS expression {$$ = $1 - $3; }
		| expression O_MULTIPLY expression {$$ = $1 * $3;}
;