自己动手写编译器:创建由 C 语言编译而成的语法解析器

#ifndef __L_H
#define __L_H
extern  int ii_newfile(char* name);
extern  unsigned char* ii_text();
extern  int ii_flush(int force);
extern  int ii_length();
extern  int ii_lineno();
extern  unsigned char* ii_ptext();
extern  int ii_plength();
extern  int ii_plineno();
extern  unsigned  char* ii_mark_start();
extern  unsigned  char* ii_mark_end();
extern  unsigned  char* ii_move_start();
extern  unsigned  char* ii_to_mark();
extern  unsigned  char* ii_mark_prev();
extern  int ii_advance();
extern  int ii_flush(int force);
extern  int ii_fillbuf(unsigned  char* starting_at);
extern  int ii_look(int n);
extern  int ii_pushback(int n);
extern  void ii_term();
extern  void ii_unterm();
extern  int ii_input();
extern  void ii_unput(int c);
extern  int ii_lookahead(int n);
extern  int ii_flushbuf();
#endif

func main() {
    lexReader, _ := nfa.NewLexReader("input.lex", "output.py")
    lexReader.Head()
    parser, _ := nfa.NewRegParser(lexReader)
    start := parser.Parse()
    parser.PrintNFA(start)

    nfaConverter := nfa.NewNfaDfaConverter()
    nfaConverter.MakeDTran(start)
    nfaConverter.PrintDfaTransition()

    nfaConverter.MinimizeDFA()
    fmt.Println("---------new DFA transition table ----")
    nfaConverter.PrintMinimizeDFATran()

    //nfaConverter.DoPairCompression()
    nfaConverter.DoSquash()
    nfaConverter.PrintDriver()
}

int yylex() {
    static int yystate = -1;
    int yylastaccept;
    int yyprev;
    int yynstate;
    int yylook;  //预读取字符
    int yyanchor;

    if(yystate == -1) {
        //将数据读入缓冲区
        ii_advance();
        //ii_advance 使得 Next 指针移动了一位，因此在我们还没有读入任何字符时，需要将其后退回去
        ii_pushback(1);
    }

    yystate = 0;
    yyprev = 0;
    yylastaccept = 0;
    ii_unterm();
    ii_mark_start();
    while(1) {
        /*
        * 这里我们采取贪婪算法，如果当前识别的字符串已经进入识别状态，
        * 但是还有字符可以读取，那么我们先缓存当前识别状态，然后继续识别后续字符，
        * 直到文件抵达末尾或者输入的字符导致识别失败，此时我们再返回到上次识别状态
        * 进行处理，这种方法让我们尽可能获得能进入完成状态的最长字符串
        */
        while(1) {
            yylook = ii_look(1);
            if (yylook != EOF) {
                yynstate = yy_next(yystate, yylook);
                break;
            } else {
                if (yylastaccept) {
                    /*
                     * 如果文件数据读取完毕，并且我们抵达过完成状态，那么设置下一个状态为
                     * 非法状态
                     */
                    yynstate = YYF;
                    break;
                }
                else if(yywrap()) {
                    yytext = "";
                    yyleng = 0;
                    return 0;
                }
                else {
                    ii_advance();
                    ii_pushback(1);
                }
            }
        }// inner while

        if (yynstate != YYF) {
            //跳转到下一个有效状态
            printf("Transation from state %d ", yystate);
            printf(" to state %d on <%c>\n", yynstate, yylook);

            if (ii_advance() < 0) {
                //缓冲区已满
                printf("Line %d, lexeme too long. Discarding extra characters.\n", ii_lineno());
                ii_flush(1);
            }

            yyanchor = Yyaccept[yynstate];
            if (yyanchor) {
                yyprev = yystate;
                yylastaccept = yynstate;
                ii_mark_end(); //完成一个字符串的识别
            }

            yystate = yynstate;
        } else {
            //跳转到无效状态，说明输入字符串不合法
            if (!yylastaccept) {
                //忽略掉非法字符
                printf("Ignoring bad input\n");
                ii_advance();
            } else {
                //回退到上一次接受状态
                ii_to_mark();
                if (yyanchor & 2) {
                    //末尾匹配,将末尾回车符号放回缓冲区
                    ii_pushback(1);
                }
                if (yyanchor & 1) {
                    //开头匹配，忽略掉字符串开头的回车符号
                    ii_move_start();
                }
                ii_term();
                //获取当前识别的字符串，极其长度和所在行号
                yytext = (char*) ii_text();
                yyleng = ii_length();
                yylineno = ii_lineno();

                printf("Accepting state%d, ", yylastaccept);
                printf("line %d: <%s>\n", yylineno, yytext);

                switch (yylastaccept) {
                    /*
                     * 这里根据接受状态执行其对应的代码，实际上这里的代码
                     * 后面会由 GoLex 生成
                     */
                    case 3:
                    case 4:
                        printf("%s is a float number", yytext);
                        return FCON;
                    default:
                        printf("internal error, yylex: unkonw accept state %d.\n", yylastaccept);
                        break;
                }
            }

            ii_unterm();
            yylastaccept = 0;
            yystate = yyprev;

        }

    }// outer while
}

int main() {
    int fd = ii_newfile("/Users/my/Documents/CLex/num.txt");
    if (fd == -1) {
        printf("value of errno: %d\n", errno);
    }
    yylex();
    return 0;
}

Transation from state 0  to state 4 on <3>
Transation from state 4  to state 3 on <.>
Transation from state 3  to state 3 on <1>
Transation from state 3  to state 3 on <4>
Accepting state3, line 1: <
3.14>