4604人阅读
文法分析用Flex(Lex):将数据分隔成一个个的标记token (标示符identifiers，关键字keywords，数字numbers, 中括号brackets, 大括号braces, 等等etc.)
语法分析用Bison(Yacc): 在分析标记的时候生成抽象语法树. Bison 将会做掉几乎所有的这些工作, 我们定义好我们的抽象语法树就OK了.
组装用LLVM: 这里我们将遍历我们的抽象语法树，并未每一个节点生成字节/机器码。 这听起来似乎很疯狂，但是这几乎就是最简单的 一步了.
sudo apt-get install flex bison
flex -h && bison -h 进行测试
cd ~/shellscript/bin
gedit lexya
将执行后面每一个例子时一连串的命令放进去
chmod u+x lexya 就像下面这样
～/shellscript/bin/lexya 针对草木鱼（四五六七）和汇编版本的一个脚本
#! /bin/bash
name=`basename $0`
# 针对草木鱼（四五六七）和汇编版本
if [ $name = "lexya6" ]
bison -d lexya_e.y
lex -d lexya_e.l
gcc -g -o graph lex.yy.c lexya_e.tab.c liwei.c
./graph & treeinput
elif [ $name = "lexya5" ]
bison -d lexya_e.y
lex -d lexya_e.l
gcc -g -o parser lex.yy.c lexya_e.tab.c parser.c
./parser & input
elif [ $name = "lexya4" ]
bison -d lexya_e.y
lex -d lexya_e.l
gcc -g -o parser lex.yy.c lexya_e.tab.c parser.c
./parser & input
elif [ $name = "lexya7" ]
bison -d tree.y
lex -d tree.l
gcc -g -c lex.yy.c tree.tab.c parser.c # 有Waring，忽略之 -c 只编译不链接
ar -rl compile.a *.o
# 使用静态库文件编译外部程序：
-o lw main.c compile.a
# 运行编译显示结果：
./lw & input
elif [ $name = "lexyan" ]
./parser & testfile/test.c & test.asm
# nasm -f elf64 test.asm
# ld -s -o test test.o
as --32 -o test.o test.asm
ld -s -m elf_i386 -o test test.o
ln -s lexya lexyan && ln -s lexya lexya4 && ln -s lexya lexya5 && ln -s lexya lexya6 && ln -s lexya lexya7
一个简单的编译器 flex & bison
目标编译代码
int do_math(int a) {
int x = a * 5 + 3
do_math(10)
看起来很简单。它和C非常相似，但是它没有使用分号做语句的分隔，同时你也会注意到我们的语法中没有return语句。这就是你可以自己实现的部分。
现在我们还没有任何机制来验证结果。我们将通过检查我们编译之后LLVM打印出的字节码验证我们程序的正确性。
编写tokens.l 和 parser.y 去github上下载最新版,可能有错，自己读代码改正
bison -d -o parser.cpp parser.y
flex -o tokens.cpp tokens.l
如果上面没有错误，你可以编译一个简单的main.cpp
#include &iostream&
#include "node.h"
extern NBlock* programB
extern int yyparse();
int main(int argc, char **argv)
yyparse();
std::cout && programBlock &&
g++ -o parser parser.cpp tokens.cpp main.cpp
具体参见原博客：使用Flex Bison 和LLVM编写自己的编译器
Lex工具是一种词法分析程序生成器，它可以根据词法规则说明书的要求来生成单词识别程序，由该程序识别出输入文本中的各个单词。 一般可以分为&定义部分&&规则部分&&用户子程序部分&。其中规则部分是必须的，定义和用户子程序部分是任选的。
简单的处理Lex的例子
#include "stdio.h"
printf("Int
: %s\n",yytext);
[0-9]*\.[0-9]+
printf("Float
: %s\n",yytext);
[a-zA-Z][a-zA-Z0-9]*
printf("Var
: %s\n",yytext);
[\+\-\*\/\%]
printf("Op
: %s\n",yytext);
printf("Unknown : %c\n",yytext[0]);
flex -o a.c lex.l
gcc -o a a.c -ll
./a 或者 ./a file.txt
file.txt 如下
bcd=4%9-333
对lex.l进行改进
showtitle();
linenum++;
printf("Int
: %s\n",yytext);
[0-9]*\.[0-9]+
printf("Float
: %s\n",yytext);
[a-zA-Z][a-zA-Z0-9]*
printf("Var
: %s\n",yytext);
[\+\-\*\/\%]
printf("Op
: %s\n",yytext);
printf("Unknown : %c\n",yytext[0]);
showtitle()
printf("----- Lex Example -----\n");
int main()
linenum=0;
yylex(); /* 进行分析 */
printf("/nLine Count: %d/n",linenum);
int yywrap()
flex -o a.c lex.l
gcc -o a a.c 这里不加 -ll 也可以编译通过
./a 或者 ./a file.txt
-ll 参数选项
当编译时不带-ll选项时，是必须加入main函数和yywrap(yywrap将下后面说明)。
lex 内部预定义变量和函数
ytext char * 当前匹配的字符串
yleng int 当前匹配的字符串长度
yin FILE * lex当前的解析文件，默认为标准输出
yout FILE * lex解析后的输出文件，默认为标准输入
ylineno int 当前的行数信息
CHO #define ECHO fwrite(yytext, yyleng, 1, yyout) 也是未匹配字符的默认动作
nt yylex(void) 调用Lex进行词法分析
nt yywrap(void) 在文件(或输入)的末尾调用。如果函数的返回值是1，就停止解析。 因此它可以用来解析多个文件。代码可以写在第三段，这样可以解析多个文件。 方法是使用 yyin 文件指针指向不同的文件，直到所有的文件都被解析。最后，yywrap() 可以返回1来表示解析的结束。
yacc文法采用BNF(Backus-Naur Form)的变量规则描述。
处理 1+2/3+4*6-3
我们将 “1+2/3+4*6-3-2”逐个字符移进堆栈，如下所示：
.1+2/3+4*6-3
1.+2/3+4*6-3
E.+2/3+4*6-3
E+.2/3+4*6-3
E+2./3+4*6-3
E+E./3+4*6-3
E+E/.3+4*6-3
E+E/3.+4*6-3
E+E/E.+4*6-3
E+E/E+.4*6-3
E+E/E+4.*6-3
E+E/E+E.*6-3
E+E/E+E*.6-3
E+E/E+E*6.-3
E+E/E+E*E.-3
E+E/E+E*E-.3
E+E/E+E*E-3.
E+E/E+E*E-E.
E+E+E*E-E.
我们在实际运算操作中是把一个表达式逐步简化成一个非终结符。称之为“自底向上”或者“移进归约”的分析法
在第1步中我们把1压入堆栈中。第2步对应规则a，把1转换成E。然后继续压入和归约，直到第5步。此时堆栈中剩下E+E，按照规则d，可以进行E=E+E的合并，然而输入信息并没有结束，这就产生了“移进-归约”冲突(shift-reduce conflict)。在yacc中产生这种冲突时，会继续移进
在第17步，E+E/E，即可以采用E+E规则d，也可以采用E/E规则b，如果使用E=E+E规约，显然从算法角度是错误的，这就有了运算符的优先级概念。这种情况称为“归约-归约”冲突(reduce-reduce conflict)。此时yacc会采用第一条规则，即E=E/E。这个内容会在后面的实例做进一步深化
小计算器 lex && yacc 对应于草木鱼 (二)
维护者两个栈，内容栈和分析栈
在.l文件的词法分析时，进行一次压栈，例如：[0-9]+ { yylval = atoi(yytext); return INTEGER; }
yylval = atoi(yytext); 是将yylval的值压入内容栈
return INTEGER; 是将INTEGER对应的数字压入分析栈
.l的结果传给了.y文件，yacc再次进行压栈 但是这次压栈不一定是紧接着.l进行的，因为会有移近-移近冲突和移近-规约冲突
例如：expr: INTEGER { $$ = $1; }
expr: INTEGER 是将INTEGER从分析栈弹出，压入expr
{ $$ = $1; } 是将INTEGER 对应的内容栈中的值弹出，并赋值给expr对应的yyval，同时压入内容栈
#include &stdlib.h&
void yyerror(char *);
#include "lexya_a.tab.h"
{ yylval = atoi(yytext); return INTEGER; }
yyerror("无效字符");
int yywrap(void) {
#include &stdlib.h&
#include &stdio.h&
int yylex(void);
void yyerror(char *);
%token INTEGER
%left '+' '-'
%left '*' '/'
program expr '\n' { printf("%d\n", $2); }
INTEGER { $$ = $1; }
| expr '*' expr { $$ = $1 * $3; }
| expr '/' expr { $$ = $1 / $3; }
| expr '+' expr { $$ = $1 + $3; }
| expr '-' expr { $$ = $1 - $3; }
void yyerror(char *s) {
printf("%s\n", s);
int main(void) {
yyparse();
bison -d lexya_a.y 参数 -d 将头文件和.c文件分离
lex lexya_a.l
cc -o parser *.c
./parser 输入计算式，回车会显示运行结果
bison -d lexya_a.y 编译后会产生 lexya_a.tab.c lexya_a.tab.h
lex文件lexya_a.l中头声明已包括了 lexya_a.tab.h。这两个文件是典型的互相协作的示例
详细分析见 草木鱼系列的第二篇
yacc 堆栈原理
%token INTEGER
%left '+' '-'
%left '*' '/'
%}和%%这一段可以看作预定义标记部分。%token INTEGER 定义声明了一个标记。
当我们编译后，它会在lexya_a.tab.c中生成一个剖析器，同时会在lexya_a.tab.h
产生包含信息：
# define INTEGER 257
其中0-255的之间的标记值约定为字符值，是系统保留的后定义的token。
lexya_a.tab.h其它部分是默认生成的，与token INTEGER无关。
# ifndef YYSTYPE
define YYSTYPE int
define YYSTYPE_IS_TRIVIAL 1
extern YYSTYPE
lex文件需要包含lexya_a.tab.h这个头文件，并且使用其中对标记值的定义。为了获得标记，yacc会调用yylex。yylex的返回值类型是整型，可以用于返回标记。而在yylval变量中保存着与返回的标记相对应的值
yacc在内部维护着两个堆栈，一个分析栈和一个内容栈。分析栈中保存着终结符和非终结符，并且记录了当前剖析状态。而内容栈是一个YYSTYPE类型的元素数组，对于分析栈中的每一个元素都保存着一个对应的值。例如，当yylex返回一个INTEGER标记时，把这个标记移入分析栈。同时，相应的yacc值将会被移入内容栈中。分析栈和内容栈的内容总是同步的，因此从栈中找到对应的标记值是很容易的。
比如lex文件中下面这一段：
{ yylval = atoi(yytext); return INTEGER; }
这是将把整数的值保存在yylval中，同时向yacc返回标记INTEGER。即内容栈存在了整数的值，对应的分析栈就为INTEGER标记了。yylval类型由YYSTYPE决定，由于它的默认类型是整型，所以在这个例子中程序运行正常。
lex文件还有一段：
这里显然只是向yacc的分析栈返回运算符标记，系统保留的0-255此时便有了作用，内容栈为空。把“-”放在第一位是防止正则表达式发现类似a-z的歧义。
再看下面的：
%left '+' '-'
%left '*' '/'
%left 表示左结合，%right 表示右结合。最后列出的定义拥有最高的优先权。因此乘法和除法拥有比加法和减法更高的优先权。+ - * / 所有这四个算术符都是左结合的。运用这个简单的技术，我们可以消除文法的歧义。
粗略有了概念之后，再看lex如何执行相应的行为。
以expr: expr ‘+’ expr { $$ = $1 + $3; }为例
在分析栈中我们其实用左式替代了右式。在本例中，我们弹出“ expr ‘+’ expr ”然后压入“expr”。我们通过弹出三个成员，压入一个成员来缩小堆栈。在我们的代码中可以看到用相对地址访问内容栈中的值。如1，2，这样都是yacc预定义可以直接使用的标记。“1”代表右式中的第一个成员，“2”代表第二个，后面的以此类推。“$$”表示缩小后的堆栈顶部。在上面的动作中，把对应两个表达式的值相加，弹出内容栈中的三个成员，然后把得到的和压入堆栈中。这样，保持分析栈和内容栈中的内容依然同步。
program expr ‘\n’ { printf(“%d\n”, $2); }
说明每当一行表达式结束时，打印出第二个栈值，即expr的值，完成字符运算。
计算器升级版 ()运算符 变量保存 lex && yacc 对应于草木鱼 (三)
#include &stdlib.h&
#include "lexya_b.tab.h"
void yyerror(char *);
void add_buff(char *);
extern char sBuff[10][20];
extern int iX;
extern int iY;
{ yylval = * add_buff(yytext); return VAR; }
{ yylval = atoi(yytext); add_buff(yytext); return INT; }
{ yylval = * add_buff(yytext); return * }
{ yylval = * iY=0;iX++; return * }
yyerror("无效字符");
void add_buff(char * buff) {
sBuff[iX][iY]=* iY++;
int yywrap(void) {
#include &stdlib.h&
int yylex(void);
void yyerror(char *);
void debuginfo(char *, int *, char *);
void printinfo();
int sMem[256];
char sBuff[10][20]={0};
%token INT VAR
%left '+' '-'
%left '*' '/'
program statement
statement:
expr { printf("%d\n",$1); }
| VAR '=' expr { debuginfo("=",yyvsp,"110"); sMem[$1]=$3; }
| statement '\n' { printf("--------------------------------\n\n"); }
INT { debuginfo("INT",yyvsp,"0"); $$ = $1; }
| VAR { debuginfo("VAR",yyvsp,"1"); $$ = sMem[$1]; }
| expr '*' expr { debuginfo("*",yyvsp,"010"); $$ = $1 * $3; }
| expr '/' expr { debuginfo("/",yyvsp,"010"); $$ = $1 / $3; }
| expr '+' expr { debuginfo("+",yyvsp,"010"); $$ = $1 + $3; }
| expr '-' expr { debuginfo("-",yyvsp,"010"); $$ = $1 - $3; }
| '(' expr ')'
{ debuginfo("()",yyvsp,"101"); $$ = $2; }
void debuginfo(char * info,int * vsp, char * mark) {
printf("--RULE: %s \n", info);
int ilen=strlen(mark);
for(i=0;i&=1-i--) {
if(mark[ilen+i-1]=='1')
printf("$%d %d %c \n", i+ilen, vsp[i], vsp[i]);
printf("$%d %d \n", i+ilen, vsp[i]);
printinfo();
void printinfo() {
printf("--STATEMENT: \n");
printf("%s \n",sBuff[iX-1]);
printf("%s \n",sBuff[iX]);
printf("\n");
void yyerror(char *s) {
printf("%s\n", s);
int main(void) {
yyparse();
input 编译文本
a=4+2*(3-2-1)+6
b=1-10/(6+4)+8
bison -d lexya_b.y
lex lexya_b.l
gcc -g -o parser lex.yy.c lexya_b.tab.c 参数-g是调试选项
./parser & input
上面的计算器升级版分析
这里只是做了一些扩充变化：
1.增加了全局数组sMem来存放变量，不过变量名有限制，只支持单字符。
2.增加了全局数组sBuff存放分析过的语句
3.增加debuginfo打印堆栈信息
4.增加printinfo打印目前的分析语句
要进行内部分析，就需要剖析生成的c文件，对程序(parser)进行跟踪调试。
(注：Lex编译时加上d参数，会在程序解释时输出详细的调试信息。如：lex -d lexya_$1.l)
通过本示例再加上实际对lexya_b.tab.c的分析理解，会对lex，yacc理论有更进一步的理解。
增加支持的变量字符数，根据运行结果精读下面的源代码 草木鱼（三）
上面的例子只支持单字符的变量，想支持多字符，需要定义一全局变量如：
struct varIndex
char sMark[10];
同时打印信息加入对变量的显示，下面列出全部文件内容，比较简单，不再附加说明。
下面是需要的四个文件
头文件 userdef.h
typedef struct {
char sMark[10];
varIndex strMem[256];
#include &stdlib.h&
#include "userdef.h"
#include "lexya_c.tab.h"
void yyerror(char *);
void add_buff(char *);
void add_var(char *);
extern char sBuff[10][20];
extern int iBuffX;
extern int iBuffY;
extern varIndex strMem[256];
extern int iMaxI
extern int iCurI
[a-zA-Z][a-zA-Z0-9]*
{ add_var(yytext); yylval = iCurI add_buff(yytext);
return VAR; }
{ yylval = atoi(yytext); add_buff(yytext); return INT;
{ yylval = * add_buff(yytext); return * }
{ yylval = * iBuffY=0;iBuffX++; return * }
yyerror("无效字符");
void add_buff(char * buff) {
strcat(sBuff[iBuffX],buff);
iBuffY+=strlen(buff);
void add_var(char *mark) {
if(iMaxIndex==0){
strcpy(strMem[0].sMark,mark);
iMaxIndex++;
iCurIndex=0;
for(i=0;i&=iMaxIndex-1;i++) {
if(strcmp(strMem[i].sMark,mark)==0) {
iCurIndex=i;
strcpy(strMem[iMaxIndex].sMark,mark);
iCurIndex=iMaxI
iMaxIndex++;
int yywrap(void) {
#include &stdlib.h&
#include "userdef.h"
int yylex(void);
void yyerror(char *);
void debug_info(char *, int *, char *);
void stm_info();
extern varIndex strMem[256];
int iMaxIndex=0;
int iCurIndex=0;
char sBuff[10][20]={0};
int iBuffX=0;
int iBuffY=0;
%token INT VAR
%left '+' '-'
%left '*' '/'
program statement
statement:
expr { printf("%d\n",$1); }
| VAR '=' expr { debug_info("=",yyvsp,"210"); strMem[$1].iValue=$3;
| statement '\n' { printf("--------------------------------\n\n"); }
INT { debug_info("INT",yyvsp,"0"); $$ = $1;
| VAR { debug_info("VAR",yyvsp,"2"); $$ =
strMem[$1].iV }
| expr '*' expr { debug_info("*",yyvsp,"010"); $$ = $1 * $3; }
| expr '/' expr { debug_info("/",yyvsp,"010"); $$ = $1 / $3; }
| expr '+' expr { debug_info("+",yyvsp,"010"); $$ = $1 + $3; }
| expr '-' expr { debug_info("-",yyvsp,"010"); $$ = $1 - $3; }
| '(' expr ')'
{ debug_info("()",yyvsp,"101"); $$ = $2;
void debug_info(char * info,int * vsp, char * mark) {
printf("--RULE: %s \n", info);
int ilen=strlen(mark);
for(i=0;i&=1-i--) {
switch(mark[ilen+i-1]){
printf("$%d %d %c \n", i+ilen, vsp[i], vsp[i]);
printf("$%d %d \n", i+ilen, vsp[i]);
printf("$%d %s %d\n", i+ilen, strMem[vsp[i]].sMark, strMem[vsp[i]].iValue);
stm_info();
void stm_info() {
printf("--STATEMENT: \n");
if(iBuffY==0)
printf("%s \n",sBuff[iBuffX-1]);
printf("%s \n",sBuff[iBuffX]);
printf("\n");
void yyerror(char *s) {
printf("%s\n", s);
int main(void) {
yyparse();
aa=4+2*(3-2-1)+6
bb=1-10/(6+4)+8
bison -d lexya_c.y
lex -d lexya_c.l //-d是打印调试信息
gcc -g -o parser lex.yy.c lexya_c.tab.c //参数-g是调试选项，这里可能会报Warning
./parser & input
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：276556次
积分：4266
积分：4266
排名：第7478名
原创：156篇
转载：15篇
评论：19条
(2)(1)(15)(20)(10)(15)(23)(35)(6)(15)(5)(5)(11)(9)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'(1) 从网站：http://www.lysator.liu.se/c/& 下载C语言的语法文件：
The ANSI C grammar (&and&)&
(2) 编译词法文件：
(3) 编译语法文件：
&&yacc&-dv&c.y
说明：-d：产生头文件y.yab.h，-v：产生分析表y.output。针对else产生的移进规约冲突，采用了yacc的默认动作“移进”解决。
(4) 编译语法分析器：
&&cc&lex.yy.c&y.tab.c&-ll
(5) 测试：
编写测试程序test.c
#include&&stdio.h&
int&main(){
&&&&int&a&=&0;
&&&&for(;&a&&&10;&a++){
&&&&&&&&printf(&hello&from&sun!&&);
&&./a.out&&&test.c
结果如下：
&&stdio.h&
&&&&&&&&int&&=&;
&&&&&&&&for(;&&&&;&++){
&&&&&&&&&&&&&&&&int(&hello&from&sun&hong&hao!&&);
发现c.y文件中没有语义动作。只是进行了词法扫描一下，所以得到结果就是上面的样子了。
(5) 贴一下y.out里的规则：
&&&0&&$accept&:&translation_unit&$end
&&&1&&primary_expression&:&IDENTIFIER
&&&2&&&&&&&&&&&&&&&&&&&&&|&CONSTANT
&&&3&&&&&&&&&&&&&&&&&&&&&|&STRING_LITERAL
&&&4&&&&&&&&&&&&&&&&&&&&&|&'('&expression&')'
&&&5&&postfix_expression&:&primary_expression
&&&6&&&&&&&&&&&&&&&&&&&&&|&postfix_expression&'['&expression&']'
&&&7&&&&&&&&&&&&&&&&&&&&&|&postfix_expression&'('&')'
&&&8&&&&&&&&&&&&&&&&&&&&&|&postfix_expression&'('&argument_expression_list&')'
&&&9&&&&&&&&&&&&&&&&&&&&&|&postfix_expression&'.'&IDENTIFIER
&&10&&&&&&&&&&&&&&&&&&&&&|&postfix_expression&PTR_OP&IDENTIFIER
&&11&&&&&&&&&&&&&&&&&&&&&|&postfix_expression&INC_OP
&&12&&&&&&&&&&&&&&&&&&&&&|&postfix_expression&DEC_OP
&&13&&argument_expression_list&:&assignment_expression
&&14&&&&&&&&&&&&&&&&&&&&&&&&&&&|&argument_expression_list&','&assignment_expression
&&15&&unary_expression&:&postfix_expression
&&16&&&&&&&&&&&&&&&&&&&|&INC_OP&unary_expression
&&17&&&&&&&&&&&&&&&&&&&|&DEC_OP&unary_expression
&&18&&&&&&&&&&&&&&&&&&&|&unary_operator&cast_expression
&&19&&&&&&&&&&&&&&&&&&&|&SIZEOF&unary_expression
&&20&&&&&&&&&&&&&&&&&&&|&SIZEOF&'('&type_name&')'
&&21&&unary_operator&:&'&'
&&22&&&&&&&&&&&&&&&&&|&'*'
&&23&&&&&&&&&&&&&&&&&|&'+'
&&24&&&&&&&&&&&&&&&&&|&'-'
&&25&&&&&&&&&&&&&&&&&|&'~'
&&26&&&&&&&&&&&&&&&&&|&'!'
&&27&&cast_expression&:&unary_expression
&&28&&&&&&&&&&&&&&&&&&|&'('&type_name&')'&cast_expression
&&29&&multiplicative_expression&:&cast_expression
&&30&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&multiplicative_expression&'*'&cast_expression
&&31&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&multiplicative_expression&'/'&cast_expression
&&32&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&multiplicative_expression&'%'&cast_expression
&&33&&additive_expression&:&multiplicative_expression
&&34&&&&&&&&&&&&&&&&&&&&&&|&additive_expression&'+'&multiplicative_expression
&&35&&&&&&&&&&&&&&&&&&&&&&|&additive_expression&'-'&multiplicative_expression
&&36&&shift_expression&:&additive_expression
&&37&&&&&&&&&&&&&&&&&&&|&shift_expression&LEFT_OP&additive_expression
&&38&&&&&&&&&&&&&&&&&&&|&shift_expression&RIGHT_OP&additive_expression
&&39&&relational_expression&:&shift_expression
&&40&&&&&&&&&&&&&&&&&&&&&&&&|&relational_expression&'&'&shift_expression
&&41&&&&&&&&&&&&&&&&&&&&&&&&|&relational_expression&'&'&shift_expression
&&42&&&&&&&&&&&&&&&&&&&&&&&&|&relational_expression&LE_OP&shift_expression
&&43&&&&&&&&&&&&&&&&&&&&&&&&|&relational_expression&GE_OP&shift_expression
&&44&&equality_expression&:&relational_expression
&&45&&&&&&&&&&&&&&&&&&&&&&|&equality_expression&EQ_OP&relational_expression
&&46&&&&&&&&&&&&&&&&&&&&&&|&equality_expression&NE_OP&relational_expression
&&47&&and_expression&:&equality_expression
&&48&&&&&&&&&&&&&&&&&|&and_expression&'&'&equality_expression
&&49&&exclusive_or_expression&:&and_expression
&&50&&&&&&&&&&&&&&&&&&&&&&&&&&|&exclusive_or_expression&'^'&and_expression
&&51&&inclusive_or_expression&:&exclusive_or_expression
&&52&&&&&&&&&&&&&&&&&&&&&&&&&&|&inclusive_or_expression&'|'&exclusive_or_expression
&&53&&logical_and_expression&:&inclusive_or_expression
&&54&&&&&&&&&&&&&&&&&&&&&&&&&|&logical_and_expression&AND_OP&inclusive_or_expression
&&55&&logical_or_expression&:&logical_and_expression
&&56&&&&&&&&&&&&&&&&&&&&&&&&|&logical_or_expression&OR_OP&logical_and_expression
&&57&&conditional_expression&:&logical_or_expression
&&58&&&&&&&&&&&&&&&&&&&&&&&&&|&logical_or_expression&'?'&expression&':'&conditional_expression
&&59&&assignment_expression&:&conditional_expression
&&60&&&&&&&&&&&&&&&&&&&&&&&&|&unary_expression&assignment_operator&assignment_expression
&&61&&assignment_operator&:&'='
&&62&&&&&&&&&&&&&&&&&&&&&&|&MUL_ASSIGN
&&63&&&&&&&&&&&&&&&&&&&&&&|&DIV_ASSIGN
&&64&&&&&&&&&&&&&&&&&&&&&&|&MOD_ASSIGN
&&65&&&&&&&&&&&&&&&&&&&&&&|&ADD_ASSIGN
&&66&&&&&&&&&&&&&&&&&&&&&&|&SUB_ASSIGN
&&67&&&&&&&&&&&&&&&&&&&&&&|&LEFT_ASSIGN
&&68&&&&&&&&&&&&&&&&&&&&&&|&RIGHT_ASSIGN
&&69&&&&&&&&&&&&&&&&&&&&&&|&AND_ASSIGN
&&70&&&&&&&&&&&&&&&&&&&&&&|&XOR_ASSIGN
&&71&&&&&&&&&&&&&&&&&&&&&&|&OR_ASSIGN
&&72&&expression&:&assignment_expression
&&73&&&&&&&&&&&&&|&expression&','&assignment_expression
&&74&&constant_expression&:&conditional_expression
&&75&&declaration&:&declaration_specifiers&';'
&&76&&&&&&&&&&&&&&|&declaration_specifiers&init_declarator_list&';'
&&77&&declaration_specifiers&:&storage_class_specifier
&&78&&&&&&&&&&&&&&&&&&&&&&&&&|&storage_class_specifier&declaration_specifiers
&&79&&&&&&&&&&&&&&&&&&&&&&&&&|&type_specifier
&&80&&&&&&&&&&&&&&&&&&&&&&&&&|&type_specifier&declaration_specifiers
&&81&&&&&&&&&&&&&&&&&&&&&&&&&|&type_qualifier
&&82&&&&&&&&&&&&&&&&&&&&&&&&&|&type_qualifier&declaration_specifiers
&&83&&init_declarator_list&:&init_declarator
&&84&&&&&&&&&&&&&&&&&&&&&&&|&init_declarator_list&','&init_declarator
&&85&&init_declarator&:&declarator
&&86&&&&&&&&&&&&&&&&&&|&declarator&'='&initializer
&&87&&storage_class_specifier&:&TYPEDEF
&&88&&&&&&&&&&&&&&&&&&&&&&&&&&|&EXTERN
&&89&&&&&&&&&&&&&&&&&&&&&&&&&&|&STATIC
&&90&&&&&&&&&&&&&&&&&&&&&&&&&&|&AUTO
&&91&&&&&&&&&&&&&&&&&&&&&&&&&&|&REGISTER
&&92&&type_specifier&:&VOID
&&93&&&&&&&&&&&&&&&&&|&CHAR
&&94&&&&&&&&&&&&&&&&&|&SHORT
&&95&&&&&&&&&&&&&&&&&|&INT
&&96&&&&&&&&&&&&&&&&&|&LONG
&&97&&&&&&&&&&&&&&&&&|&FLOAT
&&98&&&&&&&&&&&&&&&&&|&DOUBLE
&&99&&&&&&&&&&&&&&&&&|&SIGNED
&100&&&&&&&&&&&&&&&&&|&UNSIGNED
&101&&&&&&&&&&&&&&&&&|&struct_or_union_specifier
&102&&&&&&&&&&&&&&&&&|&enum_specifier
&103&&&&&&&&&&&&&&&&&|&TYPE_NAME
&104&&struct_or_union_specifier&:&struct_or_union&IDENTIFIER&'{'&struct_declaration_list&'}'
&105&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&struct_or_union&'{'&struct_declaration_list&'}'
&106&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&struct_or_union&IDENTIFIER
&107&&struct_or_union&:&STRUCT
&108&&&&&&&&&&&&&&&&&&|&UNION
&109&&struct_declaration_list&:&struct_declaration
&110&&&&&&&&&&&&&&&&&&&&&&&&&&|&struct_declaration_list&struct_declaration
&111&&struct_declaration&:&specifier_qualifier_list&struct_declarator_list&';'
&112&&specifier_qualifier_list&:&type_specifier&specifier_qualifier_list
&113&&&&&&&&&&&&&&&&&&&&&&&&&&&|&type_specifier
&114&&&&&&&&&&&&&&&&&&&&&&&&&&&|&type_qualifier&specifier_qualifier_list
&115&&&&&&&&&&&&&&&&&&&&&&&&&&&|&type_qualifier
&116&&struct_declarator_list&:&struct_declarator
&117&&&&&&&&&&&&&&&&&&&&&&&&&|&struct_declarator_list&','&struct_declarator
&118&&struct_declarator&:&declarator
&119&&&&&&&&&&&&&&&&&&&&|&':'&constant_expression
&120&&&&&&&&&&&&&&&&&&&&|&declarator&':'&constant_expression
&121&&enum_specifier&:&ENUM&'{'&enumerator_list&'}'
&122&&&&&&&&&&&&&&&&&|&ENUM&IDENTIFIER&'{'&enumerator_list&'}'
&123&&&&&&&&&&&&&&&&&|&ENUM&IDENTIFIER
&124&&enumerator_list&:&enumerator
&125&&&&&&&&&&&&&&&&&&|&enumerator_list&','&enumerator
&126&&enumerator&:&IDENTIFIER
&127&&&&&&&&&&&&&|&IDENTIFIER&'='&constant_expression
&128&&type_qualifier&:&CONST
&129&&&&&&&&&&&&&&&&&|&VOLATILE
&130&&declarator&:&pointer&direct_declarator
&131&&&&&&&&&&&&&|&direct_declarator
&132&&direct_declarator&:&IDENTIFIER
&133&&&&&&&&&&&&&&&&&&&&|&'('&declarator&')'
&134&&&&&&&&&&&&&&&&&&&&|&direct_declarator&'['&constant_expression&']'
&135&&&&&&&&&&&&&&&&&&&&|&direct_declarator&'['&']'
&136&&&&&&&&&&&&&&&&&&&&|&direct_declarator&'('&parameter_type_list&')'
&137&&&&&&&&&&&&&&&&&&&&|&direct_declarator&'('&identifier_list&')'
&138&&&&&&&&&&&&&&&&&&&&|&direct_declarator&'('&')'
&139&&pointer&:&'*'
&140&&&&&&&&&&|&'*'&type_qualifier_list
&141&&&&&&&&&&|&'*'&pointer
&142&&&&&&&&&&|&'*'&type_qualifier_list&pointer
&143&&type_qualifier_list&:&type_qualifier
&144&&&&&&&&&&&&&&&&&&&&&&|&type_qualifier_list&type_qualifier
&145&&parameter_type_list&:&parameter_list
&146&&&&&&&&&&&&&&&&&&&&&&|&parameter_list&','&ELLIPSIS
&147&&parameter_list&:&parameter_declaration
&148&&&&&&&&&&&&&&&&&|&parameter_list&','&parameter_declaration
&149&&parameter_declaration&:&declaration_specifiers&declarator
&150&&&&&&&&&&&&&&&&&&&&&&&&|&declaration_specifiers&abstract_declarator
&151&&&&&&&&&&&&&&&&&&&&&&&&|&declaration_specifiers
&152&&identifier_list&:&IDENTIFIER
&153&&&&&&&&&&&&&&&&&&|&identifier_list&','&IDENTIFIER
&154&&type_name&:&specifier_qualifier_list
&155&&&&&&&&&&&&|&specifier_qualifier_list&abstract_declarator
&156&&abstract_declarator&:&pointer
&157&&&&&&&&&&&&&&&&&&&&&&|&direct_abstract_declarator
&158&&&&&&&&&&&&&&&&&&&&&&|&pointer&direct_abstract_declarator
&159&&direct_abstract_declarator&:&'('&abstract_declarator&')'
&160&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&'['&']'
&161&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&'['&constant_expression&']'
&162&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&direct_abstract_declarator&'['&']'
&163&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&direct_abstract_declarator&'['&constant_expression&']'
&164&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&'('&')'
&165&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&'('&parameter_type_list&')'
&166&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&direct_abstract_declarator&'('&')'
&167&&&&&&&&&&&&&&&&&&&&&&&&&&&&&|&direct_abstract_declarator&'('&parameter_type_list&')'
&168&&initializer&:&assignment_expression
&169&&&&&&&&&&&&&&|&'{'&initializer_list&'}'
&170&&&&&&&&&&&&&&|&'{'&initializer_list&','&'}'
&171&&initializer_list&:&initializer
&172&&&&&&&&&&&&&&&&&&&|&initializer_list&','&initializer
&173&&statement&:&labeled_statement
&174&&&&&&&&&&&&|&compound_statement
&175&&&&&&&&&&&&|&expression_statement
&176&&&&&&&&&&&&|&selection_statement
&177&&&&&&&&&&&&|&iteration_statement
&178&&&&&&&&&&&&|&jump_statement
&179&&labeled_statement&:&IDENTIFIER&':'&statement
&180&&&&&&&&&&&&&&&&&&&&|&CASE&constant_expression&':'&statement
&181&&&&&&&&&&&&&&&&&&&&|&DEFAULT&':'&statement
&182&&compound_statement&:&'{'&'}'
&183&&&&&&&&&&&&&&&&&&&&&|&'{'&statement_list&'}'
&184&&&&&&&&&&&&&&&&&&&&&|&'{'&declaration_list&'}'
&185&&&&&&&&&&&&&&&&&&&&&|&'{'&declaration_list&statement_list&'}'
&186&&declaration_list&:&declaration
&187&&&&&&&&&&&&&&&&&&&|&declaration_list&declaration
&188&&statement_list&:&statement
&189&&&&&&&&&&&&&&&&&|&statement_list&statement
&190&&expression_statement&:&';'
&191&&&&&&&&&&&&&&&&&&&&&&&|&expression&';'
&192&&selection_statement&:&IF&'('&expression&')'&statement
&193&&&&&&&&&&&&&&&&&&&&&&|&IF&'('&expression&')'&statement&ELSE&statement
&194&&&&&&&&&&&&&&&&&&&&&&|&SWITCH&'('&expression&')'&statement
&195&&iteration_statement&:&WHILE&'('&expression&')'&statement
&196&&&&&&&&&&&&&&&&&&&&&&|&DO&statement&WHILE&'('&expression&')'&';'
&197&&&&&&&&&&&&&&&&&&&&&&|&FOR&'('&expression_statement&expression_statement&')'&statement
&198&&&&&&&&&&&&&&&&&&&&&&|&FOR&'('&expression_statement&expression_statement&expression&')'&statement
&199&&jump_statement&:&GOTO&IDENTIFIER&';'
&200&&&&&&&&&&&&&&&&&|&CONTINUE&';'
&201&&&&&&&&&&&&&&&&&|&BREAK&';'
&202&&&&&&&&&&&&&&&&&|&RETURN&';'
&203&&&&&&&&&&&&&&&&&|&RETURN&expression&';'
&204&&translation_unit&:&external_declaration
&205&&&&&&&&&&&&&&&&&&&|&translation_unit&external_declaration
&206&&external_declaration&:&function_definition
&207&&&&&&&&&&&&&&&&&&&&&&&|&declaration
&208&&function_definition&:&declaration_specifiers&declarator&declaration_list&compound_statement
&209&&&&&&&&&&&&&&&&&&&&&&|&declaration_specifiers&declarator&compound_statement
&210&&&&&&&&&&&&&&&&&&&&&&|&declarator&declaration_list&compound_statement
&211&&&&&&&&&&&&&&&&&&&&&&|&declarator&compound_statement
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：711120次
积分：12875
积分：12875
排名：第1121名
原创：288篇
转载：1964篇
评论：11条
(36)(172)(194)(52)(5)(149)(32)(85)(164)(258)(112)(24)(403)(199)(1)(10)(76)(283)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'