def parseFact(self):
""" generated source for method parseFact """
if self.curr() == Token("("):
self.match("(")
expr = self.parseExpr()
self.match(")")
return NodeFactExpr(expr)
if self.curr() == Token("-"):
self.match("-")
fact = self.parseFact()
return NodeFactFact(fact)
if (self.curr() == Token("*")):
self.match("*")
id = self.curr().lex()
self.match("id")
return NodeFactDeref(id)
if self.curr() == Token("id"):
nid = self.curr()
self.match("id")
if (self.curr() == Token("(")):
self.match("(")
expr = self.parseExpr()
self.match(")")
return NodeCall(self.pos(), nid.lex(), expr)
return NodeFactId(self.pos(), nid.lex())
num = self.curr()
self.match("num")
return NodeFactNum(num.lex())
def parseFact(self):
""" generated source for method parseFact """
if self.curr() == Token("("):
self.match("(")
expr = self.parseExpr()
self.match(")")
return NodeFactExpr(expr)
if self.curr() == Token("-"):
self.match("-")
fact = self.parseFact()
return NodeFactFact(fact)
if self.curr() == Token("id"):
id = self.curr()
self.match("id")
if self.curr() == Token("("):
self.match("(")
expr = self.parseExpr()
self.match(")")
if id.lex() == "cos":
return NodeCos(expr)
if id.lex() == "sin":
return NodeSin(expr)
if id.lex() == "tan":
return NodeTan(expr)
if id.lex() == "abs":
return NodeAbs(expr)
if id.lex() == "log":
return NodeLog(expr)
if id.lex() == "ln":
return NodeLn(expr)
return NodeFuncCall(id.lex(), expr)
return NodeFactId(self.pos(), id.lex())
num = self.curr()
self.match("num")
return NodeFactNum(num.lex())
def parseMulop(self):
""" generated source for method parseMulop """
if self.curr() == Token("*"):
self.match("*")
return NodeMulop(self.pos(), "*")
if self.curr() == Token("/"):
self.match("/")
return NodeMulop(self.pos(), "/")
return None
def parseAddop(self):
""" generated source for method parseAddop """
if self.curr() == Token("+"):
self.match("+")
return NodeAddop(self.pos(), "+")
if self.curr() == Token("-"):
self.match("-")
return NodeAddop(self.pos(), "-")
return None
def nextKwId(self):
""" generated source for method nextKwId """
old = self.pos
self.many(self.letters)
self.many(self.legits)
lexeme = self.program[old:self.pos]
if self.lexeme in self.keywords:
self.token = Token(lexeme,lexeme)
else:
self.token = Token("id", lexeme)
def nextKwId(self):
startPos = self.pos
self.many(self.legits)
# Gets a token
retrievedToken = self.program[startPos:self.pos]
# Checks if the token is a keyword
if (retrievedToken in self.keywords):
self.token = Token(retrievedToken, retrievedToken)
else:
self.token = Token("id", retrievedToken)
def nextOp(self):
old = self.pos
self.pos = old + 2
if not self.done():
self.lexeme = self.program[old:self.pos]
if self.lexeme in self.operators:
self.token = Token(self.lexeme)
return
self.pos = old + 1
self.lexeme = self.program[old:self.pos]
self.token = Token(self.lexeme)
def nextOp(self):
""" generated source for method nextOp """
old = self.pos
self.pos = old + 2
if not self.done():
self.lexeme = self.program[old: self.pos]
if self.lexeme in self.operators:
self.token = Token(self.lexeme)
return
self.pos = old + 1
self.lexeme = self.program[old: self.pos]
self.token = Token(self.lexeme)
def parseProg(self):
""" generated source for method parseProg """
block = self.parseBlock()
if not self.scanner.done():
raise SyntaxException(self.pos(), Token("EOF"), self.curr())
prog = NodeProg(block)
return prog
def nextKwId(self):
startPos = self.pos
self.many(self.legits)
retrievedToken = self.program[startPos:self.pos]
self.token = Token("id", retrievedToken)
def nextOp(self):
""" generated source for method nextOp """
### fill in here
start_pos = self.position
self.many(self.operators)
self.token = Token("op", self.program[start_pos:self.pos])
def nextNumber(self):
""" generated source for method nextNumber """
### fill in here
start_pos = self.pos
self.many(self.legits)
self.token = Token('num', self.program[start_pos:self.pos])
def nextNumber(self):
""" generated source for method nextNumber """
old = self.pos
self.many(self.digits)
if not self.done() and self.program[self.pos] == '.':
self.pos += 1
self.many(self.digits)
self.token = Token("num", self.program[old:self.pos])
def nextNumber(self):
startPos = self.pos
self.many(self.digits)
retrievedToken = self.program[startPos:self.pos]
self.token = Token("num", retrievedToken)
def parseBlock(self):
""" generated source for method parseBlock """
stmt = self.parseStmt()
rest = None
if self.curr() == Token(";"):
self.match(";")
rest = self.parseBlock()
block = NodeBlock(stmt, rest)
return block
def nextKwId(self):
""" generated source for method nextKwId """
### fill in here
##tracks self.pos right now
start_pos = self.pos
##move self.pos across all reveleant characters
self.many(self.legits)
# pullout varaibles using python slicing
# creates a new token
self.token = Token("id", self.program[start_pos:self.pos])
def parseIf(self):
self.match("if")
bool_expr = self.parseBoolExpr()
self.match("then")
stmt = self.parseStmt()
sub_stmt = None
if self.curr() == Token("else"):
self.match("else")
sub_stmt = self.parseStmt()
if_stmt = NodeIf(bool_expr, stmt, sub_stmt)
return if_stmt
def parseIfElse(self):
""" generated source for method parseIfElse """
self.match("if")
boolexpr = self.parseBoolExpr()
self.match("then")
thenstmt = self.parseStmt()
elsestmt = None
if self.curr() == Token("else"):
self.match("else")
elsestmt = self.parseStmt()
ifelse = NodeIfElse(boolexpr, thenstmt, elsestmt)
return ifelse
def parseWr(self):
""" generated source for method parseWr """
self.match("wr")
if (self.curr() == Token("pointer")):
self.match("pointer")
expr = self.parseExpr()
wr = NodeWr(expr, 1)
return wr
else:
expr = self.parseExpr()
wr = NodeWr(expr, 0)
return wr
def next(self):
""" generated source for method next """
self.many(self.whitespace)
if self.done():
return False
c = self.program[self.pos]
#if c is a kw or id,then call that function
if c in self.letters:
self.nextKwId()
# if c is a digit do something
elif c in self.digits:
self.nextNumber()
# for all other cases
else:
self.token = Token(c, c)
## self.nextOp
self.pos += 1
return True
def parseStmt(self):
""" generated source for method parseStmt """
if self.curr() == Token("id") or self.curr() == Token(
"*") or self.curr() == Token("pointer"):
assn = self.parseAssn()
return NodeStmt(assn)
if self.curr() == Token("rd"):
rd = self.parseRd()
return NodeStmt(rd)
if self.curr() == Token("wr"):
wr = self.parseWr()
return NodeStmt(wr)
if self.curr() == Token("if"):
ifelse = self.parseIfElse()
return NodeStmt(ifelse)
if self.curr() == Token("while"):
whiledo = self.parseWhileDo()
return NodeStmt(whiledo)
if self.curr() == Token("def"):
func = self.parseFunc()
return func
begin = self.parseBegin()
return NodeStmt(begin)
def next(self):
""" generated source for method next """
self.many(self.whitespace)
if self.done():
self.token = Token('')
return False
c = self.program[self.pos]
if c in self.digits:
self.nextNumber()
elif c in self.letters:
self.nextKwId()
elif c in self.operators:
self.nextOp()
elif c == "#":
self.pos += 1
self.past('\n')
return self.next()
else:
print("illegal character " + self.program[self.pos] + " at position " + str(self.pos))
self.pos += 1
return self.next()
return True
def parseRelop(self):
if self.curr() == Token("<"):
self.match("<")
return NodeRelop(self.pos(), "<")
if self.curr() == Token("<="):
self.match("<=")
return NodeRelop(self.pos(), "<=")
if self.curr() == Token(">"):
self.match(">")
return NodeRelop(self.pos(), ">")
if self.curr() == Token(">="):
self.match(">=")
return NodeRelop(self.pos(), ">=")
if self.curr() == Token("<>"):
self.match("<>")
return NodeRelop(self.pos(), "<>")
if self.curr() == Token("=="):
self.match("==")
return NodeRelop(self.pos(), "==")
return None
def parseStmt(self):
""" generated source for method parseStmt """
if self.curr() == Token("rd"):
rd = self.parseRd()
return NodeStmt(rd)
if self.curr() == Token("wr"):
wr = self.parseWr()
return NodeStmt(wr)
if self.curr() == Token("if"):
if_stmt = self.parseIf()
return NodeStmt(if_stmt)
if self.curr() == Token("while"):
while_stmt = self.parseWhile()
return NodeStmt(while_stmt)
if self.curr() == Token("begin"):
begin = self.parseBegin()
return NodeStmt(begin)
if self.curr() == Token("def"):
func_decl = self.parseFuncDecl()
return NodeStmt(func_decl)
if self.curr() == Token("id"):
assn = self.parseAssn()
return NodeStmt(assn)
return None
def parseRelop(self):
""" generated source for method parseRelop """
if self.curr() == Token("<"):
self.match("<")
return NodeRelop(self.pos(), "<")
if self.curr() == Token("<="):
self.match("<=")
return NodeRelop(self.pos(), "<=")
if self.curr() == Token(">"):
self.match(">")
return NodeRelop(self.pos(), ">")
if self.curr() == Token(">="):
self.match(">=")
return NodeRelop(self.pos(), ">=")
if self.curr() == Token("<>"):
self.match("<>")
return NodeRelop(self.pos(), "<>")
if self.curr() == Token("=="):
self.match("==")
return NodeRelop(self.pos(), "==")
return None
def match(self, s):
""" generated source for method match """
self.scanner.match(Token(s))
def curr(self):
""" generated source for method curr """
if self.token == None:
raise SyntaxException(self.pos, Token("ANY"), Token("EMPTY"))
return self.token
def nextOp(self):
retrievedToken = self.program[self.pos]
self.token = Token(retrievedToken, retrievedToken)
self.pos += 1
def parseStmt(self):
""" generated source for method parseStmt """
if self.curr() == Token("id"):
assn = self.parseAssn()
return NodeStmt(assn)
return None
