def __init__(self, fd=None, sBuilder=None, indent=" ", vManager=None):
logger.debug(
"Create compiler with args: fd:{}, indent:<{}>, vManager:{}".format(
"Yes" if fd else "No", indent, "Yes" if vManager else " No"
)
)
self.fd = fd
self.outputBuffer = ""
self.sBuilder = sBuilder
self.indentPattern = indent
self.level = 0
if vManager:
self.vManager = vManager # function symbol manager
else:
self.vManager = VariableManager() # variable symbol manager
self.managers = []
self.managers.append(self.vManager)
self.mainFunction = None
self.loopStack = []
self.deferExpression = []
self.inCondition = False
self.iAdaptor = IAdaptor.IncludeAdaptor()
self.vManager.setIAdaptor(self.iAdaptor)
# used by instance, function ...
self.usedName = set()
self.totalUsed = set()
self.fieldUsedName = set()
# self extend graph
self.deferManager = DeferClassManager.DeferClassManager(self.vManager)
def __init__(self, **kwargs):
Thread.__init__(self)
# Serial thread
self.serialthread = SerialPort()
# Controller Read/Write variables over serial
self.controller = DistantIO()
# Serial protocol
self.protocol = Protocol()
# Variable manager
self.variable_manager = VariableManager(self)
self.variable_manager.start()
self.running = True;
# Data logger
self.logger = DataLogger()
class Model(Thread):
def __init__(self, **kwargs):
Thread.__init__(self)
# Serial thread
self.serialthread = SerialPort()
# Controller Read/Write variables over serial
self.controller = DistantIO()
# Serial protocol
self.protocol = Protocol()
# Variable manager
self.variable_manager = VariableManager(self)
self.variable_manager.start()
self.running = True;
# Data logger
self.logger = DataLogger()
def get_ports(self):
return self.serialthread.get_ports()
def connect_com(self,COM_port):
# Start serial thread (can run without COM port connected)
if not self.serialthread.isAlive():
self.serialthread.start()
self.serialthread.connect(COM_port,115200)
#Model update running in a thread
def run(self):
while self.running:
if self.serialthread.char_available():
c = self.serialthread.get_char()
if not c is None:
self.protocol.process_rx(c)
if self.protocol.available():
p = self.protocol.get()
# Dump payload if controller is in heavy load ?
pub.sendMessage('new_rx_payload',rxpayload=p)#USED ?
if not p is None:
self.controller.decode(p)
def disconnect_com(self):
self.serialthread.disconnect()
def stop(self):
self.running = False
self.serialthread.stop()
self.variable_manager.stop()
if self.serialthread.isAlive():
self.serialthread.join(0.1)
if self.serialthread.isAlive():
self.serialthread.join(1)
if self.serialthread.isAlive():
print("--- Serial thread not properly joined.")
if self.variable_manager.isAlive():
self.variable_manager.join(0.1)
if self.variable_manager.isAlive():
self.variable_manager.join(1)
self.stop_controller()
def start_controller(self):
#Get command for querying variable table MCU side
cmd = self.controller.encode(cmd='table')
#Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
#Send command
self.serialthread.write(frame)
def stop_controller(self):
#TODO : Tell MCU to stop sending all data
pass
def start_log(self):
self.logger.start()
def stop_log(self):
self.logger.record_all()
def read_var(self, varid):
# Get command
cmd = self.controller.encode(cmd='read',var_id=varid)
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def write_var(self,varid,value):
# Get command
cmd = self.controller.encode(cmd='write',var_id=varid,value=value)
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def stop_read_var(self,varid):
# Get command
cmd = self.controller.encode(cmd='stop',var_id=varid)
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def stop_read_all_vars():
# Get command
cmd = self.controller.encode(cmd='stopall')
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def get_var_info(self,varid):
return self.controller.get_var_info(varid)
class Compiler(object):
"""Java to Python compiler"""
def __init__(self, fd=None, sBuilder=None, indent=" ", vManager=None):
logger.debug(
"Create compiler with args: fd:{}, indent:<{}>, vManager:{}".format(
"Yes" if fd else "No", indent, "Yes" if vManager else " No"
)
)
self.fd = fd
self.outputBuffer = ""
self.sBuilder = sBuilder
self.indentPattern = indent
self.level = 0
if vManager:
self.vManager = vManager # function symbol manager
else:
self.vManager = VariableManager() # variable symbol manager
self.managers = []
self.managers.append(self.vManager)
self.mainFunction = None
self.loopStack = []
self.deferExpression = []
self.inCondition = False
self.iAdaptor = IAdaptor.IncludeAdaptor()
self.vManager.setIAdaptor(self.iAdaptor)
# used by instance, function ...
self.usedName = set()
self.totalUsed = set()
self.fieldUsedName = set()
# self extend graph
self.deferManager = DeferClassManager.DeferClassManager(self.vManager)
# Compiler Utilitie
def c(self, fmt):
if self.fd is not None:
self.fd.write("{}# {}\n".format(self.indentPattern * (self.level), fmt))
def p(self, fmt, offset=0):
indents = self.indentPattern * (self.level + offset)
result = ""
if len(self.usedName) > 0:
more = self.iAdaptor.getMore(self.usedName) - self.iAdaptor.getInherits()
if len(more) > 0:
for imp in more:
result += "{}from {} import *\n".format(indents, imp)
result += indents + fmt
while self.deferExpression:
indents = self.indentPattern * (self.level)
result += indents + self.deferExpression.pop()
if self.fd is not None:
self.fd.write(result)
else:
self.outputBuffer += result
self.totalUsed = self.totalUsed.union(self.usedName)
self.usedName = set()
def indent(self, body, **kargs):
self.level += 1
for manager in self.managers:
manager.newScope(body, **kargs)
def unindent(self, body, **kargs):
self.level -= 1
for manager in self.managers:
manager.leaveScope(body, **kargs)
def preprocess(self, body):
SchemeBuilder.buildHelper(body, self.vManager)
def compile(self, body):
""" entry function """
self.preprocess(body)
self.solver(body)
while not self.deferManager.isEmpty():
for cls in self.deferManager.sort():
self.vManager.setSnapshot(cls.snapshot)
if cls.mtype == DeferClassManager.CLASS:
self.solver(cls.obj, absExtends=True)
self.p("{} = {}\n".format(self.vManager.findClass(cls.name), cls.name))
elif cls.mtype == DeferClassManager.ANONYMOUS:
oClass, variable, initializer = cls.obj
self.solver(oClass)
self.p("{} = {}\n".format(variable, initializer))
if self.mainFunction:
self.p("if __name__ == '__main__':\n")
self.p(" import sys\n")
self.p(" {}(sys.argv)\n".format(self.mainFunction))
return self.outputBuffer
def compilePackage(self, root, filePath):
parser = plyj.Parser().parse_file(filePath)
includer = Includer.Includer(root, filePath)
self.iAdaptor.setIncluder(includer)
result = self.compile(parser)
dependsPkgs = self.iAdaptor.getInherits()
dependsPkgs = dependsPkgs.union(self.iAdaptor.getMore(self.fieldUsedName))
self.imports = includer.getMore(self.totalUsed).union(dependsPkgs)
builtinImports = ["from lib.Switch import Switch\n", "from lib.BasicObject import BasicObject\n"]
prefix = "".join(builtinImports) + "".join(["from {} import *\n".format(pkg) for pkg in dependsPkgs])
# prefix = "".join(builtinImports) + "".join(["from {} import *\n".format(pkg) for pkg in self.imports])
return prefix + result
def CompilationUnit(self, body):
package_declaration = self.solver(body.package_declaration)
for importer in body.import_declarations:
self.solver(importer)
for typer in body.type_declarations:
self.solver(typer)
def PackageDeclaration(self, body):
name = self.solver(body.name)
self.iAdaptor.setPackage(name)
self.c("package {}\n".format(name))
def ImportDeclaration(self, body):
name = self.solver(body.name)
self.iAdaptor.addImport(name, body.static)
self.c("import {}\n".format(name))
@scoped
def InterfaceDeclaration(self, body, absExtends=False):
name, implements, decorators = getInterfaceScheme_helper(body, self.solver, self.vManager)
tmp = set()
for impl in implements:
logger.debug("InterfaceDeclaration: addInherit{}".format(impl))
try:
self.vManager.addInherit(impl)
except Includer.NonIncludeClass as e:
tmp.add(impl)
logger.warn(e)
map(implements.remove, tmp)
if absExtends:
for i in range(len(implements)):
if self.vManager.findClass(implements[i]):
implements[i] = self.vManager.getFullPathByName(implements[i])
if len(implements) == 0:
implements.append(INITIAL_CLASS)
self.c("# interface")
self.p("class {name}({parent}):\n".format(name=name, parent=", ".join(implements)), offset=-1)
if not body.body or len(body.body) == 0:
self.p("pass\n")
return
# Field => Functions => Classes
# -----------------------------
# field process
tmp = set()
# body preprocess
function_methods = set()
overloading = []
for comp in body.body:
if type(comp) == plyj.FieldDeclaration:
self.solver(comp)
elif type(comp) == plyj.MethodDeclaration or type(comp) == plyj.ConstructorDeclaration:
functionName = self.solver(comp.name)
overloading.append(functionName) if functionName in function_methods else function_methods.add(
functionName
)
elif type(comp) == plyj.ClassDeclaration:
subName, subImplements, subDecorators = getClassScheme_helper(comp, self.solver, self.vManager)
depends = deferImplement_helper(self.vManager, subImplements)
self.deferManager.addClass(subName, depends, comp)
elif type(comp) == plyj.InterfaceDeclaration:
subName, subImplements, subDecorators = getInterfaceScheme_helper(comp, self.solver, self.vManager)
depends = deferImplement_helper(self.vManager, subImplements)
if len(depends) > 0:
self.deferManager.addClass(subName, depends, comp)
else:
self.solver(comp)
else:
self.solver(comp)
for comp in body.body:
if type(comp) == plyj.MethodDeclaration or type(comp) == plyj.ConstructorDeclaration:
functionName = self.solver(comp.name)
if functionName in overloading:
self.solver(comp, appendName=True)
else:
self.solver(comp)
@scoped
def ClassDeclaration(self, body, absExtends=False):
name, implements, decorators = getClassScheme_helper(body, self.solver, self.vManager)
tmp = set()
for impl in implements:
logger.debug("ClassDeclaration: addInherit{}".format(impl))
try:
self.vManager.addInherit(impl)
except Includer.NonIncludeClass as e:
tmp.add(impl)
logger.warn(e)
map(implements.remove, tmp)
if absExtends:
for i in range(len(implements)):
if self.vManager.findClass(implements[i]):
implements[i] = self.vManager.getFullPathByName(implements[i])
if len(implements) == 0:
implements.append(INITIAL_CLASS)
self.p("class {name}({parent}):\n".format(name=name, parent=", ".join(implements)), offset=-1)
if len(body.body) == 0:
self.p("pass\n")
return
elif type(body.body[0]) == plyj.ClassInitializer:
self.p("pass\n")
return
# Field => Functions => Classes
# -----------------------------
# field process
tmp = set()
# body preprocess
function_methods = set()
overloading = []
# first step scanning
for comp in body.body:
if type(comp) == plyj.FieldDeclaration:
self.solver(comp)
elif type(comp) == plyj.MethodDeclaration or type(comp) == plyj.ConstructorDeclaration:
self.vManager.newScope(comp)
self.vManager.leaveScope(comp)
functionName = self.solver(comp.name)
overloading.append(functionName) if functionName in function_methods else function_methods.add(
functionName
)
elif type(comp) == plyj.ClassDeclaration:
subName, subImplements, subDecorators = getClassScheme_helper(comp, self.solver, self.vManager)
depends = deferImplement_helper(self.vManager, subImplements)
self.deferManager.addClass(subName, depends, comp)
elif type(comp) == plyj.InterfaceDeclaration:
subName, subImplements, subDecorators = getInterfaceScheme_helper(comp, self.solver, self.vManager)
depends = deferImplement_helper(self.vManager, subImplements)
if len(depends) > 0:
self.deferManager.addClass(subName, depends, comp)
else:
self.solver(comp)
else:
self.solver(comp)
# TODO: remove outsided classes
# append function overload entry
if len(overloading) > 0:
temp = set(overloading)
if name in temp:
temp.remove(name)
temp.add("__init__")
self.overloadEntry(temp)
for comp in body.body:
if type(comp) == plyj.MethodDeclaration or type(comp) == plyj.ConstructorDeclaration:
functionName = self.solver(comp.name)
if functionName in overloading:
self.solver(comp, appendName=True)
else:
self.solver(comp)
def ClassInitializer(self, body):
return
curframe = inspect.currentframe()
calframe = inspect.getouterframes(curframe, 2)
for i in range(2, 8):
logger.info(calframe[i][3])
self.solver(body.block)
def EmptyDeclaration(self, body):
return
def FieldDeclaration(self, body):
mtype = self.solver(body.type)
variable_declarators = []
for var in body.variable_declarators:
if var.initializer and type(var.initializer) == plyj.InstanceCreation and len(var.initializer.body) > 0:
mtype = self.solver(var.initializer.type)
variable = self.solver(var.variable)
anonymous = AnonymousName_helper()
oClass = plyj.ClassDeclaration(anonymous, var.initializer.body, extends=mtype)
initializer = plyj.InstanceCreation(
anonymous,
type_arguments=var.initializer.type_arguments,
arguments=var.initializer.arguments,
enclosed_in=var.initializer.enclosed_in,
)
self.deferManager.addAnonyClass(
anonymous, [mtype], (oClass, self.vManager.getPath() + "." + variable, self.solver(initializer))
)
return
variable, initializer = self.solver(var)
self.vManager.newVariable(variable, mtype, isMember=True)
if initializer is None:
self.c(mtype)
result = "{} = {}\n".format(variable, JavaLib.builtinTypes(mtype))
elif initializer.startswith(ANONYMOUS_PREFIX) or type(var.initializer) in [plyj.Literal, plyj.Unary]:
if type(var.initializer) == plyj.Name:
for part in initializer.split("."):
self.fieldUsedName.add(part)
if initializer in self.vManager.members:
initializer = self.vManager.members[initializer]
result = "{} = {}\n".format(variable, initializer)
else:
result = "{} = None\n".format(variable)
self.p(result)
def FieldAccess(self, body):
return "{}.{}".format(SELF_INSTANCE, self.solver(body.name))
def ConstructorDeclaration(self, body, appendName=False):
body.name = "__init__"
if appendName:
funcName = self._getOverrideName("__init__", body.parameters)
body.name = funcName
setattr(body, "body", body.block)
self._classMethodDeclaration(body)
def ConstructorInvocation(self, body):
arguments = []
for arg in body.arguments:
sArg = self.solver(arg)
arguments.append(sArg)
clsName = self.vManager.getPath().split(".")[-2]
self.p("{}({})\n".format(clsName, ", ".join(arguments)))
def MethodDeclaration(self, body, appendName=False):
name = self.solver(body.name)
if appendName:
funcName = self._getOverrideName(name, body.parameters)
body.name = funcName
self._classMethodDeclaration(body)
@scoped
def EnumDeclaration(self, body):
name = self.solver(body.name)
self.p("class {}:\n".format(name), offset=-1)
for stmt in body.body:
if type(stmt) == plyj.EnumConstant:
self.solver(stmt)
def EnumConstant(self, body):
name = self.solver(body.name)
self.p('{name} = "{name}"\n'.format(name=name))
def _getOverrideName(self, funcName, parameters):
args_type = []
for arg in parameters:
name, mtype = self.solver(arg)
args_type.append(mtype.split(".")[-1]) # get the last type name of parameters
return self._overrideName(funcName, args_type)
def _overrideName(self, funcName, args_type):
return "Oed_{}__{}".format(funcName, "__".join(args_type))
@scoped
def _classMethodDeclaration(self, body):
functionName = self.solver(body.name)
if functionName == "main":
self.mainFunction = self.vManager.getPath()
"""
elif functionName == "toString":
functionName = "__str__"
"""
args = [SELF_INSTANCE]
for arg in body.parameters:
name, mtype = self.solver(arg)
args.append(name)
self.p("@classmethod\n", offset=-1)
self.p("def {}({}):\n".format(functionName, ", ".join(args)), offset=-1)
if not body.body or len(body.body) == 0:
self.p("pass\n")
return
for stmt in body.body:
result = self.solver(stmt)
if result:
self.p(result + "\n")
def AnnotationDeclaration(self, body):
return
def Throw(self, body):
"""
Throw(exception=InstanceCreation(type=Type(name=Name(value='IllegalArgumentException'), type_arguments=[], enclosed_in=None, dimensions=0), type_arguments=[], arguments=[Additive(operator='+', lhs=Additive(operator='+', lhs=Literal(value='"Invalid character "'), rhs=Name(value='nibble')), rhs=Literal(value='" in hex string"'))], body=[], enclosed_in=None))
"""
if hasattr(body.exception, "arugments"):
result = ""
for args in body.exception.arguments:
result += self.solver(args)
else:
result = self.solver(body.exception)
result = result.replace('"', "'")
self.p('raise Exception("{}")\n'.format(result))
def Throws(self, body):
throws = []
for mtype in body.types:
throws.append(self.solver(mtype))
return throws
# @scoped
def Synchronized(self, body):
# self.p("synchronized({})\n".format(body.monitor), offset=-1)
self.solver(body.body)
@scoped
def IfThenElse(self, body):
predicate = self.solver(body.predicate, inCondition=True)
self.p("if {}:\n".format(predicate), offset=-1)
if body.if_true == None:
self.p("pass\n")
else:
result = self.solver(body.if_true)
self.p("{}\n".format(result)) if result else None
if body.if_false != None:
self.p("else:\n", offset=-1)
result = self.solver(body.if_false)
self.p("{}\n".format(result)) if result else None
@scoped
def Switch(self, body):
value = self.solver(body.expression)
cases = body.switch_cases
self.p("for mycase in Switch({}):\n".format(value), offset=-1)
for case in cases:
self.solver(case)
@scoped
def SwitchCase(self, body):
cases = []
for case in body.cases:
case = self.solver(case)
case = self.vManager.decorate(case, SELF_INSTANCE)
cases.append(case)
if cases[0] == "default":
self.p("if mycase():\n", offset=-1)
else:
self.p("if {}:\n".format(" or ".join("mycase(" + i + ")" for i in cases)), offset=-1)
if len(body.body) == 0:
self.p("pass\n")
for comp in body.body:
result = self.solver(comp)
if result:
self.p(result + "\n")
def Block(self, body):
stmts = body.statements
if len(stmts) == 0:
self.p("pass\n")
for stmt in stmts:
stmt = self.solver(stmt)
if stmt:
self.p(stmt + "\n")
def Try(self, body):
self.solver(body.block)
@scoped
@loop
def While(self, body):
self.p(
"while {}:\n".format(self.solver(body.predicate, inCondition=True) if body.predicate else "True"), offset=-1
)
if body.body:
result = self.solver(body.body)
if type(result) == str:
self.p(result + "\n")
else:
self.p("pass\n")
@scoped
@loop
def DoWhile(self, body):
self.p("while True:\n", offset=-1)
result = self.solver(body.body)
if result:
self.p(result + "\n")
self.p("if not ({}):\n".format(self.solver(body.predicate, inCondition=True)))
self.p("break\n", offset=1)
@scoped
@loop
def For(self, body):
if body.init:
if type(body.init) == list:
for init in body.init:
self.p(self.solver(init) + "\n", offset=-1)
else:
self.p(self.solver(body.init) + "\n", offset=-1)
self.p(
"while {}:\n".format(self.solver(body.predicate, inCondition=True) if body.predicate else "True"), offset=-1
)
self.solver(body.body)
if not body.update:
return
for update in body.update:
self.p(self.solver(update) + "\n")
@scoped
@loop
def ForEach(self, body):
self.p("for {} in {}:\n".format(self.solver(body.variable), self.solver(body.iterable)), offset=-1)
if body.body:
result = self.solver(body.body)
if type(result) == str:
self.p(result + "\n")
def Break(self, body):
return "break"
def Continue(self, body):
if self.loopUpdate:
for update in self.loopUpdate:
self.p(self.solver(update) + "\n")
return "continue"
def Statements(self, body):
raise Undefined
def Statement(self, body):
raise Undefined
def Assert(self, body):
return
def Assignment(self, body):
# Assignment(operator='=', lhs=Name(value='_arg1'), rhs=MethodInvocation(name='readInt', arguments=[], type_arguments=[], target=Name(value='data')))
curframe = inspect.currentframe()
calframe = inspect.getouterframes(curframe, 2)
caller = calframe[2][3]
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
if operator == ">>>=":
operator = "="
rhs = "{} >> {}".format(lhs, rhs)
if self.inCondition:
self.p("{lhs} {op} {rhs}\n".format(lhs=lhs, op=operator, rhs=rhs), offset=-1)
return lhs
elif caller in ["Assignment", "Equality", "Relational", "Return", "Unary", "Conditional"]:
offset = 0
self.p("{lhs} {op} {rhs}\n".format(lhs=lhs, op=operator, rhs=rhs), offset=offset)
return lhs
return "{lhs} {op} {rhs}".format(lhs=lhs, op=operator, rhs=rhs)
def Return(self, body):
return "return {}".format(self.solver(body.result))
def Annotation(self, body):
return self.solver(body.name)
def Type(self, body):
tArgs = []
for arg in body.type_arguments:
tArgs.append(self.solver(arg))
type_arguments = ""
if body.enclosed_in:
enclosed = self.solver(body.enclosed_in) + "."
else:
enclosed = ""
dimensions = body.dimensions
name = self.solver(body.name)
if name in JavaLib.builtinMap:
name = JavaLib.builtinMap[name]
return "{}{}{}".format(enclosed, name, type_arguments)
def Conditional(self, body):
predicate = self.solver(body.predicate, inCondition=True)
if_true = self.solver(body.if_true)
if_false = self.solver(body.if_false)
return "( {if_true} if {predicate} else {if_false} )".format(
if_true=if_true, predicate=predicate, if_false=if_false
)
def ClassLiteral(self, body):
return "{}.__class__".format(self.solver(body.type))
@itemFilter
def Name(self, body):
curframe = inspect.currentframe()
calframe = inspect.getouterframes(curframe, 2)
caller = calframe[3][3]
value = body.value
if caller not in ["ImportDeclaration", "PackageDeclaration", "Type"]:
for component in value.split("."):
self.usedName.add(component)
if caller == "Type":
return value
value = self.vManager.decorate(value, SELF_INSTANCE)
return value
@itemFilter
def Literal(self, body):
value = body.value
if re.match(r"[\d\.]+[fF]$", value):
value = str(float(value[:-1]))
return value
@itemFilter
def Variable(self, body):
return self.solver(body.name)
def FormalParameter(self, body):
"""
variable=<class 'plyj.model.Variable'>
type=<class 'plyj.model.Type'>
modifiers=<type 'list'>
vararg=<type 'bool'>
"""
variable = self.solver(body.variable)
mtype = self.solver(body.type)
self.vManager.newVariable(variable, mtype)
if hasattr(body.type, "dimensions") and body.type.dimensions > 0:
mtype = "list"
return variable, mtype
def InstanceCreation(self, body, isAnonymous=False):
collector = set()
mtype = self.solver(body.type)
map(self.usedName.add, mtype.split("."))
# built-in types
if mtype == "Object":
mtype = INITIAL_CLASS
args = []
for arg in body.arguments:
arg = self.solver(arg)
args.append(self.solver(arg))
if len(body.body) > 0: # anonymous function
anonymous = AnonymousName_helper()
oClass = plyj.ClassDeclaration(anonymous, body.body, extends=body.type)
initializer = plyj.InstanceCreation(
anonymous, type_arguments=body.type_arguments, arguments=body.arguments, enclosed_in=body.enclosed_in
)
raise ClassOverriding(oClass, initializer)
else:
return "{}({})".format(mtype, ", ".join(args))
@scoped
def OverloadingInstance(self, variableDeclarator):
variable = self.solver(variableDeclarator.variable)
args = []
instanceCreation = variableDeclarator.initializer
for arg in instanceCreation.arguments:
args.append(self.solver(arg))
self.p("class {}({}):\n".format(variable, ", ".join(args)), offset=-1)
for stmt in instanceCreation.body:
self.solver(stmt)
def VariableDeclaration(self, body):
"""
TYPE := VARIABLE_DECLARATORS
"""
mtype = self.solver(body.type)
variables = []
initializers = []
for variable in body.variable_declarators:
variable, initializer = self.solver(variable)
if variable:
self.vManager.newVariable(variable, mtype)
if initializer:
variables.append(variable)
initializers.append(initializer)
else:
variables.append(variable)
initializers.append(JavaLib.builtinTypes(mtype))
return "{} = {}".format(", ".join(variables), ", ".join(initializers))
def VariableDeclarator(self, body):
variable = self.solver(body.variable)
initializer = self.solver(body.initializer)
return variable, initializer
@JavaLib.method
def MethodInvocation(self, body):
name = self.solver(body.name)
arguments = body.arguments
args = []
for arg in arguments:
_result = self.solver(arg)
args.append(_result)
type_arguments = body.type_arguments
if body.target is None:
name = self.vManager.decorate(name, SELF_INSTANCE)
return "{name}({args})".format(name=name, args=", ".join(args))
targets = self.solver(body.target).split(".")
# IIntentReceiver.Stub.asInterface
if name == "asInterface" and targets[0][0] == "I" and targets[1] == "Stub":
# return strongBinder
return '{}.asInterface("{}")'.format(args[0], ".".join(targets[:2]))
if targets[0] == "this":
targets[0] = SELF_INSTANCE
elif targets[0] == "super":
clsName = self.vManager.getPath().split(".")[-2]
targets[0] = "super({}, {})".format(clsName, SELF_INSTANCE)
else:
targets[0] = self.vManager.decorate(targets[0], SELF_INSTANCE)
return "{}.{}({})".format(".".join(keywordReplace_helper(i) for i in targets), name, ", ".join(args))
def ExpressionStatement(self, body):
raise Undefined("plyj 0.2")
return
def Wildcard(self, body):
return
def InstanceOf(self, body):
return "isinstance({}, {})".format(self.solver(body.lhs), self.solver(body.rhs))
def ConditionalOr(self, body):
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} or {})".format(lhs, rhs)
def ConditionalAnd(self, body):
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} and {})".format(lhs, rhs)
def And(self, body):
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Or(self, body):
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Xor(self, body):
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Multiplicative(self, body):
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Equality(self, body):
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Relational(self, body):
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Additive(self, body):
operator = self.solver(body.operator)
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
if type(body.lhs) == plyj.Literal and lhs.find("E") > 0:
return "{}{}{}".format(lhs, operator, rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Unary(self, body):
"""
sign=<type 'str'>
expression=<class 'plyj.model.Literal'>
"""
curframe = inspect.currentframe()
calframe = inspect.getouterframes(curframe, 2)
caller = calframe[2][3]
sign = body.sign
expression = self.solver(body.expression)
if caller not in ["Block", "IfThenElse", "While", "For", "DoWhile", "SwitchCase", "_classMethodDeclaration"]:
if self.inCondition:
offset = -1
else:
offset = 0
if sign == "x++":
self.deferExpression.append("{} += 1\n".format(expression))
elif sign == "x--":
self.deferExpression.append("{} -= 1\n".format(expression))
elif sign == "++x":
self.p("{} += 1\n".format(expression), offset=offset)
elif sign == "--x":
self.p("{} -= 1\n".format(expression), offset=offset)
return expression
if sign == "x++":
return "{} += 1".format(expression)
elif sign == "x--":
return "{} -= 1".format(expression)
elif sign == "!":
return "not {}".format(expression)
return "{}{}".format(sign, expression)
def Shift(self, body):
operator = self.solver(body.operator)
if operator == ">>>":
operator = ">>"
lhs = self.solver(body.lhs)
rhs = self.solver(body.rhs)
return "({} {} {})".format(lhs, operator, rhs)
def Cast(self, body):
return self.solver(body.expression)
def Empty(self, body):
return "pass"
def ArrayInitializer(self, body):
return "[{}]".format(", ".join(self.solver(i) for i in body.elements))
def ArrayCreation(self, body):
# ArrayCreation(type='int', dimensions=[Name(value='_arg4_length')], initializer=None)
mtype = self.solver(body.type)
dims = []
for dim in body.dimensions:
dims.append(self.solver(dim))
dimensions = "".join("[{}()]*{}".format(mtype, i) for i in dims)
initializer = body.initializer
self.c(mtype)
return "{dimensions}".format(dimensions=dimensions)
def ArrayAccess(self, body):
index = self.solver(body.index)
target = self.solver(body.target)
return "{}[{}]".format(target, index)
def solver(self, thing, **kargs):
if thing == None:
return thing
if type(thing) == str:
if thing in JavaLib.builtinMap:
thing = JavaLib.builtinMap[thing]
if thing == "this":
thing = SELF_INSTANCE
if thing.find("$") > 0:
thing = thing.replace("$", "_D")
return keywordReplace_helper(thing)
if type(thing) == list:
return thing
oldCondition = self.inCondition
if "inCondition" in kargs:
self.inCondition = kargs["inCondition"]
del kargs["inCondition"]
try:
result = getattr(self, thing.__class__.__name__)(thing, **kargs)
except ClassOverriding as e:
oClass = self.solver(e.args[0])
result = self.solver(e.args[1], isAnonymous=True)
self.inCondition = oldCondition
return result
def overloadEntry(self, overloading):
self.c("Overloading Entries")
clsName = self.vManager.getPath()
for method in overloading:
self.p("\n")
self.p("@classmethod\n")
self.p("def {}({}, *args):\n".format(method, SELF_INSTANCE))
self.p(' fname = "Oed_{}__" + "__".join(i.__class__.__name__ for i in args)\n'.format(method))
self.p(" func = getattr({}, fname)\n".format(clsName))
self.p(" return func(*args)\n")
