lcfOS: python/ppci/frontends/ks/parser.py comparison

comparison python/ppci/frontends/ks/parser.py @ 110:9e552d34bd60

Work on compiler

author	Windel Bouwman
date	Fri, 04 Jan 2013 15:25:58 +0100
parents	f2d980eef509
children

comparison

equal deleted inserted replaced

-:8267ba1dbce3
+:9e552d34bd60
 self.Consume(';')
 def parseImport(self):
 loc = self.getLocation()
 modname = self.Consume('ID')
+# TODO: fix
 #mod = loadModule(modname)
 self.setLocation(mod, loc)
 self.cst.addSymbol(mod)
 # Helper to parse an identifier defenitions
 else:
 self.Error('Unimplemented unary operation {0}'.format(expr.op))
 else:
 self.Error('Cannot evaluate expression {0}'.format(expr))
-def parseConstExpression(self):
+def parseConstant(self):
 e = self.parseExpression()
-return self.evalExpression(e), e.typ
+val = self.evalExpression(e)
+return Constant(val, e.typ)
 def parseConstantDeclarations(self):
 """ Parse const part of a module """
 if self.hasConsumed('const'):
 while self.token.typ == 'ID':
 i = self.parseIdentDef()
 self.Consume('=')
-constvalue, typ = self.parseConstExpression()
+c = self.parseConstant()
 self.Consume(';')
-c = Constant(constvalue, typ, name=i.name, public=i.ispublic)
+c.name = i.name
+c.public = i.ispublic
 self.setLocation(c, i.location)
 self.cst.addSymbol(c)
 # Type system
 def parseTypeDeclarations(self):
 return self.parseStructuredType()
 def parseStructuredType(self):
 if self.hasConsumed('array'):
 dimensions = []
-dimensions.append( self.parseConstExpression() )
+dimensions.append( self.parseConstant() )
 while self.hasConsumed(','):
-dimensions.append( self.parseConstExpression() )
+dimensions.append( self.parseConstant() )
 self.Consume('of')
 arr = self.parseType()
-for dimension, consttyp in reversed(dimensions):
+for dimension in reversed(dimensions):
-if not isType(consttyp, integer):
+if not isType(dimension.typ, integer):
 self.Error('array dimension must be an integer type (not {0})'.format(consttyp))
-if dimension < 2:
+if dimension.value < 2:
-self.Error('array dimension must be bigger than 1 (not {0})'.format(dimension))
+self.Error('array dimension must be bigger than 1 (not {0})'.format(dimension.value))
-arr = ArrayType(dimension, arr)
+arr = ArrayType(dimension.value, arr)
 return arr
 elif self.hasConsumed('record'):
 fields = {}
 while self.token.typ == 'ID':
 # parse a fieldlist:
 if self.token.typ != ')':
 args = self.parseExpressionList()
 else:
 args = []
 self.Consume(')')
+# Type checking:
 parameters = procedure.typ.parameters
 if len(args) != len(parameters):
 self.Error("Procedure requires {0} arguments, {1} given".format(len(parameters), len(args)))
 for arg, param in zip(args, parameters):
 if not arg.typ.isType(param.typ):
 def parseRepeatStatement(self):
 self.Consume('repeat')
 stmt = self.parseStatementSequence()
 self.Consume('until')
 cond = self.parseBoolExpression()
+# TODO
 def parseForStatement(self):
 loc = self.getLocation()
 self.Consume('for')
 variable = self.parseDesignator()
 self.Consume('to')
 end = self.parseExpression()
 if not end.typ.isType(integer):
 self.Error('end expression of a for statement must have integer type')
 if self.hasConsumed('by'):
-increment, typ = self.parseConstExpression()
+increment = self.parseConstant()
-if not typ.isType(integer):
+if not increment.typ.isType(integer):
 self.Error('Increment must be integer')
+increment = increment.value
 else:
 increment = 1
 assert(type(increment) is int)
 self.Consume('do')
 statements = self.parseStatementSequence()
 self.Consume('end')
 return self.setLocation(ForStatement(variable, begin, end, increment, statements), loc)
 def parseAsmcode(self):
 # TODO: move this to seperate file
+# TODO: determine what to do with inline asm?
 def parseOpcode():
 return self.Consume('ID')
 def parseOperand():
 if self.hasConsumed('['):
 memref = []
 self.Consume(self.token.typ)
 return EmptyStatement()
 def parseStatementSequence(self):
 """ Sequence of statements seperated by ';' """
-statements = [ self.parseStatement() ]
+statements = [self.parseStatement()]
 while self.hasConsumed(';'):
-statements.append( self.parseStatement() )
+statements.append(self.parseStatement())
-return StatementSequence( statements )
+return StatementSequence(statements)
 # Parsing expressions:
 """
 grammar of expressions:
 expression       = SimpleExpression [ reloperator SimpleExpression ]
 term             = factor { muloperator factor }
 muloperator      = '*' | '/' | 'div' | 'mod' | 'and'
 factor           = number | nil | true | false | "(" expression ")" |
 designator [ actualparameters ] | 'not' factor
 """
+def getTokenPrecedence(self):
+binopPrecs = {}
+binopPrecs['and'] = 8
+binopPrecs['or'] = 6
+binopPrecs['<'] = 10
+binopPrecs['>'] = 10
+binopPrecs['='] = 10
+binopPrecs['<='] = 10
+binopPrecs['>='] = 10
+binopPrecs['<>'] = 10
+binopPrecs['+'] = 20
+binopPrecs['-'] = 20
+binopPrecs['*'] = 40
+binopPrecs['/'] = 40
+binopPrecs['div'] = 40
+binopPrecs['mod'] = 40
+typ = self.token.typ
+if typ in binopPrecs:
+return binopPrecs[typ]
+return 0
+def parsePrimary(self):
+pass
 def parseExpression(self):
 """ The connector between the boolean and expression domain """
+# TODO: implement precedence bindin
+#lhs = self.parsePrimary()
+#return self.parseBinopRhs(lhs)
 expr = self.parseSimpleExpression()
 if self.token.typ in ['>=','<=','<','>','<>','=']:
 relop = self.Consume()
 expr2 = self.parseSimpleExpression()
 # Automatic type convert to reals:
 # Type check:
 if not isType(expr.typ, expr2.typ):
 self.Error('Type mismatch in relop')
 if isType(expr.typ, real) and relop in ['<>', '=']:
 self.Error('Cannot check real values for equality')
 expr = Relop(expr, relop, expr2, boolean)
 return expr
 # Parsing arithmatic expressions:
 def parseTerm(self):
 val = self.Consume('CHAR')
 return Constant(val, char)
 elif self.token.typ == 'STRING':
 txt = self.Consume('STRING')
 return StringConstant(txt)
-elif self.token.typ in ['true', 'false']:
+elif self.hasConsumed('true'):
-val = self.Consume()
+return Constant(True, boolean)
-val = True if val == 'true' else False
+elif self.hasConsumed('false'):
-return Constant(val, boolean)
+return Constant(False, boolean)
 elif self.hasConsumed('nil'):
 return Constant(0, NilType())
 elif self.hasConsumed('not'):
 f = self.parseFactor()
 if not isType(f.typ, boolean):

Mercurial > lcfOS

comparison python/ppci/frontends/ks/parser.py @ 110:9e552d34bd60