Bison “的含义<*&燃气轮机&引用；在莱克斯

我知道，我们可以在lex中定义一些条件，匹配：

1.<DIRECTIVE>{STRING} {printf("Matching the DIRECTIVE state!");}
2.<REFERENCE>{INTEGER} {printf("Matching the REFERNCE state!");}
3.[\n] {printf("Matching the INITIAL state?");}

4.<*>{DOBULE} {printf("Matching all state include INITIAL? Seem not!");}

1.{STRING}{printf（“匹配指令状态！”）；}
2.{INTEGER}{printf（“匹配引用状态！”）；}
3.[\n]{printf（“匹配初始状态？”）；}
4.{DOBULE}{printf（“匹配所有状态包括首字母？似乎不！”）；}

如何以正确的方式使用状态？3号线和4号线的条件有什么不同

整个.l文件，由我剪切，现在它只是为了实现一个引用。当我运行它时，它可以很好地工作，但它总是说“行：4：错误：语法错误”，最后，我不知道为什么！我的test.vm只有两行文本

%{
/**支持了所有的token,不支持转义和多行注释*/
#include<stdio.h>
#include<string.h>
#include "context.h"
#include "bool.h"
#include "vtl4.tab.h"

extern int yylex();
/**bracket标志*/
int bracket_flag = 0;
/**引用标志*/
int ref_flag = 0;
/**多行注释标记*/
int mul_comment_flag = 0;
%}
%option stack
%option noyywrap yylineno

%x REF
VAR_NAME ([_a-zA-Z]+[a-zA-Z0-9_\-]*)
%%
/**这里去除$#\n防止覆盖状态REF和DIRECTIVE*/
[^$\n#]*? {printf("text:%s\n",yytext);yylval.string = yytext; return CONTENT;}
/**换行单独取出来，还没清楚为什么*/
\n {printf("newLine:%s\n",yytext);yylval.string = yytext; return CONTENT;}

/**添加^$防止只匹配最后一个变量
 例如：<p class="$b">$a $b</p> 只匹配了最后一个$b
 */
[^#$]*?/"$" {BEGIN REF;printf("begin ref text:%s\n",yytext);yylval.string = yytext; return       CONTENT;}

<REF>"$"|"$!"/"{"?{VAR_NAME} {ref_flag++;printf("$:%s\n",yytext);return DOLLAR;}
<REF>"{" {printf("{:%s\n",yytext);return BRACE;}
<DIRECTIVE>"}" {printf("}:%s\n",yytext);return BRACE_CLOSE;}
<REF>{VAR_NAME}/[^0-9A-Za-z_\-] {
    printf("ref name:%s\n",yytext);
    ref_flag--;
    yylval.sym = find_symbol(yytext);
    return ID;
}
<REF>[ /t"="\n] {BEGIN INITIAL; printf("ref end:%s\n",yytext);}
<REF>[}] {printf("}:%s\n",yytext);return BRACE_CLOSE;}

<<EOF>> {printf("lex end:%s\n",yytext);return LEX_EOF;}
%%

%{
/**支持了所有的代币不支持转义和多行注释*/
#包括
#包括
#包括“context.h”
#包括“bool.h”
#包括“vtl4.tab.h”
extern int yylex（）；
/**括号标志*/
int括号_标志=0；
/**引用标志*/
int ref_标志=0；
/**多行注释标记*/
int mul_comment_标志=0；
%}
%选项堆栈
%选项编号yyyylineno
%x参考
变量名称（[[U a-zA-Z]+[a-zA-Z0-9\-]*）
%%
/**这里去除$#\N防止覆盖状态裁判和指示*/
[^$\n#]*？{printf（“文本：%s\n”，yytext）；yylval.string=yytext；返回内容；}
/**换行单独取出来，还没清楚为什么*/
\n{printf（“换行符：%s\n”，yytext）；yylval.string=yytext；返回内容；}
/**添加^$防止只匹配最后一个变量
例如：
$a$b
只匹配了最后一个$B
*/
[^#$]*？/“$”{BEGIN REF；printf（“BEGIN REF text:%s\n”，yytext）；yylval.string=yytext；返回内容；}
“$”|“$！”/“{”{”{VAR_NAME}{ref_flag++；printf（$：%s\n），yytext）；返回美元；}
{{printf（“{:%s\n”，yytext）；返回大括号；}
“}”{printf（“}:%s\n”，yytext）；返回大括号\u CLOSE；}
{VAR_NAME}/[^0-9A-Za-z\-]{
printf（“参考名称：%s\n”，yytext）；
参考标志--；
yylval.sym=查找符号（yytext）；
返回ID；
}
[/t“=”\n]{BEGIN INITIAL；printf（“ref end:%s\n”，yytext）；}
[}]{printf（“}:%s\n”，yytext）；返回大括号_CLOSE；}
{printf（“lex end:%s\n”，yytext）；返回lex_EOF；}
%%

整个.y文件：

%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bool.h"
#include "parser.h"
#include "context.h"
#include "vtl4.tab.h"

extern FILE * yyin;
extern FILE * yyout;
int yylex();
#define YYDEBUG 1
%}
/*priority level*/
%union {
struct simpleNode *ast;
double d;
int i;
bool b;
char* string;
struct symbol *sym;
}

%token ADD SUB MUL DIV MOD EQUAL PARENTHESIS CLOSE_PARENTHESIS BRACE BRACE_CLOSE  LOGICAL_AND LOGICAL_OR LOGIC_EQUAL LOGICAL_LT LOGICAL_LE LOGICAL_GT LOGICAL_GE LOGICAL_NOT_EQUALS

%token  LEX_EOF

%token <string> CONTENT STRING_LITERAL SINGLE_LINE_COMMENT MULTI_LINE_COMMENT
%token <b> BOOL

%token INTEGER_LITERAL

%token <d> DOUBLE_LITERAL

%token DOLLAR

%token <sym> ID

%token HASH SET PARSE IF ELSE ELSEIF FOREACH IN END

%type <ast> root statements statement reference content

%start root

%%
/*JJTPROCESS*/
root:statements LEX_EOF {printf("yacc root\n");$$ = process($1);}
;

statements
: statement {printf("yacc statements:statement\n"); $$ = $1; }
| statements statement {printf("yacc statements:statements statement\n"); $$ =     add_ybrother($1,$2);}
;

statement
 : reference {printf("yacc statement:ref\n"); $$ = $1;}
| content
;

reference
: DOLLAR ID {printf("yacc ref\n");$$ = reference($2);}
 ;

content
: CONTENT {$$ = text(NULL);}
;

%%
int main(){
printf("BEGIN:\n");
FILE *src;
src = fopen("test.vm","r");
yyin = src;
int result = yyparse();
fclose(src);
return result;
}

%{
#包括
#包括
#包括
#包括“bool.h”
#包括“parser.h”
#包括“context.h”
#包括“vtl4.tab.h”
外部文件*yyin；
外部文件*yyout；
int-yylex（）；
#定义调试1
%}
/*优先级别*/
%联合{
结构simpleNode*ast；
双d；
int i；
布尔b；
字符*字符串；
结构符号*sym；
}
%标记ADD SUB MUL DIV MOD EQUAL圆括号闭合圆括号大括号闭合逻辑和逻辑或逻辑等于逻辑逻辑逻辑不等于
%令牌LEX_EOF
%令牌内容字符串文字单行注释多行注释
%令牌布尔
%令牌整数
%标记双_字面值
%代币
%令牌ID
%令牌哈希集PARSE IF ELSEIF FOREACH结束
%类型根语句语句引用内容
%起始根
%%
/*JJT过程*/
root：语句LEX_EOF{printf（“yacc root\n”）；$$=process（$1）；}
;
声明
：语句{printf（“yacc语句：语句\n”）；$$=$1；}
|语句语句{printf（“yacc语句：语句语句\n”）；$$=add_ybrother（$1，$2）；}
;
陈述
：reference{printf（“yacc语句：ref\n”）；$$=$1；}
|内容
;
参考
：美元ID{printf（“yacc ref\n”）；$$=参考（$2）；}
;
内容
：内容{$$=text（NULL）；}
;
%%
int main（）{
printf（“开始：\n”）；
文件*src；
src=fopen（“test.vm”、“r”）；
yyin=src；
int result=yyparse（）；
fclose（src）；
返回结果；
}

首先，启动条件不是Lex的特征。它们是GNUflex的一个特性

语法

确实被记录为“此规则将在任何状态下无条件触发”

您可能知道，条件可以是独占的（用

%x

定义）或包含的（用

%s

定义）

如果在没有任何条件的情况下编写规则，则该规则在

初始状态下处于活动状态，并且在包含的任何状态下也处于活动状态：包含表示“在此状态下不指定任何条件的规则将处于活动状态”

如果当前状态为独占状态，则不带任何条件的规则不处于活动状态：它排除了不带条件的规则

语法意味着规则将在所有状态下激活，包括独占状态

如果规则没有
条件语法，则表示该规则将仅在
初始状态或包含的状态下激活

在解析器中仍然有很多错误。请记住，最长的匹配规则是在输入中的任何点触发的规则，可能会被误解为启动条件不起作用。如果输入是
catalog
，并且某个符合条件的规则想要匹配
cat
，那么匹配
c
的规则是否具有
属性并不重要。这不是最长的匹配。
首先，启动条件不是Lex的特性。它们是GNUflex的一个特性

语法
确实被记录为“此规则将在任何状态下无条件触发”

您可能知道，条件可以是独占的（用
%x
定义）或包含的（用
%s
定义）

如果在没有任何条件的情况下编写规则，则该规则在
初始状态下处于活动状态，并且在包含的任何状态下也处于活动状态：包含表示“在此状态下不指定任何条件的规则将处于活动状态”

如果当前状态为独占状态，则不带任何条件的规则不处于活动状态：它排除了不带条件的规则

语法意味着规则将在所有状态下激活，包括独占状态

如果规则没有
条件语法，则表示该规则将仅在
初始状态或包含的状态下激活

在解析器中仍然有很多错误。请记住，最长的匹配规则是在输入中的任何点触发的规则，可能会被误解为启动条件不起作用。如果输入为
cat