def insertToString(self, cls, basecls, visitor):
# visitor.logger.debug('insertToString', cls, basecls)
name = 'toString'
if name not in cls.symbols:
# visitor.logger.debug('insertToString do', cls, basecls)
clsname = ast.Call(ast.Identifier('getClassName'), [])
thisptr = ast.Call(ast.Identifier('formatId'), [])
expr = None
if 'name' in cls.symbols:
# visitor.logger.debug('insertToString with name', cls, basecls, clsname, thisptr)
expr = ast.BinaryOp(
'%', ast.makeLiteral('%s(name=%s,id=%s)'),
ast.TupleLiteral(
[clsname, ast.Identifier('name'), thisptr]))
else:
# visitor.logger.debug('insertToString without name', cls, basecls, clsname, thisptr)
expr = ast.BinaryOp('%', ast.makeLiteral('%s(id=%s)'),
ast.TupleLiteral([clsname, thisptr]))
func = ast.FuncDef([], name,
ast.FuncSpec([],
ast.makePrimitiveType('string')),
ast.StatementBody([ast.Return(expr)]))
# visitor.logger.debug('insertFunc ok', name, cls, basecls, cls.primaryVars, func)
cls.definitions.append(func)
func.setOwner(cls)
visitor.visitNewItem(func)
def generateSimpleFieldCall(self, cls, basecls, basefunc, field,
invokeFuncName):
callinfo = ast.Call(
ast.AttrRef(ast.Identifier(field.name), invokeFuncName),
[ast.Identifier(param.name) for param in basefunc.spec.params])
# teststmts = [ast.CallStatement(ast.Call(ast.Identifier('println'), [ast.makeLiteral('GenerateTreeFunc check ' + basefunc.name + ' ' + field.name),
# ast.Identifier(field.name),
# ast.Call(ast.Identifier('toString'), [])]))]
teststmts = []
isStatement = basefunc.spec.returnType is None or (
isinstance(basefunc.spec.returnType, ast.UserType)
and basefunc.spec.returnType.fullpath == 'void')
if isStatement:
body = ast.StatementBody([
# ast.Call(ast.Identifier('println'), [ast.makeLiteral('GenerateTreeFunc ' + basefunc.name + ' ' + field.name),
# ast.Call(ast.AttrRef(ast.Identifier(field.name), 'toString'), []),
# ast.Call(ast.Identifier('toString'), [])]),
callinfo
])
branch = ast.IfBranch(
ast.BinaryOp('!=', ast.Identifier(field.name), ast.Nil()),
body)
return ast.StatementBody(teststmts +
[ast.IfStatement([branch], None)])
return ast.IfElseExpr(
ast.BinaryOp('!=', ast.Identifier(field.name), ast.Nil()),
callinfo, ast.Nil())
def led(self, left, token):
# Cleaner code here
if isinstance(
token,
(tokens.PLUS, tokens.MINUS, tokens.ASTERISK, tokens.SLASH)):
return ast.BinaryOp(token, left, self.expr(self.bp(token)))
if isinstance(token, (tokens.EQ, tokens.NEQ, tokens.LT, tokens.GT,
tokens.LTE, tokens.GTE)):
return ast.BinaryOp(token, left, self.expr(self.bp(token)))
else:
raise ParserError(f"No infix parse function found for {token}")
def vUnaryOp(self, node):
if node.oper == '++':
if node.right.resolveType().type == 'int':
id = 'Increment'
if node.pre:
id = 'pre' + id
else:
id = 'post' + id
if node.isNodeStatement():
id = 'p' + id
func = ast.FunctionCall(id,
ast.ActualParametersList(node.right))
func.symtab = node.symtab
if node.isNodeStatement():
func.isStatement = True
self.visit(func)
else:
binaryOp = ast.BinaryOp(node.right, '+', ast.IntLiteral(1))
binaryOp.symtab = node.symtab
assignment = ast.AssignmentStatement(node.right, '=', binaryOp)
assignment.symtab = node.symtab
self.visit(assignment)
elif node.oper == '--':
if node.right.resolveType().isInt():
id = 'Decrement'
if node.pre:
id = 'pre' + id
else:
id = 'post' + id
if node.isNodeStatement():
id = 'p' + id
func = ast.FunctionCall(id,
ast.ActualParametersList(node.right))
func.symtab = node.symtab
if node.isNodeStatement():
func.isStatement = True
self.visit(func)
else:
binaryOp = ast.BinaryOp(node.right, '-', ast.IntLiteral(1))
binaryOp.symtab = node.symtab
assignment = ast.AssignmentStatement(node.right, '=', binaryOp)
assignment.symtab = node.symtab
self.visit(assignment)
#binaryOp = ast.BinaryOp(node.right, '-', ast.IntLiteral(1))
#binaryOp.symtab = node.symtab
#assignment = ast.AssignmentStatement(node.right, '=', binaryOp)
#assignment.symtab = node.symtab
#self.visit(assignment)
else:
self.w(self.t[node.oper])
self.visit(node.right)
def resolveName_StringEvaluation(self, se):
# self.logger.debug('resolveName_StringEvaluation convert', se.literal)
text, exprs = convert_string_literal(se.literal.value)
if len(exprs) == 0:
return
# self.logger.debug('resolveName_StringEvaluation convert', text, exprs)
formatstr = ast.StringLiteral(text)
if len(exprs) == 1:
se.evaluation = ast.BinaryOp("%", formatstr, exprs[0])
else:
se.evaluation = ast.BinaryOp("%", formatstr, TupleLiteral(exprs))
se.evaluation.setOwner(se)
self.visitNewItem(se.evaluation)
se.evaluation.visit(self)
def doCondition(self, node, cond):
if not node.cond.resolveType().isBool():
newcond = ast.BinaryOp(node.cond, '!=', ast.IntLiteral('0'))
newcond.symtab = node.symtab
self.visit(newcond)
else:
self.visit(node.cond)
def p_binary_expression(self, p):
""" binary_expression : cast_expression
| binary_expression TIMES binary_expression
| binary_expression DIVIDE binary_expression
| binary_expression MOD binary_expression
| binary_expression PLUS binary_expression
| binary_expression MINUS binary_expression
| binary_expression RSHIFT binary_expression
| binary_expression LSHIFT binary_expression
| binary_expression LT binary_expression
| binary_expression LE binary_expression
| binary_expression GE binary_expression
| binary_expression GT binary_expression
| binary_expression EQ binary_expression
| binary_expression NE binary_expression
| binary_expression AND binary_expression
| binary_expression OR binary_expression
| binary_expression XOR binary_expression
| binary_expression LAND binary_expression
| binary_expression LOR binary_expression
"""
if len(p) == 2:
p[0] = p[1]
else:
p[0] = ast.BinaryOp(p[2], p[1], p[3])
def vAssignmentStatement(self, node):
if isinstance(
node.expr,
ast.Constructor) and node.expr.type.resolveType().isVector():
self.w('New')
self.w('(')
self.visit(node.lval)
cons = node.expr
while isinstance(cons, ast.Constructor):
self.w(',')
#print cons.params
self.visit(cons.params.children[0])
if len(cons.params.children) == 1:
cons = None
break
else:
cons = cons.params.children[1]
if cons != None:
print '****************Need to initialize******************'
self.w(')')
elif isinstance(node.expr, ast.AssignmentStatement):
self.visit(node.expr)
self.p(';')
tmp = node.expr
if isinstance(node.expr.lval, str):
node.expr = ast.Identifier(node.expr.lval)
else:
node.expr = node.expr.lval
node.expr.symtab = node.symtab
self.visit(node)
node.expr = tmp
else:
ident = node.lval
ident.symtab = node.symtab
oldexpr = node.expr
if node.operator != '=':
node.expr = ast.BinaryOp(
ident, self.assignmentOperators[node.operator],
ast.Parenthesis(node.expr))
node.expr.symtab = node.symtab
tpe_ident = ident.resolveType().type
tpe_expr = node.expr.resolveType().type
#if isinstance(ident.resolveType(), ast.StructType):
#print ident.resolveType().id
#print tpe_ident
#if isinstance(node.expr.resolveType().resolveType(), ast.StructType):
#print node.expr.resolveType().resolveType().id
#print tpe_expr
if tpe_ident != tpe_expr and not (
(tpe_ident == 'float' and tpe_expr == 'double') or
(tpe_ident == 'double' and tpe_expr == 'float')):
node.expr = ast.CastExpression(ast.Type(tpe_ident), node.expr)
node.expr.symtab = node.symtab
self.visit(node.lval)
self.w(':=')
self.visit(node.expr)
node.expr = oldexpr
def visitUnaryOp(self, node):
# logical operators don't exist in LLVM
if node.op == '!':
eq = ast.Operator.get('==')
false = self.makebool(False)
return self.visit(ast.BinaryOp(node.value, eq, false).at(node))
if node.op == '-':
return self.builder.neg(self.visit(node.value))
assert node.op == '~'
return self.builder.not_(self.visit(node.value))
def p_binop(p):
'''expr : expr PLUS expr
| expr MINUS expr
| expr TIMES expr
| expr DIVIDE expr
| expr MODULO expr
| expr EQ expr
| expr NE expr
| expr LT expr
| expr GT expr
| expr LE expr
| expr GE expr
| expr AND expr
| expr OR expr'''
p[0] = ast.BinaryOp(p[1], ast.Operator.get(p[2]), p[3]).at(loc(p))
def generateInitializeOwnerCall(self, cls, basecls, basefunc, field):
# print('generateInitializeOwnerCall', basefunc.name, cls, field, basefunc)
# msgstmt = ast.Call(ast.Identifier('println'), [ast.makeLiteral('generate initializeOwner start ' + field.name),
# ast.Identifier(field.name),
# ast.Call(ast.Identifier('toString'), [])])
body = ast.StatementBody([
# ast.Call(ast.Identifier('println'), [ast.makeLiteral('generate initializeOwner ' + field.name),
# ast.Identifier(field.name),
# ast.Call(ast.Identifier('toString'), [])]),
ast.Call(ast.AttrRef(ast.Identifier(field.name), 'setOwner'),
[ast.This()]),
self.generateSimpleFieldCall(cls, basecls, basefunc, field,
'initializeOwner')
])
branch = ast.IfBranch(
ast.BinaryOp('!=', ast.Identifier(field.name), ast.Nil()), body)
# return ast.StatementBody([msgstmt, ast.IfStatement([branch], None)])
return ast.IfStatement([branch], None)
def p_binary_expression(self, p):
""" binary_expression : cast_expression
| binary_expression TIMES binary_expression
| binary_expression DIVIDE binary_expression
| binary_expression MOD binary_expression
| binary_expression PLUS binary_expression
| binary_expression MINUS binary_expression
| binary_expression LT binary_expression
| binary_expression LTE binary_expression
| binary_expression GT binary_expression
| binary_expression GTE binary_expression
| binary_expression EQUALS binary_expression
| binary_expression NE binary_expression
| binary_expression AND binary_expression
| binary_expression OR binary_expression
"""
p[0] = p[1] if len(p) == 2 else ast.BinaryOp(p[2], p[1], p[3],
p[1].coord)
def p_expr(self, p):
"""
expr : cast_expression
| expr PLUS expr
| expr MINUS expr
| expr TIMES expr
| expr DIVIDE expr
| expr EQUALS expr
| expr MOD expr
| expr GT expr
| expr GET expr
| expr LT expr
| expr LET expr
| expr DIFF expr
| expr AND expr
| expr OR expr
"""
p[0] = (
(p[1]) if len(p) == 2 else ast.BinaryOp(p[2], p[1], p[3], coord=p[1].coord)
)
def vCastExpression(self, node):
tpe = node.expression.resolveType()
if tpe.isInt() and node.type.isFloatingPoint():
self.w('castint2%s(' % node.type.type)
self.visit(node.expression)
self.w(')')
elif node.type.resolveType().isInt() and tpe.isFloatingPoint():
self.w('cast%s2int(' % tpe.type)
self.visit(node.expression)
self.w(')')
elif node.type.resolveType().isString():
self.visit(node.expression)
elif node.type.resolveType().isBool() and tpe.isInt():
op = ast.BinaryOp(node.expression, '!=', ast.IntLiteral('0'))
op.symtab = node.symtab
op.right.symtab = node.symtab
self.visit(op)
else:
self.visit(node.type.resolveType())
self.w('(')
self.visit(node.expression)
self.w(')')
def get_random_arith_op():
rand_int = get_rand_int(1, 5)
return ast.BinaryOp(rand_int)
def p_lor_expression_02(t):
'''
lor_expression : lor_expression LOR land_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def p_or_expression_02(t):
'''
or_expression : or_expression OR xor_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def p_xor_expression_02(t):
'''
xor_expression : xor_expression XOR and_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def p_and_expression_02(t):
'''
and_expression : and_expression AND equality_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def p_equality_expression_02(t):
'''
equality_expression : equality_expression equality_operator relational_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def p_relational_expression_02(t):
'''
relational_expression : relational_expression relational_operator additive_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def p_additive_expression_02(t):
'''
additive_expression : additive_expression additive_operator multiplicative_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def p_multiplicative_expression_02(t):
'''
multiplicative_expression : multiplicative_expression multiplicative_operator unary_expression
'''
t[0] = ast.BinaryOp(t[1], t[2], t[3])
def expression_binop(s):
return ast.BinaryOp(s[1].getstr(), s[0], s[2])
