def switchStat(): global token exitList = intermediate.emptyList() e1 = expression() while token[0] != "endswitch": if token[0] == "case": token = lexi.lex() e2 = expression() if token[0] == "upDownTk": bTrue = intermediate.makeList(intermediate.nextQuad()) #references ["=", e1, e2, "_"] intermediate.genQuad("=", e1, e2, "_") bFalse = intermediate.makeList(intermediate.nextQuad()) #references ["jump", "_", "_", "_"] intermediate.genQuad("jump", "_", "_", "_") intermediate.backPatch(bTrue, intermediate.nextQuad()) # ["=", e1, e2, tells where to go] token = lexi.lex() statements() tList = intermediate.makeList(intermediate.nextQuad()) intermediate.genQuad("jump", "_", "_", "_") exitList = intermediate.merge(exitList, tList) intermediate.backPatch(bFalse, intermediate.nextQuad()) else: line = getLineAndColumn() print("Syntax error: expected ':' at line " + str(line[0]+1)+".") exit() else: line = lexi.getLineAndColumn() print("Syntax error: 'endswitch' or 'case' statement is missing .") exit() intermediate.backPatch(exitList, intermediate.nextQuad()) token = lexi.lex() return
def varlist(): global token if token[0] == "Id": checkAlreadyDeclaredIdentifier() symbolTable.newVariableEntity(token[1]) lexi.token = lex() while token[0] != "enddeclare": if token[0] == "commaTk": token = lexi.lex() checkAlreadyDeclaredIdentifier() symbolTable.newVariableEntity(token[1]) if token[0] == "Id": token = lexi.lex() else: line = lexi.getLineAndColumn() print("Syntax error: Invalid arguments after ',' at line " + str(line[0] + 1)+".") exit() else: line = lexi.getLineAndColumn() print("Syntax error: Invalid arguments at 'declare' statement at line " + str(line[0] + 1)+".") exit() token = lexi.lex() return elif token[0] == "enddeclare": token = lexi.lex() return else: line = lexi.getLineAndColumn() print("Syntax error: 'enddeclare' is missing at line " + str(line[0] + 1)+".") exit()
def factor(): global token if token[0] == "constantTk" : constant = token[1] token = lexi.lex() return constant elif token[0] == "Id": checkUndeclaredIdentifier() identifier = token[1] token = lexi.lex() return idTail(identifier) elif token[0] =="leftparenthesisTk": token = lex() expression1 = expression() if token[0] == "rightparenthesisTk" : token = lexi.lex() return expression1 else: line = lexi.getLineAndColumn() print("Syntax error: ')' is missing at line " + str(line[0]+1)+".") exit() else: line = lexi.getLineAndColumn() print("Syntax error: 'actualParameter' is missing at line " + str(line[0]+1)+".") exit()
def forcaseStat(): global token flag = intermediate.newTemp() forQuad = intermediate.nextQuad() intermediate.genQuad(":=", "0", "_", flag) while token[0] != "endforcase": if token[0] == "when": token = lexi.lex() (bTrue, bFalse) = condition() intermediate.backPatch(bTrue, intermediate.nextQuad()) if token[0] == "upDownTk": token = lexi.lex() statements() genQuad(":=", "1", "_", flag) intermediate.backPatch(bFalse, intermediate.nextQuad()) else: line = lexi.getLineAndColumn() print("Syntax error: expected ':' at line " + str(line[0]+1)+".") exit() else: line = lexi.getLineAndColumn() print("Syntax error: expected 'when' at line " + str(line[0]+1)+".") exit() intermediate.genQuad("=", flag, "1", forQuad) token = lexi.lex() return
def program(): global token token = lexi.lex() if token[0] == "program": token = lexi.lex() if token[0] == "Id": symbolTable.newScope() programId = "__main" token = lexi.lex() block(programId) symbolTable.setLastFunctionFrameLength() if token[0] == "endprogram": final.genQuad("halt", "_", "_", "_") intermediate.genQuad("end_block", programId, "_", "_") final.genFinalCode() symbolTable.deleteScope() token = lexi.lex() if token == "EOF": print("Passed Test Successfully!") else: line = lexi.getLineAndColumn() print("Syntax error: code after 'endprogram' statement at line " + str(line[0] + 1)+".") exit() else: print("Syntax error: 'endprogram' statement is missing.") exit() else: print("Syntax error: program name is missing at line.") exit() else: print("Syntax error: 'program' statement is missing.") exit()
def formalparlist(): global token while token[0] != "rightparenthesisTk": formalparitem() if token[0] == "commaTk" : token = lexi.lex() formalparitem() if token[0] != "rightparenthesisTk": token = lexi.lex() token = lex() return
def procorfunc(): global token global funcList global inFunction global returnFound returnFound = False token2 = "" if token[0] == "procedure" or token[0] == "function": token2 = token[0] token = lexi.lex() if token[0] == "Id": checkAlreadyDeclaredIdentifier() inFunctionLocal = inFunction inFunction = False if token2 == "function": inFunction = True symbolTable.newFunctionEntity(token[1], True) symbolTable.newScope() else: symbolTable.newFunctionEntity(token[1], False) symbolTable.newScope() name = token[1] funcList.append(name) token = lexi.lex() procorfuncbody(token2, name) if token2 == "procedure": if token[0] == "endprocedure": final.genFinalCode() symbolTable.deleteScope() token = lexi.lex() return else: print("Syntax error: 'endprocedure' statement expected.") exit() elif token2 == "function": if token[0] == "endfunction": final.genFinalCode() symbolTable.deleteScope() token = lexi.lex() if returnFound == False and inFunction == True: print("No 'return' statement found in function.") returnFound = False inFunction = inFunctionLocal exit() return else: print("Syntax error: 'endfunction' statement expected.") exit() else: line = lexi.getLineAndColumn() print("Syntax error: '"+str(token2)+"' name is missing at line " + str(line[0] + 1)+".") exit()
def actualPars(identifier, functionItem): global token if token[0] == "leftparenthesisTk" : token = lexi.lex() actualParlist(functionItem) if token[0] == "rightparenthesisTk": token = lexi.lex() return else: line = lexi.getLineAndColumn() print("Syntax error: ')' is missing at line " + str(line[0]+1)+".") exit() else: return identifier
def statements(): global token statement() while token[0] == "semiColumnTk": token = lexi.lex() statement() return
def optionalSign(): global token if token[0] == "addOperTk": token = lexi.lex() return return
def elsepart(): global token if token[0] == "else": token = lexi.lex() statements() return return
def declarations(): global token if token[0] == "declare": token = lexi.lex() varlist() else: return
def callStat(callId): global token global a global param global counter global temp if counter == 0: a = intermediate.newTemp() param.append(a) counter += 1 if token[0] == "Id": functionItem, _ = symbolTable.findEntity(token[1]) procedureName = token[1] token = lexi.lex() actualPars(procedureName, functionItem) if token[0] == "rightparenthesisTk" or token[0]== "commaTk": intermediate.genQuad("par", temp, "RET", "_") intermediate.genQuad("call", callId, "_", "_") else: for i in range(1,len(param)): intermediate.genQuad("par",param[i],"in","_") intermediate.genQuad("par",param[0],"RET","_") intermediate.genQuad("call", callId, "_", "_") counter = 0 param = [] else: line = lexi.getLineAndColumn() print("Syntax error: 'function' name is missing at line " + str(line[0]+1)+".") exit()
def formalpars(): global token if token[0] == "leftparenthesisTk" : token = lexi.lex() formalparlist() else: line = lexi.getLineAndColumn() print("Syntax error: '(' statement is missing at line " + str(line[0]+1)+".") return
def inputStat(): global token if token[0] == "Id": idToken = token[1] intermediate.genQuad("inp", idToken, "_", "_") token = lexi.lex() return else: line = lexi.getLineAndColumn() print("Syntax error: input is missing at line " + str(line[0]+1)+".") exit()
def actualParlist(functionItem): global token global counter global param argumentId = 0 actualParitem(functionItem, argumentId) while token[0] == "commaTk": argumentId += 1 token = lexi.lex() actualParitem(functionItem, argumentId) return
def relationalOper(): global token relationalList = ["=","<=",">=",">","<","<>"] x = token[1] relopType = token[1] #return operator for x in range(0,len(relationalList)): token = lexi.lex() return relopType else: line = lexi.getLineAndColumn() print("Syntax error: 'relational operator' is missing at line " + str(line[0]+1)+".") exit()
def boolterm(): global token (r1True, r1False) = boolfactor() qTrue = r1True qFalse = r1False while token[0] == "and": token = lexi.lex() intermediate.backPatch(qTrue, nextQuad()) (r2True, r2False) = boolfactor() qFalse = intermediate.merge(qFalse, r2False) qTrue = r2True return (qTrue, qFalse)
def condition(): global token (q1True, q1False) = boolterm() bTrue = q1True bFalse = q1False while token[0] == "or": token = lexi.lex() intermediate.backPatch(bFalse, intermediate.nextQuad()) (q2True, q2False) = boolterm() bTrue = intermediate.merge(bTrue, q2True) bFalse = q2False return (bTrue, bFalse)
def actualParitem(functionItem, argumentId): global token global param global counter global temp if token[0] == "in": if functionItem.argumentList[argumentId].isIn == False: print("Expected 'inout' but found 'in'") exit() token = lexi.lex() actualParId = token[1] exp = expression() intermediate.genQuad("par", exp, "CV", "_") return elif token[0] == "inout": if functionItem.argumentList[argumentId].isIn == True: print("Expected 'in' but found 'inout'") exit() token = lexi.lex() if token[0] == "Id": checkUndeclaredIdentifier() actualParId = token[1] intermediate.genQuad("par", actualParId, "REF", "_") token = lexi.lex() return else: line = lexi.getLineAndColumn() print("Syntax error: 'Parameter' is missing at line " + str(line[0]+1)+".") exit() elif token[0] == "call": temp = intermediate.newTemp() param.append(temp) counter += 1 token = lexi.lex() callId = token[1] callStat(callId) else: line = lexi.getLineAndColumn() print("Syntax error: 'in' or 'inout' is missing at line " + str(line[0] + 1) +".") exit()
def ifStat(): global token (bTrue, bFalse) = condition() if token[0] == "then": intermediate.backPatch(bTrue, intermediate.nextQuad()) token = lexi.lex() statements() ifList = intermediate.makeList(intermediate.nextQuad()) intermediate.genQuad("jump","_","_","_") intermediate.backPatch(bFalse, intermediate.nextQuad()) elsepart() intermediate.backPatch(ifList, intermediate.nextQuad()) if token[0] == "endif": token = lexi.lex() return else: print("Syntax error: 'endif' statement is missing.") exit() else: line = lexi.getLineAndColumn() print("Syntax error: 'then' statement is missing at line " + str(line[0]+1)+".") exit()
def whileStat(): global token q = intermediate.nextQuad() (bTrue, bFalse) = condition() intermediate.backPatch(bTrue, intermediate.nextQuad()) statements() intermediate.genQuad("jump","_","_", q) intermediate.backPatch(bFalse,nextQuad()) if token[0] == "endwhile": token = lexi.lex() return else: print("Syntax error: 'endwhile' statement is missing. " ) exit()
def repeatStat(): global token global exitList global inRepeat currentExitList = exitList #temp list with all the values exitList = intermediate.emptyList() #clear the global exitList inRepeat = True bRepeat = intermediate.nextQuad() #beginning of repeat while token[0] != "endrepeat": statements() inRepeat = False genQuad("jump", "_", "_", bRepeat) #jump to the start of repeat outOfRepeat = intermediate.nextQuad() #out of the repeat backPatch(exitList, outOfRepeat) #backPatch the current out of repeat exitList = currentExitList #give back to global list token = lexi.lex() return
def boolfactor(): global token if token[0] == "not": token = lexi.lex() if token[0] == "leftlogicparenthesisTk": token = lexi.lex() (q1True, q1False) = condition() if token[0] != "rightlogicparenthesisTk": line = lexi.getLineAndColumn() print("Syntax error: ']' statement is missing at line " + str(line[0]+1)+".") exit() token = lexi.lex() return (q1False,q1True) else: line = lexi.getLineAndColumn() print("Syntax error: '[' statement is missing at line " + str(line[0]+1)+".") exit() elif token[0] == "leftlogicparenthesisTk": token = lexi.lex() (q1True, q1False) = condition() if token[0] != "rightlogicparenthesisTk": line = lexi.getLineAndColumn() print("Syntax error: ']' statement is missing at line " + str(line[0]+1)+".") exit() token = lexi.lex() return (q1True, q1False) elif token[0] == "true" or token[0] == "false": if token[0] =="true": q2True = intermediate.makeList(intermediate.nextQuad()) q2False = intermediate.emptyList() intermediate.genQuad("true", "_", "_", "_") else: q2False = intermediate.makeList(intermediate.nextQuad()) q2True = intermediate.emptyList() intermediate.genQuad("false", "_", "_", "_") token = lexi.lex() return (q2True, q2False) else: expression1 = expression() relop = relationalOper() expression2 = expression() rTrue = makeList(intermediate.nextQuad()) intermediate.genQuad(relop, expression1, expression2, "_") rFalse = makeList(intermediate.nextQuad()) intermediate.genQuad("jump", "_", "_", "_") return (rTrue, rFalse)
def formalparitem(): global token if token[0] == "inout" or token[0] == "in": isIn = False if token[0] == "in": isIn = True token = lex() symbolTable.newArgument(isIn) symbolTable.newParameterEntity(token[1], isIn) if token[0] != "Id" : line = lexi.getLineAndColumn() print("Syntax error: 'Parameter' is missing at line " + str(line[0]+1)+".") exit() else: token = lexi.lex() return else: line = lexi.getLineAndColumn() print("Syntax error: 'inout' or 'in' statement is missing at line " + str(line[0]+1)+".") exit()
def statement(): global token global exitList global var if token[0] == "Id": checkUndeclaredIdentifier() var = token[1] token = lexi.lex() if token[0] == "inputTk": token = lexi.lex() assignmentStat(var) else: line = lexi.getLineAndColumn() print("Syntax error: expected ':=' statement after variable at line " + str(line[0]+1)+".") exit() elif token[0] == "repeat": token = lexi.lex() repeatStat() elif token[0] == "if": token = lexi.lex() ifStat() elif token[0] == "while": token = lexi.lex() whileStat() elif token[0] == "exit": exitFound = True if inRepeat == False: print("'exit' statement found outside of repeat.") exit() bExit = intermediate.makeList(nextQuad()) genQuad("jump", "_", "_", "_") exitList = intermediate.merge(exitList, bExit) #list with jumps potition token = lexi.lex() elif token[0] == "switch": token = lexi.lex() switchStat() elif token[0] == "forcase": token = lexi.lex() forcaseStat() elif token[0] == "call": token = lexi.lex() callId = token[1] callStat(callId) elif token[0] == "return": returnFound = True if inFunction == False: print("'return' statement found outside of function.") exit() token = lexi.lex() returnStat() elif token[0] == "input": token = lexi.lex() inputStat() elif token[0] == "print": token = lexi.lex() printStat() else: return return
def addOper(): global token token = lexi.lex() return
def mulOper(): global token token = lexi.lex() return