# -*- coding: utf-8 -*-
from ast import *
from lexer import *
from token import *
class Parser:
def __init__(self, lex):
self.lexer = lex
self.token = lex.scan()
self.count = 1 #debug
return
def parse(self):
return self.program()
def move(self):
print self.count, self.token #debug
self.count += 1 #debug
self.token = self.lexer.scan()
return
def error(self, msg):
raise Exception(msg)
def match(self, tag):
if self.token == None:
self.error("Unexpected end of file.")
if self.token.tag != tag:
self.error("match: expected %s got %s\n" %(tag, self.token.tag))
val = self.token.value
self.move()
return val
# boolean = join { "||" join }.
def boolean(self):
res = self.join()
while self.token.tag == Tag.OPERATOR and self.token.value == "||":
self.move()
res = BinaryExpression(res, "||", self.join())
return res
# join = equality { "&&" equality }.
def join(self):
res = self.equality()
while self.token.tag == Tag.OPERATOR and self.token.value == "&&":
self.move()
res = BinaryExpression(res, "&&", self.relation())
return res
# equality = relation { ( "==" | "!=" ) relation }.
def equality(self):
res = self.relation()
while self.token.tag == Tag.OPERATOR and self.token.value in ["==", "!="]:
op = self.match(Tag.OPERATOR)
res = BinaryExpression(res, op, self.relation())
return res
# relation = expression { ( "<" | "<=" | ">=" | ">" ) expression }.
def relation(self):
res = self.expression()
while self.token.tag == Tag.OPERATOR and self.token.value in ["<", "<=", ">=", ">"]:
op = self.match(Tag.OPERATOR)
res = BinaryExpression(res, op, self.expression())
return res
# expression = term { ( "+" | "-" ) term }.
def expression(self):
res = self.term()
while self.token.tag == Tag.OPERATOR and self.token.value in ["+", "-"]:
op = self.match(Tag.OPERATOR)
res = BinaryExpression(res, op, self.term())
return res
# term = unary { ( "*" | "/" | "%" ) unary }.
def term(self):
res = self.unary()
while self.token.tag == Tag.OPERATOR and self.token.value in ["*", "/", "%"]:
op = self.match(Tag.OPERATOR)
res = BinaryExpression(res, op, self.unary())
return res
# unary = "!" unary | "-" unary | factor.
def unary(self):
if self.token.tag == Tag.OPERATOR and self.token.value == "!":
self.move()
return UnaryExpression("!", self.unary())
if self.token.tag == Tag.OPERATOR and self.token.value == "-":
self.move()
return UnaryExpression("-", self.unary())
return self.factor()
# factor = "(" boolean ")" | integer | "true" | "false" | ident | function_call.
def factor(self):
if self.token.tag == Tag.LPAREN:
self.move()
res = self.boolean()
self.match(Tag.RPAREN)
return res
if self.token.tag == Tag.NUMBER:
return Constant(self.match(Tag.NUMBER))
if self.token.tag == Tag.TRUE:
self.move()
return Constant(1)
if self.token.tag == Tag.FALSE:
self.move()
return Constant(0)
''' Wegen der Änderung in function_call() kann die Grammatik nicht
mehr mit einem Lookahead von 1 geparst werden. Die Lösung hier
ist, den Aufruf von function_call() zu "inlinen". Muss irgendwann
aber geändert werden. Eine Lösung wäre Funktionen mit call
aufzurufen oder eben auf LL(2) oder LR umzusteigen.
'''
if self.token.tag == Tag.IDENT:
name = self.match(Tag.IDENT)
if self.token.tag == Tag.LBRAK: # function_call
self.match(Tag.LBRAK)
args = [] if self.token.tag == Tag.RBRAK else self.expression_list()
self.match(Tag.RBRAK)
return FunctionCall(name, args)
return Variable(name)# variable
error("unknown factor begins with " + self.token.tag)
# function_call = ident "[" [ expression_list ] "]".
''' function_call muss eine expression sein sonst geht alles folgende nicht:
foo = bar[]
@foo[bar]
spam[5] + eggs[1]
andererseits ist function_call dann kein statement mehr
exit[]
wäre also falsch. Der Aufruf muss in einem assignment verkapselt werden:
dummy = exit[]
'''
def function_call(self):
name = self.match(Tag.IDENT)
self.match(Tag.LBRAK)
args = [] if self.token.tag == Tag.RBRAK else self.expression_list()
self.match(Tag.RBRAK)
return FunctionCall(name, args)
# ident_list = ident { "," ident }.
def ident_list(self):
ident = [self.match(Tag.IDENT)]
while self.token.tag == Tag.COMMA:
self.move()
ident.append(self.match(Tag.IDENT))
return ident
# expression_list = boolean { "," boolean }.
def expression_list(self):
exp = [self.boolean()]
while self.token.tag == Tag.COMMA:
self.move()
exp.append(self.boolean())
return exp
# function_list = function { function }.
def function_list(self):
funcs = [self.function()]
while self.token:
funcs.append(self.function())
return funcs
# statement_list = statement { statement }.
def statement_list(self):
stat = [self.statement()]
while self.token.tag not in [Tag.END, Tag.ELSE]:
stat.append(self.statement())
return stat
# function = "fun" ident "[" [ ident_list ] "]" nl statement_list "end" nl.
def function(self):
self.match(Tag.FUN)
name = self.match(Tag.IDENT)
self.match(Tag.LBRAK)
args = [] if self.token.tag == Tag.RBRAK else self.ident_list()
self.match(Tag.RBRAK)
self.match(Tag.NEWLINE)
block = self.statement_list()
self.match(Tag.END)
self.match(Tag.NEWLINE)
return Function(name, args, block)
# statement = [ if_statement | while_statement | assign_statement | return_statement ].
def statement(self):
return {Tag.IF: self.if_statement,
Tag.WHILE: self.while_statement,
Tag.IDENT: self.assignment,
Tag.RETURN: self.return_statement
}[self.token.tag]()
# if_statement = "if" boolean nl statement_list [ "else" [ nl ] statement_list ] "end" nl.
def if_statement(self):
self.match(Tag.IF)
condition = self.boolean()
self.match(Tag.NEWLINE)
true_case = self.statement_list()
else_case = []
if self.token.tag == Tag.ELSE:
self.move()
if self.token.tag == Tag.NEWLINE: self.move()
else_case = self.statement_list()
self.match(Tag.END)
self.match(Tag.NEWLINE)
return IfStatement(condition, true_case, else_case)
# while_statement = "while" boolean nl statement_list "end" nl.
def while_statement(self):
self.match(Tag.WHILE)
condition = self.boolean()
self.match(Tag.NEWLINE)
body = self.statement_list()
self.match(Tag.END)
self.match(Tag.NEWLINE)
return WhileStatement(condition, body)
# return_statement = "@" boolean nl.
def return_statement(self):
self.match(Tag.RETURN)
exp = self.boolean()
self.match(Tag.NEWLINE)
return ReturnStatement(exp)
# assignment = ident "=" boolean nl.
def assignment(self):
name = self.match(Tag.IDENT)
self.match(Tag.ASSIGNMENT)
exp = self.boolean()
self.match(Tag.NEWLINE)
return AssignStatement(name, exp)
# program = function_list.
def program(self):
return Program(self.function_list())
