def create(typevar):
node_typevar = []
for st in typevar:
if st.datatype in ("INT", "DOUBLE", "BOOLEAN", "STRING",
"INTLIST", "DOUBLELIST", "STRINGLIST",
"DATE", "DATELIST"):
node = Node(type="local",
name=st.name,
pseudo_type=self.DATATYPE[st.datatype])
node_typevar.append(node)
if st.datatype in (
"INTARRAY",
"DOUBLEARRAY",
"STRINGARRAY",
"DATEARRAY",
):
if st.len.isdigit():
elts = Node(type='int',
value=st.len,
pseudo_type='int')
else:
elts = Node(type='name',
name=st.len,
pseudo_type='int')
node = Node(type="local",
name=st.name,
elts=[elts],
pseudo_type=self.DATATYPE[st.datatype])
node_typevar.append(node)
return node_typevar
def translateNotContains(node):
return Node("call",
function="ALL",
args=Node(type="binary_op",
op="!=",
right=node.args,
left=node.receiver),
pseudo_type=node.pseudo_type)
def translateCeil(node):
return Node("call",
function="REAL",
args=Node("call",
function='CEILING',
args=node.args,
pseudo_type="FLOAT"),
pseudo_type="FLOAT")
def translateNotContains(node):
return Node("unary_op",
operator="not",
value=Node("standard_method_call",
receiver=node.receiver,
message="contains?",
args=node.args,
pseudo_type=node.pseudo_type))
def translatePow(node):
return Node("call",
function=" ",
args=Node("binary_op",
op="**",
left=node.args[0],
right=node.args[1]),
pseudo_type="boolean")
def translateNotContains(node):
return Node("call",
function="!",
args=[
Node("standard_method_call",
receiver=node.receiver,
message="contains?",
args=node.args,
pseudo_type=node.pseudo_type)
])
def translateNotContains(node):
return Node("call",
function="!",
args=[
Node("simpleCall",
op='%in%',
value=node.args,
sequence=node.receiver,
pseudo_type='Boolean')
])
def getStrategyVar(self, tree):
""" This method returns a list of parameters and the value of their attributes
and the name and category of model inputs and outputs
Args:\n
tree (Node): a tree where the parameters and inouts will be extracted
Returns:\n
list: list of parameters and the value of their attributes
and the name of model inputs and outputs and their category
"""
self.getTypeNode(tree, "constructorDef")
constrNode = self.getTree
self.getTypeNode(constrNode[0], "declaration")
declNode = self.getTree
vinfo, inou = [], []
for g in declNode:
decl = g.decl
d = self.getAttNode(decl, **{"type":"VarInfo"})
i = self.getAttNode(decl, **{"pseudo_type": ["List","PropertyDescription"]})
if d: vinfo.append(d[0].name)
if i: inou.append(i[0].name)
pd = self.getAttNode(constrNode[0].block, **{"type":"ExprStatNode"})
pde = [p.expr for p in pd]
pdi = self.getAttNode(pde, **{"type":"standard_method_call", "receiver":Node(type ='local', name = inou[0], pseudo_type = ['List', 'PropertyDescription']), "message":"append"})
pdo = self.getAttNode(pde, **{"type":"standard_method_call", "receiver":Node(type ='local', name = inou[1], pseudo_type = ['List', 'PropertyDescription']), "message":"append"})
pdi_name = [x[0].name for x in [p.args for p in pdi if p]]
pdo_name = [x[0].name for x in [p.args for p in pdo if p]]
listatt = ["DefaultValue","Description","MaxValue", "MinValue", "Name", "Unit", "URL", "ValueType"]
pa =[]
for v in vinfo:
vi={}
for att in listatt:
n = self.getAttNode(constrNode[0].block,**{'type':'assignment', 'target': Node(type = 'member_access', name= v, member = att, pseudo_type = 'VarInfo')})
if att !="ValueType" :
vi[att] = n[0].value.value
if isinstance(vi[att] , Node): vi[att] = "%s%s"%(n[0].value.operator,vi[att].value)
else:
vi[att] = mapType[n[0].value.args[0].value.decode("utf-8")]
vi["category"] = "constant" # "TODOOOOOOOO"
pa.append(vi)
def inout_att(pd_name):
inps =[]
for p in pd_name:
pi={}
n = self.getAttNode(constrNode[0].block,**{'type':'assignment', 'target': Node(type = 'member_access', name= p, member = "PropertyName", pseudo_type = 'PropertyDescription')})
pi["Name"] = n[0].value.value
n = self.getAttNode(constrNode[0].block,**{'type':'assignment', 'target': Node(type = 'member_access', name= p, member = "DomainClassType", pseudo_type = 'PropertyDescription')})
pi["category"] = n[0].value.class_type
inps.append (pi)
return inps
inp = inout_att(pdi_name)
out = inout_att(pdo_name)
return pa, inp, out
def translateSum(node):
return Node("call",
function="accumulate",
args=[
Node("local", name="%s.begin()" % node.receiver.name),
Node("local", name="%s.end()" % node.receiver.name),
Node("local",
name="decltype(%s)::value_type(0)" %
node.receiver.name)
],
pseudo_type=node.pseudo_type)
def translatePop(node):
return Node("custom_call",
receiver=node.receiver,
function="%s.erase" % node.receiver.name,
args=[
Node(type="binary_op",
left=Node(type="local",
name="%s.begin()" % (node.receiver.name)),
op="+",
right=node.args)
],
pseudo_type=node.pseudo_type)
def translateSum(node):
if node.pseudo_type == "float":
return Node("method_call",
receiver=node.receiver,
message=".stream().mapToDouble(Double::doubleValue).sum()",
args=[],
pseudo_type=node.pseudo_type)
elif node.pseudo_type == "int":
return Node("method_call",
receiver=node.receiver,
message=".stream().mapToInt(Integer::intValue).sum()",
args=[],
pseudo_type=node.pseudo_type)
def visit_implicit_return(self, node):
if (not self.funcname.startswith("model_")
and not self.funcname.startswith("init_")):
self.newline(node)
if len(self.z.returns) == 1 and "name" in dir(
self.z.returns[0].value):
pass
elif len(self.z.returns
) > 1 or self.z.returns[0].value.type != "tuple":
newNode = Node(type="assignment",target=Node(type="local", name="res_cyml"),\
value=node.value)
self.visit(newNode)
else:
pass
def visit_assignment(self, node):
if node.value.type == "cond_expr_node":
self.visit_cond_expr_node(node)
elif node.value.type == "standard_call" and node.value.function == "integr":
self.newline(node)
self.write("%s = %s" % (node.target.name, node.value.args[0].name))
self.newline(node)
self.write("call Add(%s," % node.target.name)
self.visit(node.value.args[1])
self.write(")")
elif (node.value.type == "custom_call" and not self.recursive
and node.value.pseudo_type
== "tuple") or (node.value.type == "custom_call"
and node.value.function.startswith('model_')):
self.newline(node)
node = Node("subroutine",
receiver=node.target,
function=node.value.function,
args=node.value.args)
self.write('call ')
self.visit(node)
elif node.value.type == "list" and not node.value.elements:
self.write("\n deallocate(%s)\n" % node.target.name)
elif node.value.type == "notAnumber":
self.visit_notAnumber(node)
else:
self.newline(node)
self.visit(node.target)
self.write(' = ')
self.visit(node.value)
def translateCopy(node):
types = {
"int": "int",
"float": "double",
"bool": "bool",
"array": "%s[] %s= new %s",
"list": "List",
"tuple": "Tuple",
"str": "string",
"dict": "Dictionary",
"datetime": "DateTime",
"DateTime": "DateTime"
}
return Node(type="call",
function="new List<%s>" % (types[node.pseudo_type[1]]),
args=[Node("local", name=node.args.name)])
def translatePrint(node):
if node.args[0].type == "tuple":
x = []
for n in node.args[0].elements:
if "value" in dir(n) and n.value in [b'\r', b'\t', b'\n']: continue
x.append(
Node(type="ExprStatNode",
expr=Node(type="custom_call",
function="Console.WriteLine",
args=[n])))
return x
else:
return Node(type="ExprStatNode",
expr=Node(type="custom_call",
function="Console.WriteLine",
args=node.args))
def add_features(self, node):
self.internal = self.internal_declaration(node)
internal_name=[]
if self.internal is not None:
self.internal = self.internal if isinstance(self.internal,list) else [self.internal]
for inter in self.internal:
if 'elements' in dir(inter):
self.initialValue.append(Node(type="initial",name = inter.name, pseudo_type=inter.pseudo_type, value = inter.elements))
internal_name= [e.name for e in self.internal]
self.params = self.retrieve_params(node)
params_name = [e.name for e in self.params]
outputs = self.transform_return(node)[1]
if not isinstance(outputs, list):
outputs=[outputs]
outputs_name = [e.name for e in outputs]
variables = self.params+self.internal if self.internal else self.params
newNode=[]
for var in variables:
if var.pseudo_type in ["datetime", ["list","datetime"]]: self.therearedate=True
if var not in newNode:
if var.name in params_name and var.name not in outputs_name:
var.feat = "IN"
newNode.append(var)
if var.name in params_name and var.name in outputs_name:
var.feat = "INOUT"
newNode.append(var)
if var.name in internal_name and var.name in outputs_name:
var.feat = "OUT"
newNode.append(var)
if var.name in internal_name and var.name not in outputs_name:
newNode.append(var)
return newNode
def x(l, f, *args):
pseudo_type, args = args[-1], list(args[:-1])
if args and swap:
f, args[0] = args[0], f
cs = Node(type="method_call",
receiver=l,
message=name,
args=[f] + args,
pseudo_type=pseudo_type)
if z:
cs.pseudo_type = 'CSharpEnumerable'
return Node(type="method_call",
receiver=cs,
message='ToList',
args=[],
pseudo_type=pseudo_type)
else:
return cs
def visit_function(self, node):
self.newline(extra=1)
self.write("RECURSIVE FUNCTION %s" %
(node.name)) if node.recursive else self.write(
"FUNCTION %s" % (node.name))
self.write("(")
parameters = []
node_params = []
for pa in node.params:
if pa.name not in self.mod_parameters:
parameters.append(pa.name)
pa.feat = "IN"
node_params.append(pa)
self.write(', &\n '.join(parameters))
if len(self.z.returns) == 1 and "name" in dir(self.z.returns[0].value):
self.write(') RESULT(%s)' %
(','.join(self.transform_return(node)[0])))
elif len(self.z.returns) > 1:
self.write(') RESULT(res_cyml)')
else:
self.write(') RESULT(%s)' %
(','.join(self.transform_return(node)[0])))
self.indentation += 1
self.initialValue = []
newNode = self.add_features(node)
self.newline(node)
self.write("IMPLICIT NONE")
self.newline(node)
self.visit_declaration(node_params) #self.visit_decl(node)
self.visit_declaration(self.transform_return(node)[1])
interVar = [i for i in newNode if "feat" not in dir(i)]
self.visit_declaration(interVar)
if len(self.z.returns) > 1:
self.visit_declaration([
Node(type="local",
name="res_cyml",
pseudo_type=node.return_type)
])
if self.initialValue:
for n in self.initialValue:
if isinstance(n.pseudo_type, list) and len(
n.value) >= 1 and n.pseudo_type[0] in ("list",
"array"):
self.write("%s = " % n.name)
self.write(u'(/')
self.comma_separated_list(n.value)
self.write(u'/)')
self.newline(node)
elif isinstance(n.pseudo_type, str):
if n.value == b'': self.write('%s = ""' % (n.name))
else: self.write("%s = %s" % (n.name, n.value))
self.newline(node)
self.indentation -= 1
self.newline(node)
self.body(node.block)
self.newline(node)
self.write("END FUNCTION %s" % node.name)
def create(typevar):
node_typevar = []
def catvar(var):
if "variablecategory" in dir(
var) and var.variablecategory == "state":
return "s"
if "variablecategory" in dir(
var) and var.variablecategory == "rate":
return "r"
if "variablecategory" in dir(
var) and var.variablecategory == "auxiliary":
return "a"
for st in typevar:
if st.datatype in ("INT", "DOUBLE", "BOOLEAN", "STRING",
"INTLIST", "DOUBLELIST", "STRINGLIST",
"DATE", "DATELIST"):
node = Node(type="local",
name=st.name,
pseudo_type=self.DATATYPE[st.datatype],
cat=catvar(st))
node_typevar.append(node)
if st.datatype in (
"INTARRAY",
"DOUBLEARRAY",
"STRINGARRAY",
"DATEARRAY",
):
if st.len.isdigit():
elts = Node(type='int',
value=st.len,
pseudo_type='int')
else:
elts = Node(type='name',
name=st.len,
pseudo_type='int')
node = Node(type="local",
name=st.name,
elts=[elts],
pseudo_type=self.DATATYPE[st.datatype],
cat=catvar(st))
node_typevar.append(node)
return node_typevar
def translateMAX(node):
args = []
if len(node.args) >= 2:
for i in range(len(node.args)):
if node.args[i].pseudo_type != node.pseudo_type:
node.args[i] = Node(type="call",
function=CppRules.types[node.pseudo_type],
args=node.args[i],
pseudo_type=node.pseudo_type)
args.append(node.args[i])
node.type = "call"
node.args = args
node.function = "max"
return node
def visit_assignment(self, node):
if node.value.type == "cond_expr_node":
self.visit_cond_expr_node(node)
elif node.value.type == "custom_call":
self.newline(node)
node = Node("subroutine",
receiver=node.target,
function=node.value.function,
args=node.value.args)
self.write('call ')
self.visit(node)
else:
self.newline(node)
self.visit(node.target)
self.write(' = ')
self.visit(node.value)
def internal_declaration(self, node):
statements = node.block
if isinstance(statements, list):
intern_decl = statements[0].decl if statements[
0].type == "declaration" else None
for stmt in statements[1:]:
if stmt.type == "declaration":
intern_decl = intern_decl + stmt.decl
if self.z.ForSequence:
for i in range(self.z.nbForSeq):
intern_decl = intern_decl + [
Node(type="int",
name="i_cyml%s" % i,
pseudo_type="int")
]
else:
intern_decl = statements.decl if statements.type == "declaration" else None
return intern_decl
def visit_assignment(self, node):
if node.value.type == "cond_expr_node":
self.visit_cond_expr_node(node)
elif node.value.type == "custom_call":
self.newline(node)
node = Node("subroutine",
receiver=node.target,
function=node.value.function,
args=node.value.args)
self.write('call ')
self.visit(node)
elif node.value.type == "list" and not node.value.elements:
self.write("\n deallocate(%s)\n" % node.target.name)
elif node.value.type == "notAnumber":
self.visit_notAnumber(node)
else:
self.newline(node)
self.visit(node.target)
self.write(' = ')
self.visit(node.value)
def translateget(node):
if "value" in dir(node.args[0]):
return Node('index',
sequence=Node('local',
name=node.receiver.name,
pseudo_type=node.receiver.pseudo_type),
index=Node(node.args[0].type,
value=node.args[0].value,
pseudo_type=node.args[0].pseudo_type),
pseudo_type="Void")
elif "name" in dir(node.args[0]):
return Node('index',
sequence=Node('local',
name=node.receiver.name,
pseudo_type=node.receiver.pseudo_type),
index=Node(node.args[0].type,
name=node.args[0].name,
pseudo_type=node.args[0].pseudo_type),
pseudo_type="Void")
def translateLenList(node): return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type)
def translateSum(node):
def translateDictkeys(node): return Node("method_call", receiver=node.receiver, message=".keySet()", args=[], pseudo_type=node.pseudo_type)
class JavaRules(GeneralRule):
def translateLenArray(node): return Node("method_call", receiver=node.receiver, message=".length", args=[], pseudo_type=node.pseudo_type)
def translateDictkeys(node): return Node("method_call", receiver=node.receiver, message=".keySet()", args=[], pseudo_type=node.pseudo_type)
def trans_format_parse(node): return Node("standard_call", args=Node(type="str", value=argsToStr(node.args), pseudo_type="str"), function="format.parse", pseudo_type=node.pseudo_type)
def translateNotContains(node): return Node("unary_op", operator="not", value=Node("standard_method_call", receiver=node.receiver, message="contains?", args=node.args, pseudo_type=node.pseudo_type))
def translatevalueDict(node):
return Node("method_call",
receiver=node.receiver,
message=".Values.ToList()",
args=[],
pseudo_type=node.pseudo_type)
def translateLenArray(node):
return Node("method_call",
receiver=node.receiver,
message=".Length",
args=[],
pseudo_type=node.pseudo_type)
