lcfOS: python/ppci/c3/codegenerator.py comparison

comparison python/ppci/c3/codegenerator.py @ 393:6ae782a085e0

Added init program

author	Windel Bouwman
date	Sat, 17 May 2014 21:17:40 +0200
parents	2ec730e45ea1
children	988f3fb861e4

comparison

equal deleted inserted replaced

-:bb4289c84907
+:6ae782a085e0
 for s in code.statements:
 self.genCode(s)
 elif type(code) is ast.Empty:
 pass
 elif type(code) is ast.Assignment:
-lval = self.genExprCode(code.lval)
+lval = self.gen_expr_code(code.lval)
-rval = self.genExprCode(code.rval)
+rval = self.gen_expr_code(code.rval)
 if not self.equal_types(code.lval.typ, code.rval.typ):
 raise SemanticError('Cannot assign {} to {}'
 .format(code.rval.typ, code.lval.typ),
 code.loc)
 if not code.lval.lvalue:
 raise SemanticError('No valid lvalue {}'.format(code.lval),
 code.lval.loc)
 self.emit(ir.Move(lval, rval))
 elif type(code) is ast.ExpressionStatement:
-self.emit(ir.Exp(self.genExprCode(code.ex)))
+self.emit(ir.Exp(self.gen_expr_code(code.ex)))
 elif type(code) is ast.If:
 bbtrue = self.newBlock()
 bbfalse = self.newBlock()
 te = self.newBlock()
 self.gen_cond_code(code.condition, bbtrue, bbfalse)
 self.setBlock(bbfalse)
 self.genCode(code.falsestatement)
 self.emit(ir.Jump(te))
 self.setBlock(te)
 elif type(code) is ast.Return:
-re = self.genExprCode(code.expr)
+re = self.gen_expr_code(code.expr)
 self.emit(ir.Move(self.fn.return_value, re))
 self.emit(ir.Jump(self.fn.epiloog))
 b = self.newBlock()
 self.setBlock(b)
 elif type(code) is ast.While:
 self.setBlock(bbdo)
 self.genCode(code.statement)
 self.genCode(code.final)
 self.emit(ir.Jump(bbtest))
 self.setBlock(te)
+elif type(code) is ast.Switch:
+raise NotImplementedError('Unknown stmt {}'.format(code))
 else:
 raise NotImplementedError('Unknown stmt {}'.format(code))
 def gen_cond_code(self, expr, bbtrue, bbfalse):
 """ Generate conditional logic.
 self.setBlock(l2)
 self.gen_cond_code(expr.b, bbtrue, bbfalse)
 if not self.equal_types(expr.b.typ, self.boolType):
 raise SemanticError('Must be boolean', expr.b.loc)
 elif expr.op in ['==', '>', '<', '!=', '<=', '>=']:
-ta = self.genExprCode(expr.a)
+ta = self.gen_expr_code(expr.a)
-tb = self.genExprCode(expr.b)
+tb = self.gen_expr_code(expr.b)
 if not self.equal_types(expr.a.typ, expr.b.typ):
 raise SemanticError('Types unequal {} != {}'
 .format(expr.a.typ, expr.b.typ),
 expr.loc)
 self.emit(ir.CJump(ta, expr.op, tb, bbtrue, bbfalse))
 else:
 raise SemanticError('non-bool: {}'.format(expr.op), expr.loc)
 expr.typ = self.boolType
 elif type(expr) is ast.Literal:
-self.genExprCode(expr)
+self.gen_expr_code(expr)
 if expr.val:
 self.emit(ir.Jump(bbtrue))
 else:
 self.emit(ir.Jump(bbfalse))
 else:
 # Check that the condition is a boolean value:
 if not self.equal_types(expr.typ, self.boolType):
 self.error('Condition must be boolean', expr.loc)
-def genExprCode(self, expr):
+def gen_expr_code(self, expr):
 """ Generate code for an expression. Return the generated ir-value """
 assert isinstance(expr, ast.Expression)
 if type(expr) is ast.Binop:
 expr.lvalue = False
 if expr.op in ['+', '-', '*', '/', '<<', '>>', '|', '&']:
-ra = self.genExprCode(expr.a)
+ra = self.gen_expr_code(expr.a)
-rb = self.genExprCode(expr.b)
+rb = self.gen_expr_code(expr.b)
 if self.equal_types(expr.a.typ, self.intType) and \
 self.equal_types(expr.b.typ, self.intType):
+expr.typ = expr.a.typ
+elif self.equal_types(expr.b.typ, self.intType) and \
+type(expr.a.typ) is ast.PointerType:
+# Special case for pointer arithmatic TODO: coerce!
 expr.typ = expr.a.typ
 else:
 raise SemanticError('Can only add integers', expr.loc)
 else:
 raise NotImplementedError("Cannot use equality as expressions")
 return ir.Binop(ra, expr.op, rb)
 elif type(expr) is ast.Unop:
 if expr.op == '&':
-ra = self.genExprCode(expr.a)
+ra = self.gen_expr_code(expr.a)
 expr.typ = ast.PointerType(expr.a.typ)
 if not expr.a.lvalue:
 raise SemanticError('No valid lvalue', expr.a.loc)
 expr.lvalue = False
 assert type(ra) is ir.Mem
 # This returns the dereferenced variable.
 if isinstance(tg, ast.Variable):
 expr.lvalue = True
 return ir.Mem(self.varMap[tg])
 elif isinstance(tg, ast.Constant):
-c_val = self.genExprCode(tg.value)
+c_val = self.gen_expr_code(tg.value)
 return self.evalConst(c_val)
 else:
 raise NotImplementedError(str(tg))
 elif type(expr) is ast.Deref:
 # dereference pointer type:
-addr = self.genExprCode(expr.ptr)
+addr = self.gen_expr_code(expr.ptr)
 ptr_typ = self.the_type(expr.ptr.typ)
 expr.lvalue = True
 if type(ptr_typ) is ast.PointerType:
 expr.typ = ptr_typ.ptype
 return ir.Mem(addr)
 else:
 raise SemanticError('Cannot deref non-pointer', expr.loc)
 elif type(expr) is ast.Member:
-base = self.genExprCode(expr.base)
+base = self.gen_expr_code(expr.base)
 expr.lvalue = expr.base.lvalue
 basetype = self.the_type(expr.base.typ)
 if type(basetype) is ast.StructureType:
 if basetype.hasField(expr.field):
 expr.typ = basetype.fieldType(expr.field)
 bt = self.the_type(expr.base.typ)
 offset = ir.Const(bt.fieldOffset(expr.field))
 return ir.Mem(ir.Add(base.e, offset))
 elif type(expr) is ast.Index:
 """ Array indexing """
-base = self.genExprCode(expr.base)
+base = self.gen_expr_code(expr.base)
-idx = self.genExprCode(expr.i)
+idx = self.gen_expr_code(expr.i)
 base_typ = self.the_type(expr.base.typ)
 if not isinstance(base_typ, ast.ArrayType):
 raise SemanticError('Cannot index non-array type {}'
 .format(base_typ),
 expr.base.loc)
 return ir.Addr(ir.Const(cval))
 else:
 return ir.Const(expr.val)
 elif type(expr) is ast.TypeCast:
 return self.gen_type_cast(expr)
+elif type(expr) is ast.Sizeof:
+# The type of this expression is int:
+expr.typ = self.intType
+self.check_type(expr.query_typ)
+type_size = self.size_of(expr.query_typ)
+return ir.Const(type_size)
 elif type(expr) is ast.FunctionCall:
 return self.gen_function_call(expr)
 else:
 raise NotImplementedError('Unknown expr {}'.format(expr))
 data = txt.encode('ascii')
 return length + data
 def gen_type_cast(self, expr):
 """ Generate code for type casting """
-ar = self.genExprCode(expr.a)
+ar = self.gen_expr_code(expr.a)
 from_type = self.the_type(expr.a.typ)
 to_type = self.the_type(expr.to_type)
 if isinstance(from_type, ast.PointerType) and \
 isinstance(to_type, ast.PointerType):
 expr.typ = expr.to_type
 .format(from_type, to_type), expr.loc)
 def gen_function_call(self, expr):
 """ Generate code for a function call """
 # Evaluate the arguments:
-args = [self.genExprCode(e) for e in expr.args]
+args = [self.gen_expr_code(e) for e in expr.args]
 # Check arguments:
 tg = self.resolveSymbol(expr.proc)
 if type(tg) is not ast.Function:
 raise SemanticError('cannot call {}'.format(tg))
 ftyp = tg.typ

Mercurial > lcfOS

comparison python/ppci/c3/codegenerator.py @ 393:6ae782a085e0