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); }
private static bool Start() { globalOffset = 12;//first line in assembly is a jmp if (!semanticPass) { address = 0; offset = 0; memberVariables = new List <string>(); } while (ClassDeclaration()) { ; } if (!Tokens.GetToken().lexeme.Equals("void")) { SyntaxError(Tokens.GetToken(), "void return for main"); } Tokens.NextToken(); if (!Tokens.GetToken().lexeme.Equals("pxi")) { SyntaxError(Tokens.GetToken(), "pxi"); } Tokens.NextToken(); if (!Tokens.GetToken().lexeme.Equals("main")) { SyntaxError(Tokens.GetToken(), "main method"); } string[] data = new string[2]; data[0] = "returnType:void"; data[1] = "accessMod:public"; Symbol symbol = new Symbol("g", ("MAIN"), Tokens.GetToken().lexeme, "main", data); SymbolTable.Add(symbol); currentMethodName = "M"; identifierToken = Tokens.GetToken(); currentIdentifier = ""; scope += ".main"; if (semanticPass) { ICode.FUNC(symbol.symid); } Tokens.NextToken(); if (Tokens.GetToken().lexeme != "(") { SyntaxError(Tokens.GetToken(), "("); } Tokens.NextToken(); if (Tokens.GetToken().lexeme != ")") { SyntaxError(Tokens.GetToken(), ")"); } Tokens.NextToken(); if (!MethodBody()) { SyntaxError(Tokens.GetToken(), "method body"); } return(true); }
public static void iExist() { SAR top_sar = SAS.Pop(); if (top_sar.value == "this") { SAS.Push(top_sar); return; } string args = ""; if (top_sar.argList.Count != 0) { args = top_sar.argList[0]; for (int i = 1; i < top_sar.argList.Count; ++i) { args += "," + top_sar.argList[i]; } } top_sar.paramType = args; string symid = SymbolTable.iExists(top_sar); if (symid == null || !SymbolTable.ContainsSymid(symid)) { SemanticError(top_sar); } Symbol symbol = SymbolTable.GetValue(symid); if (symbol.data != null) { top_sar.dataType = symbol.data[0].Split(':')[1]; top_sar.dataType.Trim(); } top_sar.paramType = symbol.parameters; top_sar.symid = symbol.symid; if (symbol.kind == "method") { ICode.FRAME(symbol.symid, "this"); if (symbol.parameters != null && symbol.parameters != "") { for (int i = 0; i < top_sar.argList.Count; ++i) { ICode.PUSH(top_sar.argList[i]); } } ICode.CALL(symbol.symid); Symbol temp = new Symbol("t", "t" + uniqueCounter++, "t_" + symbol.value + "_ReturnValue", "tvar", symbol.data); SymbolTable.Add(temp); top_sar.symid = temp.symid; if (symbol.data[0].Split(':')[1] != "void" && symbol.data[0].Split(':')[1] != "null") { ICode.PEEK(temp.symid); } } SAS.Push(top_sar); }
public static void MathOperator() { bool valid = false; SAR y = SAS.Pop(); SAR x = SAS.Pop(); SAR z = new SAR(SAR.SARtype.Identifier, x.token, x.value, x.scope); z.dataType = x.dataType; string op = OS.Peek(); if (x.dataType[0] == '@' && x.argList != null && x.argList.Count != 0) { if (x.dataType.Substring(1, x.dataType.Length - 1) == y.dataType) { valid = true; } } if (y.dataType[0] == '@' && y.argList != null && y.argList.Count != 0) { if (y.dataType.Substring(1, y.dataType.Length - 1) == x.dataType) { valid = true; } } if (((x.dataType == y.dataType) && (x.dataType == "int")) || valid) { z.symid = "t" + uniqueCounter++; z.value += "_" + y.value; z.scope = "t"; string[] data = { "returnType:" + z.dataType, "accessMod:private" }; Symbol temp = new Symbol("t", z.symid, z.value, "tvar", data); SymbolTable.Add(temp); if (op == "+") { ICode.ADD(x.symid, y.symid, z.symid); } else if (op == "-") { ICode.SUB(x.symid, y.symid, z.symid); } else if (op == "*") { ICode.MUL(x.symid, y.symid, z.symid); } else if (op == "/") { ICode.DIV(y.symid, x.symid, z.symid); } SAS.Push(z); OS.Pop(); OSprecidence.Pop(); return; } SemanticOperationError(x, y, OS.Peek()); }
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); }
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); }
public static void itoa() { SAR exp = SAS.Pop(); if (exp.dataType != "int") { SemanticAtoiError(exp); } string[] data = { "returnType:char", "accessMod:private" }; Symbol temp = new Symbol("t", "t" + uniqueCounter++, "t" + exp.value, "tvar", data); SymbolTable.Add(temp); ICode.MOV(temp.symid, exp.symid); ICode.CONVERT(temp.symid); exp.dataType = "char"; exp.symid = temp.symid; SAS.Push(exp); }
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); }
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); }
public static void NewObj() { SAR al = SAS.Pop(); SAR type = SAS.Pop(); if (!SymbolTable.NewObj(type, al.argList.ToArray())) { SemanticError(type); } string functionSymid = type.symid; type.sarType = SAR.SARtype.Ref; type.symid = "t" + uniqueCounter++; string[] data = { "returnType:" + type.dataType, "accessMod:private" }; Symbol instance = new Symbol("t", type.symid, "t" + type.value, "tvar", data); SymbolTable.Add(instance); string[] data2 = { "returnType:" + type.dataType, "accessMod:private" }; Symbol peekTemp = new Symbol("t", "t" + uniqueCounter++, "t" + type.value + "ReturnValue", "tvar", data2); SymbolTable.Add(peekTemp); Symbol staticInit = SymbolTable.GetValue(("Y" + functionSymid.Substring(1))); ICode.NEWI(type.size.ToString(), type.symid); //call constructor ICode.FRAME(functionSymid, type.symid); if (al.argList != null && al.argList.Count > 0 && al.argList[0] != "") { for (int i = 0; i < al.argList.Count; ++i) { ICode.PUSH(al.argList[i]); } } ICode.CALL(functionSymid); ICode.PEEK(peekTemp.symid); type.symid = peekTemp.symid; SAS.Push(type); }
public static void Start(ref List <string> iCode, string filename) { int labelOffset = 0; string operand1 = ""; string operand2 = ""; string operand3 = ""; string instruction; string[] line; string[] comments; string[] data = new string[2]; data[0] = "returnType:int"; data[1] = "accessMod:public"; string[] dataChar = new string[2]; dataChar[0] = "returnType:char"; dataChar[1] = "accessMod:public"; SymbolTable.Add(new Symbol("g", TRUE, "1", "ilit", data)); SymbolTable.Add(new Symbol("g", FALSE, "0", "ilit", data)); SymbolTable.Add(new Symbol("g", "N4", "4", "ilit", data)); SymbolTable.Add(new Symbol("g", "N-1", "-1", "ilit", data)); SymbolTable.Add(new Symbol("g", "H!", "!", "c**t", dataChar)); SymbolTable.Add(new Symbol("g", "FREE", "0", "ilit", data)); filename = filename.Split('.')[0] + ".asm"; sw = new StreamWriter(filename, false); List <Symbol> globalVars = SymbolTable.GetSymbolsInScope("g"); Symbol var; pc = 0; for (int i = 0; i < globalVars.Count; ++i)//print all global variables at top of assembly file { var = globalVars[i]; if (var.symid[0] == 'H') { if (var.symid.Length == 1) { sw.WriteLine(var.symid + " .BYT "); } else { sw.WriteLine(var.symid + " .BYT " + var.symid.Substring(1, (var.symid.Length - 1))); } ++pc; } else if (var.symid[0] == 'N' || var.symid[0] == 'B' || var.symid == "null") { sw.WriteLine(var.symid + " .INT " + var.value); pc += 4; } } sw.WriteLine(FREE + " .INT 0");//address of available heap pc += 4; sw.WriteLine(";------------------------END OF DATA SEGMENT-----------------------"); LDR(registers[(int)Register.True], TRUE); LDR(registers[(int)Register.False], FALSE); LDA(registers[(int)Register.OP1], END); //load address of final instruction in code segment ADI(registers[(int)Register.OP1], (3 * INSTRUCT_SIZE).ToString()); //get address of first free heap location STR(registers[(int)Register.OP1], FREE); //update free heap location MOV(registers[(int)Register.OP1], registers[(int)Register.FP]); ADI(registers[(int)Register.OP1], (-1 * VAR_SIZE).ToString()); STR(registers[(int)Register.FP], registers[(int)Register.OP1]);//set fp to pfp (bottom of stack) _iCode = iCode; foreach (string s in _iCode) { bufferedLine = ""; labelOffset = 0; operand1 = ""; operand2 = ""; operand3 = ""; comments = s.Split(';'); line = comments[0].Trim().Split(' '); comment = COMMENT_FORMAT + comments[0]; for (int i = 1; i < comments.Length; ++i) { comment += comments[i]; } if (!_instructions.Contains <string>(line[0])) { //label labelOffset = 1; instruction = line[1]; bufferedLine = line[0] + " "; } else { labelOffset = 0; instruction = line[0]; } if (line.Length > labelOffset + 1)//contains 1 or more operands { operand1 = line[labelOffset + 1]; } if (instruction == "FUNC") { operand2 = operand1; } else { if (line.Length > labelOffset + 2)//contains 2 or more operands { operand2 = line[labelOffset + 2]; } if (line.Length > labelOffset + 3)//contains 2 or more operands { operand3 = line[labelOffset + 3]; } } InstructionCall(instruction, operand1, operand2, operand3); } sw.WriteLine(OVERFLOW + " LDB R3 H!"); pc += 12; sw.WriteLine("TRP 3"); pc += 12; sw.WriteLine(UNDERFLOW + " LDB R3 H!"); pc += 12; sw.WriteLine("TRP 3"); pc += 12; sw.Write(END + " TRP 0"); sw.Flush(); sw.Close(); }
public static void BoolOperator() { SAR y = SAS.Pop(); SAR x = SAS.Pop(); SAR z = new SAR(SAR.SARtype.Identifier, x.token, x.value, x.scope); string op = OS.Peek(); if (op == "==" || op == "!=") { if ((x.dataType != y.dataType) && (y.dataType != "null")) { SemanticOperationError(x, y, OS.Pop()); } } else if ((x.dataType != y.dataType)) { /*if(x.dataType == "int" || x.dataType == "char") * { * * } * else * {*/ SemanticOperationError(x, y, OS.Pop()); // } } z.symid = "t" + uniqueCounter++; z.value += "_" + y.value; z.scope = "t"; z.dataType = "bool"; string[] data = { "returnType:" + z.dataType, "accessMod:private" }; Symbol temp = new Symbol("t", z.symid, z.value, "tvar", data); SymbolTable.Add(temp); if (op == "<") { ICode.LT(x.symid, y.symid, z.symid); } else if (op == ">") { ICode.GT(x.symid, y.symid, z.symid); } else if (op == "!=") { ICode.NE(x.symid, y.symid, z.symid); } else if (op == "==") { ICode.EQ(x.symid, y.symid, z.symid); } else if (op == "<=") { ICode.LE(x.symid, y.symid, z.symid); } else if (op == ">=") { ICode.GE(x.symid, y.symid, z.symid); } SAS.Push(z); OS.Pop(); OSprecidence.Pop(); return; }
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); }
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); }
public static void rExist() { SAR top_sar = SAS.Pop(); SAR LHS = SAS.Peek(); bool this_ = false; string scope = top_sar.scope; if (SAS.Count > 0) { if (SAS.Peek().value != "this") { top_sar.classType = SAS.Pop().dataType; } else { this_ = true; string[] temp = top_sar.scope.Split('.'); top_sar.classType = temp[temp.Length - 1]; SAS.Pop(); } } else { SemanticError(top_sar); } Symbol symbol; if ((symbol = SymbolTable.rExists(top_sar)) == null) { SemanticError(top_sar); } if (symbol.data != null) //not a class { if ((symbol.data[symbol.data.Length - 1] == "accessMod:public") || this_) //member is public { top_sar.dataType = symbol.data[0].Split(':')[1]; top_sar.dataType.Trim(); top_sar.sarType = SAR.SARtype.Ref; top_sar.symid = "t" + uniqueCounter++; top_sar.scope = "t"; string[] data = { "returnType:" + top_sar.dataType, "accessMod:private" }; if (symbol.kind == "method") { ICode.FRAME(symbol.symid, LHS.symid); if (symbol.parameters != null && symbol.parameters != "") { for (int i = 0; i < top_sar.argList.Count; ++i) { ICode.PUSH(top_sar.argList[i]); } } ICode.CALL(symbol.symid); ICode.PEEK(top_sar.symid); } else { top_sar.symid += "r"; if (LHS.value == "this") { LHS.symid = "this"; } ICode.REF(LHS.symid, symbol.symid, top_sar.symid); } Symbol temp = new Symbol(top_sar.scope, top_sar.symid, "t" + top_sar.value, "tvar", data); SymbolTable.Add(temp); SAS.Push(top_sar); return; } else { SemanticPrivateError(top_sar); } } /*if (SymbolTable.ContainsValue(scope + "." + top_sar.value)) * { * Symbol symbol = SymbolTable.GetValue(SymbolTable.GetSymid(scope + "." + top_sar.value)); * if (symbol.data != null) //not a class * { * if (symbol.data[symbol.data.Length - 1]=="accessMod:public") //member is public * { * top_sar.dataType = symbol.data[0].Split(':')[1]; * top_sar.dataType.Trim(); * if (symbol.data.Length == 3) * { * top_sar.paramType = symbol.data[1]; * } * top_sar.sarType = SAR.SARtype.Ref; * SAS.Push(top_sar); * return; * } * } * }*/ SemanticError(top_sar); }
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); }
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); }