コード例 #1
0
        //<常量定义> ::= <标识符>=<无符号整数>
        public void decconst()
        {
            Error        er = compiler.error;
            symbol_table st = compiler.st;

            if (sym == symlist.iden)
            {
                getsym();
                if (sym == symlist.equality || sym == symlist.becomes)
                {
                    if (sym == symlist.becomes)
                    {
                        er.adderror(1);
                    }
                    getsym();
                    if (sym == symlist.number)
                    {
                        st.add(symlist.constsym);  //加入符号表
                        getsym();
                    }
                    else//常数声明标识符后不是数字
                    {
                        er.adderror(2);
                    }
                }
                else//不是等号
                {
                    er.adderror(3);
                }
            }
            else   //不是标识符
            {
                er.adderror(4);
            }
        }
コード例 #2
0
 public Compiler(string path)
 {
     source = path;
     la     = new lexical_analysis(this);
     sa     = new syntax_Analysis(this);
     st     = new symbol_table(this);
     error  = new Error(this);
     pc     = new Pcode();
 }
コード例 #3
0
        //<变量说明部分>::= var<标识符>{,<标识符>};
        public void decvar()
        {
            Error        er = compiler.error;
            symbol_table st = compiler.st;

            if (sym == symlist.iden)
            {
                st.add(symlist.varsym); //加入符号表
                dx[level]++;            //分配地址
                getsym();
            }
            else//不是标识符
            {
                er.adderror(4);
            }
        }
コード例 #4
0
        //<因子> ::= <标识符>|<无符号整数>|'('<表达式>')'
        public void factor(List <symlist> followlst)
        {
            Pcode            pc      = compiler.pc;
            List <symlist>   nextlst = new List <symlist>();
            symbol_table     st      = compiler.st;
            lexical_analysis la      = compiler.la;
            Error            er      = compiler.error;
            int index;

            nextlst.AddRange(factorSymSet);
            check(nextlst, followlst, 24);
            while (factorSymSet.Contains(sym))
            {
                if (sym == symlist.iden)
                {
                    index = st.position(la.word);
                    if (index == -1)
                    {
                        er.adderror(11);
                    }
                    else
                    {
                        record re   = st.stable[index];
                        string kind = re.kind;
                        if (kind == "constant")
                        {
                            pc.gen("LIT", 0, re.val);
                        }
                        else if (kind == "variable")
                        {
                            int l = level - re.level;
                            int a = re.adr;
                            pc.gen("LOD", l, a);
                        }
                        else
                        {
                            er.adderror(21);
                        }
                    }
                    getsym();
                }
                else if (sym == symlist.number)
                {
                    pc.gen("LIT", 0, la.num);
                    getsym();
                }
                else if (sym == symlist.LParenthesis)
                {
                    getsym();
                    followlst.Add(symlist.RParenthesis);
                    expression(followlst);
                    if (sym == symlist.RParenthesis)
                    {
                        getsym();
                    }
                    else
                    {
                        er.adderror(22);
                    }                        //error
                }
                check(followlst, factorSymSet, 23);
            }
        }
コード例 #5
0
        //<语句> ::= <赋值语句>|<条件语句>|<当型循环语句>|<过程调用语句>|<读语句>|<写语句>|<复合语句>|<重复语句>|<空>
        public void statement(List <symlist> followlst)
        {
            Error            er      = compiler.error;
            symbol_table     st      = compiler.st;
            lexical_analysis la      = compiler.la;
            Pcode            pc      = compiler.pc;
            List <symlist>   nextlst = new List <symlist>();
            List <symlist>   n2      = new List <symlist>();

            int index, cx1, cx2;

            switch (sym)
            {
            //<赋值语句> ::= <标识符>:=<表达式>
            case symlist.iden:
                index = st.position(la.word);
                if (index == -1)    //未声明
                {
                    er.adderror(11);
                }
                else if (st.stable[index].kind != "variable")
                {
                    er.adderror(12);
                    index = -1;
                }
                getsym();
                if (sym == symlist.becomes)
                {
                    getsym();
                }
                else    //不是:=
                {
                    er.adderror(13);
                }
                expression(followlst);
                if (index != -1) //生成pcode
                {
                    int l = level - st.stable[index].level;
                    int a = st.stable[index].adr;
                    pc.gen("STO", l, a);
                }
                break;

            //<过程调用语句>::=call<标识符>
            case symlist.callsym:
                getsym();
                if (sym == symlist.iden)
                {
                    index = st.position(la.word);
                    if (index == -1)
                    {
                        er.adderror(11);
                    }
                    else if (st.stable[index].kind != "procedure")
                    {
                        index = -1;
                        er.adderror(15);
                    }
                    else    //生成pcode
                    {
                        int l = level - st.stable[index].level;
                        int a = st.stable[index].adr;
                        pc.gen("CAL", l, a);
                    }
                    getsym();
                }
                else
                {
                    er.adderror(14);
                }
                break;

            //<复合语句> ::= begin<语句>{;<语句>}end
            case symlist.beginsym:
                getsym();
                nextlst.Clear();
                nextlst.AddRange(followlst);
                n2.Clear();
                n2.AddRange(stateSymSet);
                n2.Add(symlist.semicolon);
                statement(nextlst);
                while (n2.Contains(sym))
                {
                    if (sym == symlist.semicolon)
                    {
                        getsym();
                    }
                    else
                    {
                        er.adderror(10);
                    }
                    statement(nextlst);
                }
                if (sym == symlist.endsym)
                {
                    getsym();
                }
                else    //少了end
                {
                    er.adderror(17);
                }
                break;

            //<条件语句> ::= if<条件>then<语句>[else<语句>]
            case symlist.ifsym:
                getsym();
                nextlst.Clear();
                nextlst.AddRange(followlst);
                nextlst.Add(symlist.thensym);
                nextlst.Add(symlist.dosym);
                ifstatement(nextlst);
                if (sym == symlist.thensym)
                {
                    getsym();
                }
                else
                {
                    er.adderror(16);
                }
                cx1 = pc.cx;
                pc.gen("JPC", 0, 0);
                nextlst.Clear();
                nextlst.AddRange(followlst);
                nextlst.Add(symlist.elsesym);
                statement(nextlst);
                if (sym == symlist.elsesym)
                {
                    getsym();
                    cx2 = pc.cx;
                    pc.gen("JMP", 0, 0);
                    statement(followlst);
                    pc.pcdeolst[cx1].a = cx2 + 1;
                    pc.pcdeolst[cx2].a = pc.cx;
                }
                else
                {
                    pc.pcdeolst[cx1].a = pc.cx;
                }
                break;

            // <当型循环语句 > ::= while< 条件 >do< 语句 >
            case symlist.whilesym:
                cx1 = pc.cx;
                getsym();
                nextlst.Clear();
                nextlst.AddRange(followlst);
                nextlst.Add(symlist.dosym);
                ifstatement(nextlst);
                cx2 = pc.cx;
                pc.gen("JPC", 0, 0);
                if (sym == symlist.dosym)
                {
                    getsym();
                }
                else
                {
                    er.adderror(18);    //error
                }
                statement(followlst);
                pc.gen("JMP", 0, cx1);
                pc.pcdeolst[cx2].a = pc.cx;
                break;

            //<读语句> ::= read'('<标识符>{,<标识符>}')'
            case symlist.readsym:
                getsym();
                if (sym == symlist.LParenthesis)
                {
                    do
                    {
                        getsym();
                        if (sym == symlist.iden)
                        {
                            index = st.position(la.word);
                        }
                        else
                        {
                            index = -1;
                            er.adderror(32);    //error
                        }
                        if (index > 0 && st.stable[index].kind != "variable")
                        {
                            getsym();
                            er.adderror(32);
                        }
                        else if (sym == symlist.RParenthesis || sym == symlist.semicolon)
                        {
                            er.adderror(35);
                            getsym();
                        }
                        else
                        {
                            int l = level - st.stable[index].level;
                            int a = st.stable[index].adr;
                            pc.gen("RED", l, a);
                            getsym();
                        }
                    } while (sym == symlist.comma);
                }
                else
                {
                    er.adderror(33);
                }                            //error
                if (sym == symlist.RParenthesis)
                {
                    getsym();
                }
                else
                {
                    er.adderror(34);
                    while (!followlst.Contains(sym))
                    {
                        getsym();
                    }
                }
                break;

            //<写语句> ::= write'('<标识符>{,<标识符>}')'
            case symlist.writesym:
                getsym();
                nextlst.Clear();
                nextlst.AddRange(followlst);
                nextlst.Add(symlist.RParenthesis);
                nextlst.Add(symlist.comma);
                if (sym == symlist.LParenthesis)
                {
                    do
                    {
                        getsym();
                        expression(nextlst);
                        pc.gen("WRT", 0, 0);
                    } while (sym == symlist.comma);
                    if (sym == symlist.RParenthesis)
                    {
                        getsym();
                    }
                    else
                    {
                        er.adderror(34);
                    }                            //error
                }
                else
                {
                    er.adderror(33);
                }                            //error
                break;

            //<重复语句> ::= repeat<语句>{;<语句>}until<条件>
            case symlist.repeatsym:
                getsym();
                nextlst.Clear();
                nextlst.AddRange(followlst);
                nextlst.Add(symlist.untilsym);
                cx1 = pc.cx;
                statement(nextlst);
                n2.Clear();
                n2.AddRange(stateSymSet);
                n2.Add(symlist.semicolon);
                while (n2.Contains(sym))
                {
                    if (sym == symlist.semicolon)
                    {
                        getsym();
                    }
                    else
                    {
                        er.adderror(10);
                    }                            //error}
                    statement(nextlst);
                }
                if (sym == symlist.untilsym)
                {
                    getsym();
                    ifstatement(followlst);
                    pc.gen("JPC", 0, cx1);
                }
                else
                {
                    er.adderror(25);
                }                            //error
                break;
            }
            check(followlst, new List <symlist>(), 19);
        }
コード例 #6
0
        //<分程序>::=[<常量说明部分>][变量说明部分>][<过程说明部分>]<语句>
        public void subprogram(List <symlist> followlst)
        {
            //int point = compiler.st.point;
            //int pi = compiler.st.dx[point];

            List <symlist> nextlst = new List <symlist>();
            symbol_table   st = compiler.st;
            Pcode          pcode = compiler.pc;
            Error          er = compiler.error;
            int            ti, ch;

            level++;
            dx[level]         = 3;
            ti                = st.dx[st.point];
            st.stable[ti].adr = pcode.cx;
            pcode.gen("JMP", 0, 0);
            //判断是否分程序的层次超过最大层数3
            if (level > 3)
            {
                er.adderror(26);
            }
            do
            {
                //<常量说明部分> ::= const<常量定义>{,<常量定义>};
                if (sym == symlist.constsym)
                {
                    do
                    {
                        getsym();
                        decconst();
                    } while (sym == symlist.comma);
                    if (sym == symlist.semicolon)
                    {
                        getsym();
                    }
                    else//少了一个分号
                    {
                        er.adderror(5);
                    }
                }
                //<变量说明部分>::= var<标识符>{,<标识符>};
                if (sym == symlist.varsym)
                {
                    do
                    {
                        getsym();
                        decvar();
                    } while (sym == symlist.comma);
                    if (sym == symlist.semicolon)
                    {
                        getsym();
                    }
                    else//少了一个分号
                    {
                        er.adderror(5);
                    }
                }
                //<过程说明部分> ::= <过程首部><分程序>;{<过程说明部分>}
                //<过程首部> ::= procedure<标识符>;
                while (sym == symlist.proceduresym)
                {
                    getsym();
                    if (sym == symlist.iden)
                    {
                        st.add(symlist.proceduresym);//加入符号表
                        getsym();
                    }
                    else//不是标识符
                    {
                        er.adderror(4);
                    }
                    if (sym == symlist.semicolon)
                    {
                        getsym();
                    }
                    else
                    {
                        er.adderror(5);
                    }
                    nextlst.AddRange(followlst);
                    nextlst.Add(symlist.semicolon);
                    subprogram(nextlst);
                    if (sym == symlist.semicolon)
                    {
                        getsym();
                        nextlst.Clear();
                        nextlst.AddRange(followlst);
                        nextlst.Add(symlist.iden);
                        nextlst.Add(symlist.proceduresym);
                        check(nextlst, followlst, 6);
                    }
                    else
                    {
                        er.adderror(5);
                    }
                }
                nextlst.Clear();
                nextlst.AddRange(stateSymSet);
                nextlst.Add(symlist.iden);
                check(nextlst, declareSymSet, 7);
            } while (declareSymSet.Contains(sym));

            pcode.pcdeolst[st.stable[ti].adr].a = pcode.cx;
            st.stable[ti].adr  = pcode.cx;
            st.stable[ti].size = dx[level];
            ch = pcode.cx;
            pcode.gen("INT", 0, dx[level]);
            nextlst.Clear();
            nextlst.AddRange(followlst);
            nextlst.Add(symlist.semicolon);
            nextlst.Add(symlist.endsym);
            statement(nextlst);
            pcode.gen("OPR", 0, 0);
            check(nextlst, new List <symlist>(), 8);
            level--;
            int point = compiler.st.point;

            if (level < point)
            {
                if (point > 0)
                {
                    int delnum = compiler.st.dx[point] - compiler.st.dx[point - 1];
                    for (int i = 0; i < delnum; i++)
                    {
                        compiler.st.stable.RemoveAt(compiler.st.stable.Count - 1);
                    }
                    compiler.st.point--;
                }
            }

            //compiler.st.point = point;
            //compiler.st.dx[compiler.st.point] = pi;
        }