plxanalyzer.cs

本软件是针对PL/x语法结构设计的PL/x编译器

        {
            Getch();
            if (strCh == "=")
            {
                sym = symbol.geq;
                Getch();
            }

            else
            {
                sym = symbol.gtr;
            }
        }

        protected void HandleNeqSym()
        {
            Getch();
            if (strCh == "=")
            {
                sym = symbol.neq;
                Getch();
            }
            else
            {
                sym = symbol.slash;
            }
        }

        protected void HandleSingleCh()
        {
            int AsciiCh = Convert.ToChar(strCh);
            //Find sym according to Ascii
            for (int index = 0; index < NUM_OF_OPR_WORDS; index++)
            {
                if (AsciiCh == ssymAscii[index])
                {
                    sym = ssym[index];
                    break;
                }
            }
                     
            Getch();
        }

        //register const
        protected void Enter()
        {
            tabIndex++;
            wordtab[tabIndex].name = strID;
            wordtab[tabIndex].kind = objekt.constant;
            wordtab[tabIndex].value = num;
        }

        //register integer,logical,procedure
        protected void Enter(ref int dx,objekt k)
        {
            tabIndex++;
            wordtab[tabIndex].name = strID;
            wordtab[tabIndex].kind = k;
            switch (k)
            {
                case objekt.integer:
                case objekt.logical:
                    wordtab[tabIndex].level = level;
                    wordtab[tabIndex].addr = dx++;
                    break;

                case objekt.procedure:
                    wordtab[tabIndex].level = level;
                    break;

                default:
                    break;

            }

        }

        //register array
        protected void Enter(ref int dx,int arraysize)
        {
            tabIndex++;
            wordtab[tabIndex].name = strID;
            wordtab[tabIndex].kind = objekt.array;
            wordtab[tabIndex].value = arraysize;
            wordtab[tabIndex].level = level;
            wordtab[tabIndex].addr = dx;
            dx += arraysize;
        }

        protected int Position(string strSourceID)
        {
            int i = tabIndex;
            for (; i >= 0; i--)
            {
                if (wordtab[i].name == strSourceID)
                    break;
            }

            return i;
        }

        protected void ConstDeclaration(ref int dx)
        {
            if (sym == symbol.ident)
            {
                if (HasIDDeclared(strID))
                    Error(ER_ID_REDUNDANCY);
                else
                {
                    GetSym();
                    if (sym == symbol.eql || sym == symbol.becomes)
                    {
                        if (sym == symbol.becomes)
                            Error(ER_EQL_NOT_BECOMES);       //这里必须是=
                        GetSym();
                        if (sym == symbol.number)
                        {
                            Enter();
                            GetSym();
                        }
                        else
                        {
                            Error(ER_ONLY_NUMBER);    //这里必须是数字
                        }
                    }
                    else
                        Error(ER_ONLY_EQL);
                }
            }
              
            else
            {
                Error(ER_ONLY_IDIENT);    //这里必须是一个标识符
            }
        }

        protected void ArrayDeclaration(ref int dx)
        {
            string strTempArrayID;
            if (sym == symbol.lsqbracket)
            {
                GetSym();
                if (sym == symbol.number)
                {
                        arraysize = num;      //记录数组的长度
                        GetSym();

                        if (sym == symbol.rsqbracket)
                        {
                            GetSym();
                            if (sym == symbol.ident)
                            {
                                if (HasIDDeclared(strID))
                                    Error(ER_ID_REDUNDANCY);
                                else
                                {
                                    strTempArrayID = strID;                   //记录数组ID，以便在初始化时在wordtab中查找
                                    Enter(ref dx, arraysize);
                                    GetSym();
                                }
                          
                            }
                            else
                                Error(ER_ONLY_IDIENT);
                        }
                        else
                            Error(ER_MISS_RSQBRACKET);
                }
                else
                {
                    Error(ER_MUST_NUMBER_OR_CONST);     //必须是一个常数或常量
                }
                
            }
            else
                Error(ER_MISS_LSQBRACKET);

            while (sym == symbol.comma)
            {
                GetSym();
                if (sym == symbol.ident)
                {
                    if (HasIDDeclared(strID))
                        Error(ER_ID_REDUNDANCY);
                    else
                    {
                        strTempArrayID = strID;
                        Enter(ref dx, arraysize);
                        GetSym();
                     }
    
                }
                else
                    Error(ER_ONLY_IDIENT);
            }

        }

        protected void ArrayItemStatement()
        {
                if (sym == symbol.lsqbracket)
                {
                    GetSym();
                    AE(aefollsys); 

                        if (sym == symbol.rsqbracket)
                        {
                            GetSym();
                        }
                        else
                        {
                            Error(ER_MISS_RSQBRACKET);
                        }
            
                }
                else
                {
                    Error(ER_MISS_LSQBRACKET);
                }
         
            
      }

        protected objekt FindIDKind(int i)
        {
            return wordtab[i].kind;
        }

        protected bool HasIDDeclared(string id)
        {
            int i = Position(id);
            if (i != -1)
                return true;
            else 
                return false;
        }

        protected void CheckAssignment()
        {
            if (sym == symbol.becomes || sym == symbol.eql)
            {
                if (sym == symbol.eql)
                    Error(ER_ONLY_BECOMES);
                GetSym();
            }
            else
            {
                Error(ER_ONLY_BECOMES);
            }
        }

        //patch program,fill in jmp address
        protected void DoPatch(int[] patch)
        {
            code[wordtab[patch[0]].addr].address = codeIndex;
            wordtab[patch[0]].addr = codeIndex;
            wordtab[patch[0]].size = patch[1];

            cx0 = codeIndex;
            Gen(fct.ini, 0, patch[1]);
        }

        public void Prog(int lev)
        {
            int[] patch = new int[2];
            level = lev;
            if (sym == symbol.progsym)
            {
                GetSym();
                patch = DS(dsfollsys);
                if (sym == symbol.beginsym)
                {
                    DoPatch(patch);
                   
                    GetSym();
                    SS(ssfollsys);
                    Gen(fct.opr, 0, 0);
                    if (sym == symbol.endsym)
                    {
                        GetSym();
                        if (sym != symbol.period)
                            Error(ER_MUST_ENDWITH_DOT);
                    }
                    else
                        Error(ER_WAIT_END);
                }
            }
            else
                Error(ER_MUST_BEGINWITH_PROGRAM);

            //ListMidCode();
        }

        protected int[] DS(symbol[] fsys)
        {
            int[] patch = new int[2];
            int dx = 3;
            int tx0 = tabIndex;
            wordtab[tabIndex].addr = codeIndex;
            Gen(fct.jmp, 0, 0);

            D(ref dx,fsys);
            while (AssistOpr.IsContain<symbol>(dsbegsys,sym) || sym == symbol.semicolon)
            {
                if (sym == symbol.semicolon)
                    GetSym();
                else
                    Error(ER_INCORRECT_SYMBOL);
                D(ref dx, fsys);
             }
            patch[0] =  tx0;
            patch[1] = dx;

            return patch;
          }

        protected void SS(symbol[] fsys)
        {
            S(fsys);
            while (AssistOpr.IsContain<symbol>(ssbegsys, sym) || sym == symbol.semicolon)
            {
                if(sym == symbol.semicolon)
                   GetSym();
                else
                    Error(ER_INCORRECT_SYMBOL);
                S(fsys);
            }
         }

        protected void D(ref int dx,symbol[] fsys)
        {
            do
            {
            if (sym == symbol.constsym)
            {
                GetSym();
                do
                {
                    ConstDeclaration(ref dx);
                    while (sym == symbol.comma)
                    {
                        GetSym();
                        ConstDeclaration(ref dx);
                    }
                }
                while (sym == symbol.ident);
            }
            
            else if (sym == symbol.intesym)
            {
                GetSym();
                //define integer var 
                do
                {
                if (sym == symbol.ident)
                {
                    if (HasIDDeclared(strID))
                        Error(ER_ID_REDUNDANCY);
                    else
                    {
                         Enter(ref dx,objekt.integer);
                    }
                    GetSym();

                    while (sym == symbol.comma)
                    {
                        GetSym();
                        if (sym == symbol.ident)
                        {
                            if (HasIDDeclared(strID))
                                Error(ER_ID_REDUNDANCY);
                            else
                            {
                                Enter(ref dx, objekt.integer);
                            }
                            GetSym();
                        }
                     
                        else
                            Error(ER_ONLY_IDIENT);           //这里必须是标识符
                        
                    }
                }

                //define integer array
                else
                    ArrayDeclaration(ref dx);
                }while(sym == symbol.ident);   
          }

            else if (sym == symbol.logisym)
            {
                GetSym();
                do
                {
                    if (sym == symbol.ident)
                    {
                        if (HasIDDeclared(strID))
                            Error(ER_ID_REDUNDANCY);
                        else
                        {
                            Enter(ref dx, objekt.logical);
                        }
                        GetSym();
                    }
                    else
                    {
                        Error(ER_ONLY_IDIENT);        //这里必须是标识符
                    }

                    while (sym == symbol.comma)
                    {
                        GetSym();
                        if (sym == symbol.ident)
                        {
                            if (HasIDDeclared(strID))
                                 Error(ER_ID_REDUNDANCY);
                            else
                            {
                                Enter(ref dx, objekt.logical);
                            }
                            GetSym();
                        }
                        else
                            Error(ER_ONLY_IDIENT);           //这里必须是标识符
                    }
                } while (sym == symbol.ident);
            }

            while(sym == symbol.procsym)
            {
                int[] patch = new int[2];
                GetSym();
                if (sym == symbol.ident)
                {
                    if (HasIDDeclared(strID))
                        Error(ER_ID_REDUNDANCY);
                    else
                    {
                        Enter(ref dx, objekt.procedure);
                    }
                    GetSym();