⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 plxanalyzer.cs

📁 本软件是针对PL/x语法结构设计的PL/x编译器
💻 CS
📖 第 1 页 / 共 3 页
字号:

                    if(sym == symbol.semicolon)
                    {
                        GetSym();
                        level++;
                        patch = DS(dsfollsys);
                        if (sym == symbol.beginsym)
                        {
                            DoPatch(patch);
                           
                            GetSym();
                            SS(ssfollsys);
                            Gen(fct.opr, 0, 0);
                            level--;
                        }
                        if (sym == symbol.endsym)
                            GetSym();
                        else
                            Error(ER_WAIT_END);
                      }
                    else
                        Error(ER_MISS_COMMA_OR_SEMICOLON);
                }
             else
                            Error(ER_ONLY_IDIENT);       //这里必须是标识符
        }

        }while(AssistOpr.IsContain<symbol>(dsbegsys,sym));

        }

        protected void S(symbol[] fsys)
        {
            int cx1, cx2;
            if (sym == symbol.ident)
            {
                    int i = Position(strID);
                    GetSym();
                    if (i == -1)
                        Error(ER_ID_NOTFOUND);
                    else
                    {
                        switch (FindIDKind(i))
                        {
                            case objekt.integer:
                                CheckAssignment();
                                AE(aefollsys);
                                Gen(fct.sto, level - wordtab[i].level, wordtab[i].addr);
                                break;

                            case objekt.logical:
                                CheckAssignment();
                                BE(befollsys);
                                Gen(fct.sto, level - wordtab[i].level, wordtab[i].addr);
                                break;

                            case objekt.array:
                                ArrayItemStatement();
                                CheckAssignment();
                                AE(aefollsys);
                                Gen(fct.sta, level - wordtab[i].level, wordtab[i].addr);
                                break;

                            default:
                                break;
                        }
                        
                    }
                    
            }

            if(sym == symbol.callsym)
            {
                     GetSym();
                    if (sym == symbol.ident)
                    {
                        int i = Position(strID);
                        if (i == -1)
                            Error(ER_ID_NOTFOUND);
                        else
                        {
                            if (wordtab[i].kind == objekt.procedure)
                                Gen(fct.cal, level - wordtab[i].level, wordtab[i].addr);
                            else
                                Error(ER_ILLEGAL_CALL);
                        }
                    }
                    else
                        Error(ER_ONLY_IDIENT);
                    GetSym();
            }

            else if(sym == symbol.ifsym)
            {
           
                    GetSym();
                    BE(befollsys);
                    if (sym == symbol.thensym)
                    {
                        GetSym();
                        cx1 = codeIndex;
                        Gen(fct.jpc, 0, 0);
                        SS(fsys);
                        cx2 = codeIndex;
  
                        
                        if (sym == symbol.elsesym)
                        {
                            Gen(fct.jmp, 0, 0);
                            GetSym();
                            code[cx1].address = codeIndex;
                            SS(fsys);
                            code[cx2].address = codeIndex;
                        }
                        //if there is no else,then modify jpc address
                        if(code[cx1].address == 0)
                            code[cx1].address = codeIndex;

                        
                        if (sym == symbol.endsym)
                        {
                            GetSym();
                        }
                        else
                        {
                            Error(ER_WAIT_END);
                        }
                    }
                    else
                    {
                        Error(ER_WAIT_THEN);
                    }
         
            }

            else if(sym == symbol.whilesym)
            {
                cx1 = codeIndex;
                GetSym();
                BE(befollsys);
                cx2 = codeIndex;
                Gen(fct.jpc, 0, 0);
                if (sym == symbol.dosym)
                {
                    GetSym();
                    SS(fsys);
                    Gen(fct.jmp, 0, cx1);
                    code[cx2].address = codeIndex;
                    if (sym == symbol.endsym)
                    {
                        GetSym();
                    }
                    else
                    {
                        Error(ER_WAIT_END);
                    }
                }
                else
                {
                    Error(ER_WAIT_DO);
                }
            }

            else if(sym == symbol.repeatsym)
            {
                cx1 = codeIndex;
                GetSym();
                SS( fsys);
                if (sym == symbol.untilsym)
                {
                    GetSym();
                    BE( befollsys);
                    Gen(fct.jpc, 0, cx1);
                }
                else
                {
                    Error(ER_WAIT_UNTIL);
                }
            }

            else if (sym == symbol.writesym)
            {
                GetSym();
                AE( aefollsys);
                Gen(fct.opr, 0, 14);
            }

     
        }

        protected void AE(symbol[] fsys)
        {
            symbol oprsym = sym;
            if (sym == symbol.minus)
            {
                  GetSym();
            }
            AT(atfollsys);
            if (oprsym == symbol.minus)
                Gen(fct.opr, 0, 1);
            while (sym == symbol.minus || sym == symbol.plus)
            {
                oprsym = sym;
                GetSym();
                AT( atfollsys);
                if (oprsym == symbol.plus)
                    Gen(fct.opr, 0, 2);
                else
                    Gen(fct.opr, 0, 3);
            }
        }

        protected void AT(symbol[] fsys)
        {
            symbol oprsym;
            AF(afbegsys);
            while (sym == symbol.times || sym == symbol.slash || sym == symbol.mod)
            {
                oprsym = sym;
                GetSym();
                AF( afbegsys);
                if (oprsym == symbol.times)
                    Gen(fct.opr, 0, 4);
                else if (oprsym == symbol.slash)
                    Gen(fct.opr, 0, 5);
                else
                    Gen(fct.opr, 0, 6);
            }
        }

        protected void AF(symbol[] fsys)
        {
            Test(afbegsys, fsys, ER_WRONG_BEGINID_INTFACTOR);
            while (AssistOpr.IsContain<symbol>(afbegsys, sym))
            {
                if (sym == symbol.ident)
                {
                    int i = Position(strID);
                    if (i == -1)
                        Error(ER_ID_NOTFOUND);
                    else
                    {
                        switch (FindIDKind(i))
                        {
                            case objekt.integer:
                                Gen(fct.lod, level - wordtab[i].level, wordtab[i].addr);
                                GetSym();
                                break;

                            case objekt.array:
                                GetSym();
                                ArrayItemStatement();
                                Gen(fct.loa, level - wordtab[i].level, wordtab[i].addr);
                                break;

                            case objekt.constant:
                                Gen(fct.lit,0,wordtab[i].value);
                                GetSym();
                                break;

                            default:
                                break;
                        }
                    }
                   
                }

                else if (sym == symbol.number)
                {
                    Gen(fct.lit, 0, num);
                    GetSym();
                }


                else if (sym == symbol.lparen)
                {
                    GetSym();
                    AE( aefollsys);
                    if (sym == symbol.rparen)
                    {
                        GetSym();
                    }
                    else
                    {
                        Error(ER_MISS_RPAREN);
                    }
                }

                else
                {
                    Error(ER_MISS_LPAREN);
                }
            }
        }

        protected void BE(symbol[] fsys)
        {
            BT( btfollsys);
            while (sym == symbol.orsym)
            {
                GetSym();
                BT( btfollsys);
                Gen(fct.opr, 0, 2);
            }
        }

        protected void BT(symbol[] fsys)
        {
            BF( bffollsys);
            while (sym == symbol.andsym)
            {
                GetSym();
                BF( bffollsys);
                Gen(fct.opr, 0, 4);
            }
        }

        protected void BF(symbol[] fsys)
        {
            Test(bfbegsys, fsys, ER_WRONG_BEGINID_LOGICALFACTOR);
            while (AssistOpr.IsContain<symbol>(bfbegsys, sym))
            {
                if (sym == symbol.ident)
                {
                    int i = Position(strID);
                    if (i == -1)
                        Error(ER_ID_NOTFOUND);
                    else
                    {
                        if (wordtab[i].kind == objekt.logical)
                        {
                            Gen(fct.lod, level - wordtab[i].level, wordtab[i].addr);
                            GetSym();
                        }
                        else
                        {
                            switch(FindIDKind(i))
                            {
                                case objekt.integer:
                                    Gen(fct.lod, level - wordtab[i].level, wordtab[i].addr);
                                    GetSym();                                
                                    RE();
                                break;

                                case objekt.constant:
                                Gen(fct.lit, 0, wordtab[i].value);
                                GetSym();
                                RE();
                                break;

                                case objekt.array:
                                    GetSym();
                                    ArrayItemStatement();
                                    Gen(fct.loa, level - wordtab[i].level, wordtab[i].addr);
                                    RE();
                                break;

                                default:
                                break;
                            }
                        }
                    }
                }

                else if (sym == symbol.number)
                {
                    Gen(fct.lit, 0, num);
                    GetSym();
                    RE();
                }

                else if (sym == symbol.truesym)
                {
                    Gen(fct.lit, 0, 1);
                    GetSym();
                }
                else if (sym == symbol.falsesym)
                {
                    Gen(fct.lit, 0, 0);
                    GetSym();
                }
                else if (sym == symbol.notsym)
                {
                    GetSym();
                    BF( null);
                    Gen(fct.opr, 0, 13);
                }
                else if (sym == symbol.lparen)
                {
                    GetSym();
                    BE( befollsys);
                    if (sym == symbol.rparen)
                        GetSym();
                    else
                        Error(ER_MISS_RPAREN);
                }
 
            }
        }

        protected void RE()
        {
                if (sym == symbol.eql || sym == symbol.gtr || sym == symbol.geq || sym == symbol.lss || sym == symbol.leq || sym == symbol.neq)
                {
                    symbol relsym = sym;
                    GetSym();
                    AE(aefollsys);
                    switch (relsym)
                    {
                        case symbol.eql:
                            Gen(fct.opr, 0, 7);
                            break;

                        case symbol.neq:
                            Gen(fct.opr, 0, 8);
                            break;

                        case symbol.gtr:
                            Gen(fct.opr, 0, 9);
                            break;

                        case symbol.geq:
                            Gen(fct.opr, 0, 10);
                            break;

                        case symbol.lss:
                            Gen(fct.opr, 0, 11);
                            break;

                        case symbol.leq:
                            Gen(fct.opr, 0, 12);
                            break;
                    }

                }

            }

        }
                    
     }

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -