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)