Example #1
0
        private static bool Expressionz()
        {
            if (Tokens.GetToken().lexeme == "=")
            {
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!AssignmentExpression())
                {
                    SyntaxError(Tokens.GetToken(), "assignment expression");
                }
                return(true);
            }

            else if (Tokens.GetToken().lexeme == "and" || Tokens.GetToken().lexeme == "or" ||
                     Tokens.GetToken().type == Token.Type.BoolSymbol || Tokens.GetToken().type == Token.Type.MathSymbol)
            {
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "expression");
                }
                return(true);
            }

            return(false);
        }
Example #2
0
        private static bool ClassMemberDeclaration()
        {
            if (Tokens.GetToken().lexeme != "public" &&
                Tokens.GetToken().lexeme != "private")
            {
                parameters = "";
                methodSize = 0;
                return(ConstructorDeclaration());
            }
            accessMod = Tokens.GetToken().lexeme;
            Tokens.NextToken();
            if (!type())
            {
                SyntaxError(Tokens.GetToken(), "a type");
                return(false);
            }
            if (semanticPass)
            {
                SemanticActions.tExist();
            }
            Tokens.NextToken();
            if (Tokens.GetToken().type != Token.Type.Identifier)
            {
                SyntaxError(Tokens.GetToken(), "identifer");
            }
            currentIdentifier = Tokens.GetToken().lexeme;
            identifierToken   = Tokens.GetToken();
            if (semanticPass)
            {
                SemanticActions.dup(identifierToken, scope);
            }
            Tokens.NextToken();
            Symbol symbol = null;

            if (Tokens.GetToken().lexeme == "[")
            {
                currentType = "@" + currentType;
            }
            if (Tokens.GetToken().lexeme == "[" || Tokens.GetToken().lexeme == "=" || Tokens.GetToken().lexeme == ";")
            {
                string[] data = new string[2];
                data[0] = "returnType:" + currentType;
                data[1] = "accessMod:" + accessMod;
                symbol  = new Symbol(scope, ("V" + uniqueCounter++), currentIdentifier, "ivar", data);
                SymbolTable.Add(symbol);
                if (!semanticPass)
                {
                    memberVariables.Add(symbol.symid);
                }
                classSize += symbol.size;
            }
            identifierSymbol = symbol;
            if (!FieldDeclaration())
            {
                SyntaxError(Tokens.GetToken(), "field declaration");
            }
            accessMod = "public";
            return(true);
        }
Example #3
0
 private static bool AssignmentExpression()
 {
     if (Tokens.GetToken().lexeme == "new")
     {
         Tokens.NextToken();
         if (!type())
         {
             SyntaxError(Tokens.GetToken(), "a type");
             return(false);
         }
         currentType = Tokens.GetToken().lexeme;
         Tokens.NextToken();
         if (!NewDeclaration())
         {
             SyntaxError(Tokens.GetToken(), "new  declaration");
         }
         return(true);
     }
     else if (Tokens.GetToken().lexeme == "itoa" || Tokens.GetToken().lexeme == "atoi")
     {
         string lexeme = Tokens.GetToken().lexeme;
         Tokens.NextToken();
         if (Tokens.GetToken().lexeme != "(")
         {
             SyntaxError(Tokens.GetToken(), "(");
         }
         if (semanticPass)
         {
             SemanticActions.oPush(Tokens.GetToken());
         }
         Tokens.NextToken();
         if (!Expression())
         {
             SyntaxError(Tokens.GetToken(), "expression");
         }
         if (Tokens.GetToken().lexeme != ")")
         {
             SyntaxError(Tokens.GetToken(), ")");
         }
         Tokens.NextToken();
         if (semanticPass && (lexeme == "atoi"))
         {
             SemanticActions.ShuntYardAll();
             SemanticActions.atoi();
         }
         else if (semanticPass && (lexeme == "itoa"))
         {
             SemanticActions.ShuntYardAll();
             SemanticActions.itoa();
         }
         return(true);
     }
     else if (Expression())
     {
         return(true);
     }
     return(false);
 }
Example #4
0
 private static bool type()
 {
     Token.Type tokenType = Tokens.GetToken().type;
     if (tokenType != Token.Type.TypeKeyword && tokenType != Token.Type.Identifier)
     {
         return(false);
     }
     currentType = Tokens.GetToken().lexeme;
     if (semanticPass)
     {
         SemanticActions.tPush(Tokens.GetToken(), scope);
     }
     return(true);
 }
Example #5
0
        private static bool ClassDeclaration()
        {
            if (Tokens.GetToken().lexeme != "class")
            {
                return(false);
            }
            Tokens.NextToken();
            scope = "g" + "." + Tokens.GetToken().lexeme;
            if (Tokens.GetToken().type != Token.Type.Identifier)
            {
                SyntaxError(Tokens.GetToken(), "an identifer");
            }
            Symbol symbol = new Symbol("g", ("C" + uniqueCounter++), Tokens.GetToken().lexeme, "Class", null);

            identifierToken = Tokens.GetToken();
            if (semanticPass)
            {
                SemanticActions.dup(identifierToken, "g");
                ICode.StaticInit();
            }
            Tokens.NextToken();
            if (Tokens.GetToken().lexeme != "{")
            {
                SyntaxError(Tokens.GetToken(), "{");
            }
            Tokens.NextToken();
            classSize             = 0;
            classMemberOffset     = 0;
            classTempMemberOffset = 0;
            while (ClassMemberDeclaration())
            {
            }
            if (semanticPass)
            {
                ICode.StaticInitInsertVars();
            }
            if (Tokens.GetToken().lexeme != "}")
            {
                SyntaxError(Tokens.GetToken(), "modifier or constructor or a closing brace");
            }
            else
            {
                memberVariables.Add(currentClassConstructorSymid);
            }
            Tokens.NextToken();
            symbol.size = classMemberOffset;
            SymbolTable.Add(symbol);
            scope = "g";
            return(true);
        }
Example #6
0
 private static bool Fn_Arr_Member()
 {
     if (Tokens.GetToken().lexeme == "(")
     {
         if (semanticPass)
         {
             SemanticActions.oPush(Tokens.GetToken());
             SemanticActions.BAL();
         }
         Tokens.NextToken();
         Argument_List();
         if (Tokens.GetToken().lexeme != ")")
         {
             SyntaxError(Tokens.GetToken(), ")");
         }
         if (semanticPass)
         {
             SemanticActions.ShuntYardAll();
             SemanticActions.EAL();
             SemanticActions.func();
         }
         Tokens.NextToken();
         return(true);
     }
     else if (Tokens.GetToken().lexeme == "[")
     {
         if (semanticPass)
         {
             SemanticActions.oPush(Tokens.GetToken());
         }
         currentType = "@" + currentType;
         Tokens.NextToken();
         if (!Expression())
         {
             SyntaxError(Tokens.GetToken(), "an expression");
         }
         if (Tokens.GetToken().lexeme != "]")
         {
             SyntaxError(Tokens.GetToken(), "]");
         }
         if (semanticPass)
         {
             SemanticActions.ShuntYardAll();
             SemanticActions.arr();
         }
         Tokens.NextToken();
         return(true);
     }
     return(false);
 }
Example #7
0
        private static bool NewDeclaration()
        {
            if (Tokens.GetToken().lexeme == "(")
            {
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                    SemanticActions.BAL();
                }
                Tokens.NextToken();
                Argument_List();
                if (Tokens.GetToken().lexeme != ")")
                {
                    SyntaxError(Tokens.GetToken(), ")");
                }
                if (semanticPass)
                {
                    SemanticActions.ShuntYardAll();
                    SemanticActions.EAL();
                    SemanticActions.NewObj();
                }
                Tokens.NextToken();
                return(true);
            }
            else if (Tokens.GetToken().lexeme == "[")
            {
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "expression");
                }
                if (Tokens.GetToken().lexeme != "]")
                {
                    SyntaxError(Tokens.GetToken(), "]");
                }
                if (semanticPass)
                {
                    SemanticActions.ShuntYardAll();
                    SemanticActions.new_arr();
                }
                Tokens.NextToken();
                return(true);
            }

            return(false);
        }
Example #8
0
 private static bool character_literal()
 {
     if (Tokens.GetToken().type == Token.Type.Character)
     {
         string   value = Tokens.GetToken().lexeme.Replace("\'", "");
         string[] data  = new string[2];
         data[0] = "returnType:char";
         data[1] = "accessMod:public";
         Symbol symbol = new Symbol("g", ("H" + value.Trim()), "CHAR_" + value, "c**t", data);
         SymbolTable.Add(symbol);
         if (semanticPass)
         {
             SemanticActions.lPush(symbol, Tokens.GetToken(), scope);
         }
         return(true);
     }
     return(false);
 }
Example #9
0
        private static bool Parameter()
        {
            if (!type())
            {
                return(false);
            }
            if (semanticPass)
            {
                SemanticActions.tExist();
            }
            Tokens.NextToken();
            if (Tokens.GetToken().type != Token.Type.Identifier)
            {
                SyntaxError(Tokens.GetToken(), "identifer");
            }
            identifierToken = Tokens.GetToken();
            if (semanticPass)
            {
                SemanticActions.dup(identifierToken, (scope + "." + currentIdentifier));
            }
            if (Tokens.PeekToken().lexeme == "[")
            {
                currentType = "@" + currentType;
            }
            parameters += "P" + uniqueCounter;
            string[] data = new string[2];
            data[0] = "returnType:" + currentType;
            data[1] = "accessMod:" + accessMod;
            Symbol symbol = new Symbol((scope + "." + currentIdentifier), ("P" + uniqueCounter++), Tokens.GetToken().lexeme, "Param", data);

            Tokens.NextToken();
            if (Tokens.GetToken().lexeme == "[")
            {
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != "]")
                {
                    SyntaxError(Tokens.GetToken(), "]");
                }
                Tokens.NextToken();
            }
            SymbolTable.Add(symbol);
            return(true);
        }
Example #10
0
 private static bool numeric_literal()
 {
     if (Tokens.GetToken().lexeme == "+" || Tokens.GetToken().lexeme == "-")
     {
         if (Tokens.PeekToken().type != Token.Type.Number)
         {
             return(false);
         }
         string sign = Tokens.GetToken().lexeme;
         if (sign == "+")
         {
             sign = "";
         }
         Tokens.NextToken();
         string[] data = new string[2];
         data[0] = "returnType:int";
         data[1] = "accessMod:public";
         Symbol symbol = new Symbol("g", ("N" + sign + Tokens.GetToken().lexeme), (sign + Tokens.GetToken().lexeme), "ilit", data);
         SymbolTable.Add(symbol);
         if (semanticPass)
         {
             SemanticActions.lPush(symbol, Tokens.GetToken(), scope);
         }
     }
     else if (Tokens.GetToken().type == Token.Type.Number)
     {
         string[] data = new string[2];
         data[0] = "returnType:int";
         data[1] = "accessMod:public";
         Symbol symbol = new Symbol("g", ("N" + Tokens.GetToken().lexeme), Tokens.GetToken().lexeme, "ilit", data);
         SymbolTable.Add(symbol);
         if (semanticPass)
         {
             SemanticActions.lPush(symbol, Tokens.GetToken(), scope);
         }
     }
     else
     {
         return(false);
     }
     return(true);
 }
Example #11
0
 private static bool Argument_List()
 {
     if (!Expression())
     {
         return(false);
     }
     while (Tokens.GetToken().lexeme == ",")
     {
         if (semanticPass)
         {
             SemanticActions.oPush(Tokens.GetToken());
         }
         Tokens.NextToken();
         if (!Expression())
         {
             SyntaxError(Tokens.GetToken(), "an expression");
         }
     }
     return(true);
 }
Example #12
0
 private static bool Member_Refz()
 {
     if (Tokens.GetToken().lexeme == ".")
     {
         Tokens.NextToken();
         if (Tokens.GetToken().type != Token.Type.Identifier)
         {
             SyntaxError(Tokens.GetToken(), "Identifier");
         }
         if (semanticPass)
         {
             SemanticActions.iPush(Tokens.GetToken(), scope);
         }
         Tokens.NextToken();
         Fn_Arr_Member();
         if (semanticPass)
         {
             SemanticActions.rExist();
         }
         Member_Refz();
         return(true);
     }
     return(false);
 }
Example #13
0
        private static bool Statement()
        {
            if (Tokens.GetToken().lexeme == "{")
            {
                Tokens.NextToken();
                while (Statement())
                {
                    ;
                }
                if (Tokens.GetToken().lexeme != "}")
                {
                    SyntaxError(Tokens.GetToken(), "}");
                }
                Tokens.NextToken();
                return(true);
            }

            if (Tokens.GetToken().lexeme == "if")
            {
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != "(")
                {
                    SyntaxError(Tokens.GetToken(), "(");
                }
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "an expression");
                }
                if (Tokens.GetToken().lexeme != ")")
                {
                    SyntaxError(Tokens.GetToken(), ")");
                }
                if (semanticPass)
                {
                    SemanticActions.ShuntYardAll();
                    SemanticActions.if_(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!Statement())
                {
                    SyntaxError(Tokens.GetToken(), "a statement");
                }
                if (Tokens.GetToken().lexeme == "else")
                {
                    Tokens.NextToken();
                    if (semanticPass)
                    {
                        string SKIPELSE = ICode.SKIPELSE + ICode.labelCounter++ + " ";
                        ICode.JMP(SKIPELSE);
                        ICode.StackElse(SKIPELSE);
                        ICode.Print(ICode.StackIf());
                    }
                    if (!Statement())
                    {
                        SyntaxError(Tokens.GetToken(), "a statement");
                    }
                    if (semanticPass)
                    {
                        ICode.Print(ICode.StackElse());
                    }
                }
                else if (semanticPass)
                {
                    ICode.Print(ICode.StackIf());
                }
                return(true);
            }

            if (Tokens.GetToken().lexeme == "while")
            {
                if (semanticPass)
                {
                    string BEGIN = ICode.BEGIN + ICode.labelCounter++ + " ";
                    ICode.Print(BEGIN);
                    ICode.StackWhile(BEGIN);
                }
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != "(")
                {
                    SyntaxError(Tokens.GetToken(), "(");
                }
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "an expression");
                }
                if (Tokens.GetToken().lexeme != ")")
                {
                    SyntaxError(Tokens.GetToken(), ")");
                }
                if (semanticPass)
                {
                    SemanticActions.ShuntYardAll();
                    SemanticActions.while_(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!Statement())
                {
                    SyntaxError(Tokens.GetToken(), "a statement");
                }
                if (semanticPass)
                {
                    string BEGIN = ICode.StackWhile();
                    ICode.JMP(BEGIN);
                    string ENDWHILE = ICode.StackEndWhile();
                    ICode.Print(ENDWHILE);
                }
                return(true);
            }

            if (Tokens.GetToken().lexeme == "return")
            {
                Tokens.NextToken();
                Expression();
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.return_(Tokens.GetToken(), scope);
                }
                Tokens.NextToken();
                return(true);
            }

            if (Tokens.GetToken().lexeme == "cout")
            {
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != "<<")
                {
                    SyntaxError(Tokens.GetToken(), "<<");
                }
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "an expression");
                }
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.cout();
                }
                Tokens.NextToken();
                return(true);
            }

            if (Tokens.GetToken().lexeme == "cin")
            {
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != ">>")
                {
                    SyntaxError(Tokens.GetToken(), ">>");
                }
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "an expression");
                }
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.cin();
                }
                Tokens.NextToken();
                return(true);
            }

            if (Tokens.GetToken().lexeme == "spawn")
            {
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "an expression");
                }
                if (Tokens.GetToken().lexeme != "set")
                {
                    SyntaxError(Tokens.GetToken(), "set");
                }
                Tokens.NextToken();
                if (Tokens.GetToken().type != Token.Type.Identifier)
                {
                    SyntaxError(Tokens.GetToken(), "an identifier");
                }
                if (semanticPass)
                {
                    SemanticActions.iPush(Tokens.GetToken(), scope);
                }
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.spawn();
                }
                Tokens.NextToken();
                return(true);
            }

            if (Tokens.GetToken().lexeme == "block")
            {
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.block();
                }
                Tokens.NextToken();
                return(true);
            }

            if (Tokens.GetToken().lexeme == "lock")
            {
                Tokens.NextToken();
                if (Tokens.GetToken().type != Token.Type.Identifier)
                {
                    SyntaxError(Tokens.GetToken(), "an identifier");
                }
                if (semanticPass)
                {
                    SemanticActions.iPush(Tokens.GetToken(), scope);
                }
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.lock_();
                }
                Tokens.NextToken();
                return(true);
            }

            if (Tokens.GetToken().lexeme == "release")
            {
                Tokens.NextToken();
                if (Tokens.GetToken().type != Token.Type.Identifier)
                {
                    SyntaxError(Tokens.GetToken(), "an identifier");
                }
                if (semanticPass)
                {
                    SemanticActions.iPush(Tokens.GetToken(), scope);
                }
                Tokens.NextToken();
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.release();
                }
                Tokens.NextToken();
                return(true);
            }

            if (Expression())
            {
                if (Tokens.GetToken().lexeme != ";")
                {
                    SyntaxError(Tokens.GetToken(), ";");
                }
                if (semanticPass)
                {
                    SemanticActions.EOE();
                }
                Tokens.NextToken();
                return(true);
            }
            return(false);
        }
Example #14
0
        private static bool VariableDeclaration()
        {
            if (Tokens.PeekToken().type != Token.Type.Identifier)
            {
                return(false);
            }
            if (!type())
            {
                return(false);
            }
            if (semanticPass)
            {
                SemanticActions.tExist();
            }
            Tokens.NextToken();
            currentIdentifier = Tokens.GetToken().lexeme;
            identifierToken   = Tokens.GetToken();
            Tokens.NextToken();
            if (Tokens.GetToken().lexeme == "[")
            {
                Tokens.NextToken();
                currentType = "@" + currentType;
                if (Tokens.GetToken().lexeme != "]")
                {
                    SyntaxError(Tokens.GetToken(), "]");
                }
                Tokens.NextToken();
            }
            string[] data = new string[2];
            data[0] = "returnType:" + currentType;
            data[1] = "accessMod:" + accessMod;
            Symbol symbol = new Symbol(scope, ("L" + uniqueCounter++), currentIdentifier, "lvar", data);

            identifierSymbol = symbol;
            if (semanticPass)
            {
                SemanticActions.dup(identifierToken, scope);
                SemanticActions.vPush(symbol, identifierToken, scope);
            }
            SymbolTable.Add(symbol);
            if (Tokens.GetToken().lexeme == "=")
            {
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!AssignmentExpression())
                {
                    SyntaxError(Tokens.GetToken(), "assignment expression");
                }
            }
            if (Tokens.GetToken().lexeme != ";")
            {
                SyntaxError(Tokens.GetToken(), ";");
            }
            if (semanticPass)
            {
                SemanticActions.EOE();
            }
            Tokens.NextToken();
            return(true);
        }
Example #15
0
        private static bool ConstructorDeclaration()
        {
            if (Tokens.GetToken().type != Token.Type.Identifier)
            {
                return(false);
            }
            currentIdentifier = Tokens.GetToken().lexeme;
            identifierToken   = Tokens.GetToken();
            if (semanticPass)
            {
                SemanticActions.dup(identifierToken, scope);
                SemanticActions.CD(identifierToken, scope);
            }
            Tokens.NextToken();
            if (Tokens.GetToken().lexeme != "(")
            {
                SyntaxError(Tokens.GetToken(), "(");
            }
            Tokens.NextToken();
            offset         = 0;
            sizeParameters = 0;
            ParameterList();
            string[] data = new string[2];
            data[0] = "returnType:" + currentIdentifier;
            data[1] = "accessMod:" + accessMod;
            Symbol symbol = new Symbol(scope, ("X" + uniqueCounter++), currentIdentifier, "constructor", data);

            currentMethodName = symbol.symid;
            if (!semanticPass)
            {
                currentClassConstructorSymid = symbol.symid;
            }
            data[0] = "returnType:" + currentIdentifier;
            data[1] = "accessMod:" + accessMod;
            Symbol symbol2 = new Symbol(scope, ("Y" + symbol.symid.Substring(1)), currentIdentifier + "StaticInit", "Init", data);

            if (semanticPass)
            {
                ICode.RETURN("this");
                ICode.FUNC(symbol.symid);
                ICode.FRAME(symbol2.symid, "this");
                ICode.CALL(symbol2.symid);
            }
            symbol.parameters = parameters;
            if (Tokens.GetToken().lexeme != ")")
            {
                SyntaxError(Tokens.GetToken(), ")");
            }
            Tokens.NextToken();
            if (!MethodBody())
            {
                SyntaxError(Tokens.GetToken(), "method body");
            }
            symbol.size  = methodSize;
            symbol2.size = 0;
            SymbolTable.Add(symbol);
            SymbolTable.Add(symbol2);
            offset     = 0;
            methodSize = 0;
            return(true);
        }
Example #16
0
        private static bool Expression()
        {
            string lexeme = Tokens.GetToken().lexeme;

            if (lexeme == "(")
            {
                if (semanticPass)
                {
                    SemanticActions.oPush(Tokens.GetToken());
                }
                Tokens.NextToken();
                if (!Expression())
                {
                    SyntaxError(Tokens.GetToken(), "expression");
                }
                if (Tokens.GetToken().lexeme != ")")
                {
                    SyntaxError(Tokens.GetToken(), ")");
                }
                if (semanticPass)
                {
                    SemanticActions.ShuntYardAll();
                }
                Tokens.NextToken();
                Expressionz();
                return(true);
            }
            else if (lexeme == "+" || lexeme == "-" || lexeme == "true" || lexeme == "false" ||
                     lexeme == "null" || lexeme == "this" || Tokens.GetToken().type == Token.Type.Number ||
                     Tokens.GetToken().type == Token.Type.Character)
            {
                if (Tokens.GetToken().lexeme == "this")
                {
                    if (semanticPass)
                    {
                        SemanticActions.iPush(Tokens.GetToken(), scope);
                        SemanticActions.iExist();
                    }
                    Tokens.NextToken();
                    Member_Refz();
                    Expressionz();
                    return(true);
                }
                else if (lexeme == "true" || lexeme == "false" || lexeme == "null")
                {
                    string[] data = new string[2];
                    data[0] = "returnType:bool";
                    data[1] = "accessMod:public";
                    Symbol symbol;
                    if (lexeme == "true")
                    {
                        symbol = new Symbol("g", ("Btrue"), "1", "blit", data);
                    }
                    else if (lexeme == "false")
                    {
                        symbol = new Symbol("g", ("Bfalse"), "0", "blit", data);
                    }
                    else
                    {
                        data[0] = "returnType:null";
                        symbol  = new Symbol("g", "null", "2018", "null", data);
                    }
                    SymbolTable.Add(symbol);
                    if (semanticPass)
                    {
                        SemanticActions.lPush(symbol, Tokens.GetToken(), scope);
                    }
                    Tokens.NextToken();
                    Expressionz();
                    return(true);
                }
                else if (numeric_literal())
                {
                    Tokens.NextToken();
                    Expressionz();
                    return(true);
                }
                else if (character_literal())
                {
                    Tokens.NextToken();
                    Expressionz();
                    return(true);
                }
                return(false);
            }
            else if (Tokens.GetToken().type == Token.Type.Identifier)
            {
                currentIdentifier = Tokens.GetToken().lexeme;
                if (semanticPass)
                {
                    SemanticActions.iPush(Tokens.GetToken(), scope);
                }
                Tokens.NextToken();
                Fn_Arr_Member();
                if (semanticPass)
                {
                    SemanticActions.iExist();
                }
                Member_Refz();
                Expressionz();
                return(true);
            }
            return(false);
        }
Example #17
0
 private static bool FieldDeclaration()
 {
     if (Tokens.GetToken().lexeme == "(")
     {
         Tokens.NextToken();
         parameters = "";
         string methodType = currentType;
         offset         = 0;
         sizeParameters = 0;
         ParameterList();
         methodSize = 0;
         string[] data = new string[2];
         data[0] = "returnType:" + methodType;
         data[1] = "accessMod:" + accessMod;
         Symbol symbol = new Symbol(scope, ("M" + uniqueCounter++), currentIdentifier, "method", data);
         symbol.parameters = parameters;
         currentMethodName = "M";
         if (semanticPass)
         {
             ICode.FUNC(symbol.symid);
         }
         if (Tokens.GetToken().lexeme != ")")
         {
             SyntaxError(Tokens.GetToken(), ")");
         }
         Tokens.NextToken();
         if (!MethodBody())
         {
             SyntaxError(Tokens.GetToken(), "method body");
         }
         symbol.size = methodSize;
         SymbolTable.Add(symbol);
         offset     = 0;
         methodSize = 0;
         return(true);
     }
     else
     {
         bool flag = false;
         if (Tokens.GetToken().lexeme == "[")
         {
             flag = true;
             if (Tokens.PeekToken().lexeme != "]")
             {
                 return(false);
             }
             Tokens.NextToken();
             Tokens.NextToken();
         }
         if (semanticPass)
         {
             SemanticActions.vPush(identifierSymbol, identifierToken, scope);
         }
         if (Tokens.GetToken().lexeme == "=")
         {
             flag = true;
             if (semanticPass)
             {
                 SemanticActions.oPush(Tokens.GetToken());
             }
             Tokens.NextToken();
             if (!AssignmentExpression())
             {
                 return(false);
             }
         }
         if ((Tokens.GetToken().lexeme == ";"))
         {
             if (semanticPass)
             {
                 SemanticActions.EOE();
             }
             Tokens.NextToken();
             return(true);
         }
         if (flag)
         {
             SyntaxError(Tokens.GetToken(), ";");
         }
     }
     return(false);
 }