正则语言引擎：一个简单LEX和YACC结合运用的实例

发布时间：2020-12-14 00:37:15 所属栏目：百科来源：网络整理

导读：本文先描述了 LEX 与 YACC 的书写方法。然后利用 LEX 与 YACC 编写了一个简单正则语言的引擎（暂时不支持闭包与或运算），生成的中间语言为 C语言。正则引擎应直接生成NFA或DFA模拟器的输入文件，但在SDT的设计上就走的是增加，修改状态节点。而本文则采用

本文先描述了LEX与YACC的书写方法。然后利用LEX与YACC编写了一个简单正则语言的引擎（暂时不支持闭包与或运算），生成的中间语言为C语言。
正则引擎应直接生成NFA或DFA模拟器的输入文件，但在SDT的设计上就走的是增加，修改状态节点。而本文则采用类似语言编译器，翻译生产对应C语言的语句。

熟悉LEX和YACC工具

lex工具简介

lex格式

[第一部分：定义段]
%% [第二部分：词法规则段] %%
[第三部分：辅助函数段]

第一部分

Part1.1

第一部分以符号%{和%}包裹，里面为以C语法写的一些定义和声明
例如，文件包含，宏定义，常数定义，全局变量及外部变量定义，函数声明等。
这一部分被Lex翻译器处理后会全部拷贝到文件lex.yy.c中。
注意，特殊括号%{和%}都必须顶着行首写。

%{
    #include <ctype.h>
    char tokenString[MAXTOKENLEN+1];
%}

Part1.2

第二部分是一组正规定义和状态定义。
正规定义是为了简化后面的词法规则而给部分正规式定义了名字。
每条正规定义也都要顶着行首写。

digit       [0-9]
number      {digit}+
letter      [a-zA-Z]
identifier  {letter}+
newline     n
whitespace  [ t]+

状态定义也叫环境定义，它定义了匹配正规式时所处的状态的名字。
状态定义以%s开始，后跟所定义的状态的名字，注意%s也要顶行首写。
例如下面一行就定义了一个名为COMMENT的状态和一个名为BAD的状态，状态名之间用空白分隔：

%s COMMENT BAD

第二部分

词法规则段列出的是词法分析器需要匹配的正规式，以及匹配该正规式后需要进行的相关动作。

"if"            {return IF;}
"then"          {return THEN;}
"else"          {return ELSE;}

每行都是一条规则，该规则的前一部分是正规式，需要顶行首写。
后一部分是匹配该正规式后需要进行的动作，这个动作是用C语法来写的，被包裹在{}之内，被Lex翻译器翻译后会被直接拷贝进lex.yy.c。
正规式和语义动作之间要有空白隔开。其中用{}扩住的正规式表示正规定义的名字。
也可以若干个正规式匹配同一条语义动作，此时正规式之间要用 | 分隔。

第三部分

辅助函数段用C语言语法来写，辅助函数一般是在词法规则段中用到的函数。这一部分一般会被直接拷贝到lex.yy.c中。

LEX中的变量

yyin和yyout：这是Lex中本身已定义的输入和输出文件指针。这两个变量指明了lex生成的词法分析器从哪里获得输入和输出到哪里。默认：键盘输入，屏幕输出。
yytext和yyleng：这也是lex中已定义的变量，直接用就可以了。
yytext：指向当前识别的词法单元（词文）的指针
yyleng：当前词法单元的长度。
ECHO：Lex中预定义的宏，可以出现在动作中，相当于fprintf(yyout,“%s”,yytext)，即输出当前匹配的词法单元。
yylex()：词法分析器驱动程序，用Lex翻译器生成的lex.yy.c内必然含有这个函数。
yywrap()：词法分析器遇到文件结尾时会调用yywrap()来决定下一步怎么做：
若yywrap()返回0，则继续扫描
若返回1，则返回报告文件结尾的0标记。
由于词法分析器总会调用yywrap，因此辅助函数中最好提供yywrap，如果不提供，则在用C编译器编译lex.yy.c时，需要链接相应的库，库中会给出标准的yywrap函数（标准函数返回1）

一个简易的词法分析器

保留字有

int float main return while do if else for

符号有

< <= = <> > >= + - * / ( ) { } ;

双引号内容当作MSG整体。

书写lex分析程序如下：

%{
    #include <stdio.h>
    #include <stdlib.h> 
    #define LT 1
    #define LE 2
    #define GT 3
    #define GE 4
    #define EQ 5
    #define NE 6

    #define WHILE 18
    #define DO 19
    #define ID 20
    #define NUMBER 21
    #define RELOP 22
    #define NEWLINE 23
    #define IF 24
    #define ELSE 25
    #define FOR 26

    #define PLUS 27
    #define MINUS 28
    #define TIMES 29
    #define OVER 30
    #define LPAREN 31
    #define RPAREN 32
    #define SEMI 33
    #define OP 34

    #define LBRACE 35
    #define RBRACE 36

    #define INT 37
    #define MAIN 38
    #define RETURN 39
    #define FLOAT 40
    #define MSG 41

    #define ERRORCHAR 42

    int yylval;
    int installID ();
    int installNum ();
%}

delim       [ t n]
ws          {delim}+
letter      [A-Za-z_]
digit       [0-9]
id          {letter}({letter}|{digit})*
number      {digit}+(.{digit}+)?(E[+-]?{digit}+)?

%%

{ws}          {;}
int           {return (INT);}
float         {return (FLOAT);}
main          {return (MAIN);}
return        {return (RETURN);}
while         {return (WHILE);}
do            {return (DO);}
if            {return (IF);}
else          {return (ELSE);}
for           {return (FOR);}
{id}          {yylval = installID (); return (ID);}
{number}      {yylval = installNum (); return (NUMBER);}
"<"           {yylval = LT; return (RELOP);}
"<="          {yylval = LE; return (RELOP);}
"="           {yylval = EQ; return (RELOP);}
"<>"          {yylval = NE; return (RELOP);}
">"           {yylval = GT; return (RELOP);}
">="          {yylval = GE; return (RELOP);}
"+"           {yylval = PLUS; return (OP);}
"-"           {yylval = MINUS; return (OP);}
"*"           {yylval = TIMES; return (OP);}
"/"           {yylval = OVER; return (OP);}
"("           {return LPAREN;}
")"           {return RPAREN;}
";"           {return SEMI;}
"{"           {return LBRACE;}
"}"           {return RBRACE;}
"""          { 
                  char c;
                  int i = 0;
                  do{
                        yytext[i++]=c;
                        c = input();
                  } while (c != '"');
                        yytext[i]='';
                        return MSG;
              }
.                 {yylval = ERRORCHAR; return ERRORCHAR;}

%%
int installID () {
    return ID;
}


int installNum () {
  return NUMBER;
}

int yywrap (){
  return 1;
}

void writeout(int c){
  switch(c){
    case ERRORCHAR: fprintf(yyout,"(ERRORCHAR,"%s") ",yytext);break;
    case RELOP: fprintf(yyout,"(RELOP,yytext);break;     
    case WHILE: fprintf(yyout,"(WHILE,yytext);break;
    case DO: fprintf(yyout,"(DO,yytext);break;
    case NUMBER: fprintf(yyout,"(NUM,yytext);break;
    case ID: fprintf(yyout,"(ID,yytext);break;
    case NEWLINE: fprintf(yyout,"n");break;
    case IF: fprintf(yyout,"(IF,yytext);break;
    case ELSE: fprintf(yyout,"(ELSE,yytext);break;
    case FOR: fprintf(yyout,"(FOR,yytext);break;
    case PLUS:fprintf(yyout,"(PLUS,yytext);break;
    case MINUS:fprintf(yyout,"(MINUS,yytext);break;
    case OVER:fprintf(yyout,"(OVER,yytext);break;
    case LPAREN:fprintf(yyout,"(LPAREN,yytext);break;
    case RPAREN:fprintf(yyout,"(RPAREN,yytext);break;
    case SEMI:fprintf(yyout,"(SEMI,yytext);break;
    case LBRACE:fprintf(yyout,"(LBRACE,yytext);break;
    case RBRACE:fprintf(yyout,"(RBRACE,yytext);break;
    case INT:fprintf(yyout,"(INT,yytext);break;
    case MAIN:fprintf(yyout,"(MAIN,yytext);break;
    case RETURN:fprintf(yyout,"(RETURN,yytext);break;
    case FLOAT:fprintf(yyout,"(FLOAT,yytext);break;
    case MSG:fprintf(yyout,"(MSG,yytext);break;
    case OP:{
        switch(yylval){
        case PLUS: fprintf(yyout,yytext);break;
        case MINUS: fprintf(yyout,yytext);break;
        case TIMES: fprintf(yyout,"(TIMES,yytext);break;
        case OVER: fprintf(yyout,yytext);break;
        }
    };break;
    default:fprintf(yyout,"(我不知道发生了什么，但是你大概是写错了. "%s") ",yytext);break;
  }
  return;
}

int main (int argc,char* argv[]){
    int c,j=0;
    if (argc>=2){
      if ((yyin = fopen(argv[1],"r")) == NULL){
        printf("Can't open file %sn",argv[1]);
        return 1;
      }
      if (argc>=3){
        yyout=fopen(argv[2],"w");
      }
    }
    else{
        printf("Usage:./scanner [source file] [dst file]n");
        exit(0);
    }
    while ((c = yylex())!=0){
        writeout(c);
        writeout(NEWLINE);
    }
    if(argc>=2){
      fclose(yyin);
      if (argc>=3) fclose(yyout);
    }
    return 0;
}

学习YACC工具

Yacc 代表 Yet Another Compiler Compiler。 Yacc 的 GNU 版叫做 Bison。

它是一种工具，将任何一种编程语言的所有语法翻译成针对此种语言的 Yacc 语法解析器。
它用巴科斯范式(BNF,Backus Naur Form)来书写。
按照惯例，Yacc 文件有 .y 后缀。

引用网上的一个比喻

为了更加说清这一概念，让我们以英语为例。这一套标记可能是：名词,动词,形容词等等。为了使用这些标记造一个语法正确的句子，你的结构必须符合一定的规则。一个简单的句子可能是名词+动词或者名词+动词+名词。(如 I care. See spot run.)

创建有四个步骤

通过在语法文件上运行 Yacc 生成一个解析器。
说明语法：
- 编写一个 .y 的语法文件（同时说明 C 在这里要进行的动作）。
- 编写一个词法分析器来处理输入并将标记传递给解析器。这可以使用 Lex 来完成。
- 编写一个函数，通过调用 yyparse() 来开始解析。
- 编写错误处理例程（如 yyerror()）
编译 Yacc 生成的代码以及其他相关的源文件。
将目标文件链接到适当的可执行解析器库。

YACC 语法规则

Yacc 语法规则具有以下一般格式：

result: components { /* action to be taken in C */ };

在这个例子中，result 是规则描述的非终端符号。Components 是根据规则放在一起的不同的终端和非终端符号。如果匹配特定序列的话 Components 后面可以跟随要执行的动作。

param : NAME EQ NAME { printf("tName:%stValue(name):%sn",$1,$3);}
      | NAME EQ VALUE{ printf("tName:%stValue(value):%sn",$3);}
      ;

如果上例中序列 NAME EQ NAME 被匹配，将执行相应的 { } 括号中的动作。这里另一个有用的就是 $1 和 $3 的使用,它们引用了标记 NAME 和 NAME（或者第二行的 VALUE）的值。

lexer 通过 Yacc 的变量 yylval 返回这些值。标记 NAME 的 Lex 代码是这样的：

char [A-Za-z]
name {char}+
%%
{name} { yylval = strdup(yytext);
         return NAME; }

文件解析例子的规则段是这样的：

文件解析的语法

file : record file
     | record
     ;
record: NAME EQ AGE { printf("%s is now %s years old!!!",$3);};
%%

一般来说，Yacc 最好提供 yyerror(char msg) 函数的代码。当解析器遇到错误时调用 yyerror(char msg)。错误消息作为参数来传递。一个简单的 yyerror( char* ) 可能是这样的：

int yyerror(char* msg){
    printf("Error: %s encountered at line number:%dn",msg,yylineno);
}

用LEX和YACC工具分析正则表达式

正则语言的词法定义

全集为ANCII码33-126的所有字符和空

元符号有

d_quotation   "
backslash     /
l_parentheses (
r_parentheses )
l_square_brack  [
r_square_brack  ]
l_curly_braces    {
r_curly_braces    }
star          *
plus          +
horizontal_line   -
dot               .
question_mark ?
vertical_line |
caret         ^
equal         =
empty         ε
blank         [trn]+

写出其词法分析器为

%{
    #include <stdio.h>
    #include <string.h>
    #define LETTER 1
    #define D_QUOTATION 2
    #define BACKSLASH 3
    #define L_PARENTHESES 4
    #define R_PARENTHESES 5
    #define L_SQUARE_BRACK 6
    #define R_SQUARE_BRACK 7
    #define L_CURLY_BRACES 8
    #define R_CURLY_BRACES 9
    #define STAR 10
    #define PLUS 11
    #define HORIZONTAL_LINE 12
    #define DOT 13
    #define QUESTION_MARK 14
    #define VERTICAL_LINE 15
    #define CARET 16
    #define EQUAL 17
    #define EMPTY 18
    #define BLANK 19
%}


allset          [!-~]
blank           [trn]+

%%
"""        {return (D_QUOTATION);}
""        {return (BACKSLASH);}
"("         {return (L_PARENTHESES);}
")"         {return (R_PARENTHESES);}
"["         {return (L_SQUARE_BRACK);}
"]"         {return (R_SQUARE_BRACK);}
"{"         {return (L_CURLY_BRACES);}
"}"         {return (R_CURLY_BRACES);}
"*"         {return (STAR);}
"+"         {return (PLUS);}
"-"         {return (HORIZONTAL_LINE);}
"."         {return (DOT);}
"?"         {return (QUESTION_MARK);}
"|"         {return (VERTICAL_LINE);}
"^"         {return (CARET);}
"="         {return (EQUAL);}
"ε"         {return (EMPTY);}
{blank}     {return (BLANK);}
{allset}    {return (LETTER);}

%%

int yywrap(){
    return 1;
}


int main (int argc,j=0;
    if (argc>=2){
        if ((yyin = fopen(argv[1],"r")) == NULL){
            printf("Can't open file %sn",argv[1]);
            return 1;
        }
    }
    else{
        printf("Usage:./scanner [source file] [dst file]n");
        exit(0);
    }
    while ((c = yylex())!=0){
        printf("%dn",c);
    }
    fclose(yyin);
    return 0;
}

简单测试RE的词法分析器

正则表达式的语法规则

可以用字母开头的字母数字串来作为标识符命名正则表达式。在使用名字的时候要加花括号，如

binary = (0|1)+
real = {integer}.{nature}

正则表达式的上下文无关文法为

# List表示多个正则表达式的列表
List → List Named_RE | Named_RE
# Name_RE表示命名或未命名的正则表达式
Named_RE → ID = RE | RE
# RE 表示正则表达式
RE → RE “|” No_Select | No_Select
# No_Select表示不包含选择运算的正则表达式
No_Select → No_Select No_Join | No_Join
# No_Join表示不包含选择或者连接运算的正则表达式
No_Join → Base | Base * | Base + | Base ?
# Base表示最基本的正则表达式
Base → ( RE ) | LETTER | [No_Select] | "No_select " | . | { ID } 
# ID表示标识符
ID → ID <letter> | ID <number> | <letter>

根据这些规则写的CFG:

%token D_QUOTATION BACKSLASH L_PARENTHESES R_PARENTHESES L_SQUARE_BRACK
       R_SQUARE_BRACK L_CURLY_BRACES R_CURLY_BRACES STAR PLUS HORIZONTAL_LINE
       DOT QUESTION_MARK VERTICAL_LINE CARET EQUAL EMPTY RE_LETTER LETTER
       NUMBER BLANK

%%
List        : Named_RE {printf("Finish one linennn");} List 
            | Named_RE {printf("Finish prog! End!nn");}
            ;
Named_RE    : ID EQUAL {printf("Find an IDnn");} RE BLANK
            | RE {printf("Find an REn");} BLANK
            ;
RE          : RE VERTICAL_LINE {printf("Finish VERTICAL_LINEn");} No_Select
            | { printf("%d No_select startn",debug_i); debug_i++;} 
              No_Select 
              { printf("Finish %d No_Selectn",debug_i);debug_i--;}
            ;
No_Select   : No_Join {printf("Find next joinn");} No_Join
            | No_Join {printf("End of No_Selectn");}
            ;
No_Join     : Base
            | Base STAR
            | Base PLUS
            | Base QUESTION_MARK
            ;
Base        : L_PARENTHESES RE R_PARENTHESES
            | L_SQUARE_BRACK RE R_SQUARE_BRACK
            | D_QUOTATION No_Select D_QUOTATION
            | L_CURLY_BRACES ID {printf("Confirm an IDn");} R_CURLY_BRACES
            | DOT
            | LETTER
            | NUMBER
            | RE_LETTER
            ;
ID          : ID LETTER
            | ID NUMBER
            | LETTER
            ;
%%

尝试出现很多conflict ，利用Yacc -v生成查错log。

Yacc工具利用的是LALR文法，生成的查错报告也是将整个LALR打印在文件中。

文件的前一部分为归约规则，如下：

0 $accept: List $end

    1 @1: /* empty */

    2 List: Named_RE @1 List
    3     | Named_RE
    ...

中间部分为每个状态的意义与GOTO与ACTION表

state 20

   13 No_Select: No_Join . @6 No_Join
   14          | No_Join .

    D_QUOTATION     reduce using rule 12 (@6)
    D_QUOTATION     [reduce using rule 14 (No_Select)]
    R_PARENTHESES   reduce using rule 14 (No_Select)
    R_SQUARE_BRACK  reduce using rule 14 (No_Select)
    VERTICAL_LINE   reduce using rule 14 (No_Select)
    BLANK           reduce using rule 14 (No_Select)
    $default        reduce using rule 12 (@6)

    @6  go to state 32

可以看到，在状态20中，遇到D_QUOTATION有冲突。

为了解决这个问题，这里简单处理，舍弃其中的一条规则。我的语言只ID = RE的表达形式

但是对于引号的判断还是有问题，修改引号部分如下：

Base        : L_PARENTHESES RE R_PARENTHESES
            | L_SQUARE_BRACK SQUARE_PART R_SQUARE_BRACK
            | D_QUOTATION QUOTA_PART D_QUOTATION
            | L_CURLY_BRACES ID R_CURLY_BRACES
            | DOT
            | LETTER
            | NUMBER 
            | RE_LETTER 
            ;
QUOTA_PART  :  QUOTA_PART LETTER 
            |  LETTER
            ;

解决YACC冲突有以下方法：

仔细选择书写的先后顺序，YACC默认移入/归约冲突时移入，归约/归约时选第一条。

一般我们的语言可以选择最长匹配。
如同上面引号，引入新的非终结符来解决冲突。

最终的RE.y文件中的CFG

%token D_QUOTATION BACKSLASH L_PARENTHESES R_PARENTHESES L_SQUARE_BRACK
       R_SQUARE_BRACK L_CURLY_BRACES R_CURLY_BRACES STAR PLUS HORIZONTAL_LINE
       DOT QUESTION_MARK VERTICAL_LINE CARET EQUAL EMPTY RE_LETTER LETTER
       NUMBER BLANK

%%
List        : Named_RE {printf("======Finish one line======nnn");}  List 
            | Named_RE {printf("======Finish prog! End!======n");}
            ;
Named_RE    : ID EQUAL {printf("==Find an ID==nn");} RE {printf("==Find a RE==nn");} BLANK
            ;
RE          : RE VERTICAL_LINE {printf("Finish VERTICAL_LINEn");} No_Select
            | { printf("%d No_select startn",debug_i); debug_i--;}
            ;
No_Select   : No_Select {printf("Find next joinn");} No_Join
            | No_Join {printf("End of No_Selectn");}
            ;
No_Join     : Base
            | Base STAR
            | Base PLUS
            | Base QUESTION_MARK
            ;
Base        : L_PARENTHESES RE R_PARENTHESES
            | L_SQUARE_BRACK SQUARE_PART R_SQUARE_BRACK
            | D_QUOTATION QUOTA_PART {printf("QUOTATION ENDn");}
            | L_CURLY_BRACES ID {printf("Confirm an IDnn");} R_CURLY_BRACES
            | DOT
            | LETTER
            | NUMBER
            | RE_LETTER
            ;
QUOTA_PART  :  LETTER QUOTA_PART
            |  LETTER D_QUOTATION
            ;
SQUARE_PART : LETTER HORIZONTAL_LINE LETTER
            | NUMBER HORIZONTAL_LINE NUMBER
            ;

ID          : ID LETTER
            | ID NUMBER
            | LETTER
            ;
%%

输入测试文件

letter = [A-Z]
number = [0-9]
id = ({letter}_)+({number}|{letter})*

测试结果

TOKEN:LETTER
TOKEN:LETTER
TOKEN:LETTER
TOKEN:LETTER
TOKEN:LETTER
TOKEN:LETTER
 TOKEN:EQUAL
==Find an ID==

0 No_select start
 TOKEN:L_SQUARE_BRACK
TOKEN:LETTER
TOKEN:HORIZONTAL_LINE
TOKEN:LETTER
TOKEN:R_SQUARE_BRACK
TOKEN:BLANK
End of No_Select
Finish 1 No_Select
==Find a RE==

TOKEN:LETTER
======Finish one line======

...# 后面略去
======Finish prog! End!======

生成中间语言(C语言)

考虑直接使用控制流的执行难度，这里用了正则语言的一个子集，去除了所有NFA的不确定的东西。

由于YACC中生成的头文件中默认为自己定义的YYSTYPE，这里需要在Makefile里面修改该关键字

Makefile如下：

CC = gcc
test:parse example
    ./parse example
    gcc out.c -o test
parse:lex.yy.c y.tab.c
    gcc lex.yy.c y.tab.c -o parse
y.tab.c:RE.y
    yacc -d RE.y
    cp y.tab.h{,.tmp}
    sed 's/typedef int YYSTYPE/typedef char* YYSTYPE/' y.tab.h.tmp > y.tab.h
    rm y.tab.h.tmp
lex.yy.c:RE.l
    flex RE.l
clean:
    -rm out.c
    -rm test
    -rm parse
    -rm lex.yy.c
    -rm y.tab.c

Re.y中的语法定义部分如下：

%%

List        : Named_RE  List 
            | Named_RE 
            ;
Named_RE    : ID { printf("== Find an ID ==> %s ==nn",$1); gen_id($1); } 
              EQUAL RE {printf("== Find a RE== nn"); gen_id_trail();} BLANK
            ;
RE          : { printf("%d No_select startn",debug_i); debug_i--;}
            ;
No_Select   : No_Select {printf("Find next joinn");} No_Join {base_i++;}
            | No_Join {base_i++;printf("End of No_Selectn");}
            ;
No_Join     : Base
            ;
Base        : L_PARENTHESES RE R_PARENTHESES
            | L_SQUARE_BRACK SQUARE_PART R_SQUARE_BRACK
            | D_QUOTATION QUOTA_PART {printf("= QUOTATION %s =n",$2);gen_quote($2);} D_QUOTATION
            | L_CURLY_BRACES ID {printf("= Call an ID %s =n",$2);gen_call($2);} R_CURLY_BRACES
            | DOT {gen_dot();}
            | LETTER {gen_next($1);}
            | NUMBER {gen_next($1);}
            | RE_LETTER {gen_next($1);}
            ;
QUOTA_PART  :  QUOTA_PART LETTER {strcat($1,$2);}
            |  LETTER
            |  QUOTA_PART NUMBER {strcat($1,$2);}
            |  NUMBER
            ;
SQUARE_PART : LETTER HORIZONTAL_LINE LETTER {gen_square($1,$3);}
            | NUMBER HORIZONTAL_LINE NUMBER {gen_square($1,$3);}
            ;
ID          : ID LETTER {strcat($1,$2);}
            | ID NUMBER {strcat($1,$2);}
            | LETTER
            ;
%%

int main(int argc,char* argv[]){
    if(argc == 2){
        yyin = fopen(argv[1],"r");
        if(yyin == NULL){
            printf("Cannot open file!n");
            exit(0);
        }
        outfile = fopen("out.c","w");
        gen_head();
        yyparse();
        gen_main();
        fclose(outfile);
    }
    else{
        printf("Usage:./test [filename]n");
    }
    return 0;
}

int yyerror(char *msg){
    printf("Error encountered: %s n",msg);
    return 0;
}

其中用于生成C语言中间代码的功能函数如下：

void gen_main(){
    fprintf(outfile,"int main(int argc,char* argv[]){n");
    fprintf(outfile,"tcur_pos = 0;n");
    fprintf(outfile,"tif(argc == 2){n");
    fprintf(outfile,"ttstrcpy(in_str,argv[1]);n");
    fprintf(outfile,"tttarget();n");
    fprintf(outfile,"ttprintf("ACCEPTn");n");
    fprintf(outfile,"t}n");
    fprintf(outfile,"treturn 0;n");
    fprintf(outfile,"}n");
}

由于大部分类似，这里就不贴过多代码了。

测试文件：

letter = [A-Z]
num = [0-9]
target = "test"{letter} {num}.

生成C语言代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char in_str[1000];
int cur_pos;
void letter(){
    if(in_str[cur_pos]>=65&&in_str[cur_pos]<=90){
        cur_pos++;
    }
    else{
        printf("ERROR DOTn");exit(0);
    }
}
void num(){
    if(in_str[cur_pos]>=48&&in_str[cur_pos]<=57){
        cur_pos++;
    }
    else{
        printf("ERROR DOTn");exit(0);
    }
}
void target(){
    if(in_str[cur_pos]=='t'){
        cur_pos++;
    }
    else{
        printf("ERROR tn");exit(0);
    }
    if(in_str[cur_pos]=='e'){
        cur_pos++;
    }
    else{
        printf("ERROR en");exit(0);
    }
    if(in_str[cur_pos]=='s'){
        cur_pos++;
    }
    else{
        printf("ERROR sn");exit(0);
    }
    if(in_str[cur_pos]=='t'){
        cur_pos++;
    }
    else{
        printf("ERROR tn");exit(0);
    }
    letter();
    num();
    if(in_str[cur_pos]>=33&&in_str[cur_pos]<=126){
        cur_pos++;
    }
    else{
        printf("ERROR DOTn");exit(0);
    }
}
int main(int argc,char* argv[]){
    cur_pos = 0;
    if(argc == 2){
        strcpy(in_str,argv[1]);
        target();
        printf("ACCEPTn");
    }
    return 0;
}

测试：

./test testA9E
ACCEPT

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!