Exemple #1
0
        //This Procedure assumes Procedure is a PROC AST node
        private List <SemanticError> CheckProcedure(CommonAST Procedure, List <SemanticError> Errors)
        {
            List <string> LocalVariables = new List <string>();

            CommonAST walker = Procedure;

            walker = (CommonAST)walker.getFirstChild();
            string ProcedureName = walker.getText();

            walker = (CommonAST)walker.getFirstChild();

            #region Variables checking
            while (walker.Type == BoolParserTokenTypes.ID)
            {
                string variable = walker.ToString();
                if (LocalVariables.Contains(variable))
                {
                    Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_NAME_CLASH, variable, ProcedureName));
                }
                else
                {
                    LocalVariables.Add(variable);
                }

                walker = (CommonAST)walker.getNextSibling();
            }

            while ((walker.Type == BoolParserTokenTypes.LITERAL_decl))
            {
                CommonAST subWalker = (CommonAST)walker.getFirstChild();

                while (subWalker != null)
                {
                    string variable = subWalker.ToString();
                    if (LocalVariables.Contains(variable))
                    {
                        Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_NAME_CLASH, variable, ProcedureName));
                    }
                    else
                    {
                        LocalVariables.Add(variable);
                    }

                    subWalker = (CommonAST)subWalker.getNextSibling();
                }

                walker = (CommonAST)walker.getNextSibling();
            }
            #endregion


            Errors = CheckSSEQ(walker, Errors, LocalVariables, ProcedureName);

            return(Errors);
        }
Exemple #2
0
        public List <SemanticError> Check()
        {
            List <SemanticError> Errors = new List <SemanticError>();

            GlobalVariables.Clear();
            ProcedureNames.Clear();
            ProcedureToNumParam.Clear();

            CommonAST walker = BoolProgram;

            while ((walker != null) && (walker.Type == BoolParserTokenTypes.LITERAL_decl))
            {
                CommonAST subWalker = (CommonAST)walker.getFirstChild();

                while (subWalker != null)
                {
                    string variable = subWalker.ToString();
                    if (GlobalVariables.Contains(variable))
                    {
                        Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_NAME_CLASH, variable));
                    }
                    else
                    {
                        GlobalVariables.Add(variable);
                    }

                    subWalker = (CommonAST)subWalker.getNextSibling();
                }

                walker = (CommonAST)walker.getNextSibling();
            }

            CommonAST procWalker = walker;

            while (walker != null)
            {
                string procName = walker.getFirstChild().getText();

                if (ProcedureNames.Contains(procName))
                {
                    Errors.Add(new SemanticError(BoolSemanticErrorTypes.PROC_NAME_CLASH, procName));
                }
                else
                {
                    ProcedureNames.Add(procName);
                    CommonAST subWalker = (CommonAST)walker.getFirstChild().getFirstChild();

                    int numParameters = 0;
                    while (subWalker.Type == BoolParserTokenTypes.ID)
                    {
                        numParameters++;
                        subWalker = (CommonAST)subWalker.getNextSibling();
                    }

                    ProcedureToNumParam.Add(procName, numParameters);
                }

                walker = (CommonAST)walker.getNextSibling();
            }

            while (procWalker != null)
            {
                Errors = CheckProcedure(procWalker, Errors);

                procWalker = (CommonAST)procWalker.getNextSibling();
            }

            if (!(ProcedureNames.Contains("main")))
            {
                Errors.Add(new SemanticError(BoolSemanticErrorTypes.MAIN_MISSING, ""));
            }

            return(Errors);
        }