Merge pull request #19 from cyrillemidingoyi/release

update

Author: cyrillemidingoyi

src/pycropml/cyml.py

@@ -14,6 +14,7 @@
 from pycropml.transpiler.antlr_py.bioma.run import run_bioma
 from pycropml.transpiler.antlr_py.openalea.run import run_openalea
 from pycropml.transpiler.antlr_py.fortran.run import run_fortran
+from pycropml.transpiler.antlr_py.python.run import run_python
 from pycropml import render_cyml, nameconvention
 from pycropml.pparse import model_parser
 from pycropml.writeTest import WriteTest
@@ -32,7 +33,7 @@
 NAMES = {'r':'r','cs':'csharp','cpp':'cpp', 'py':'python', 'f90':'fortran', 'java':'java', 'simplace':'simplace', 'sirius':'sirius', "openalea":"openalea","apsim":"apsim", "record":"record", "dssat":"dssat","bioma":"bioma", "stics":"stics", "sirius2":"sirius2"}
 ext = {'r':'r','cs':'cs','cpp':'cpp', 'py':'py', 'f90':'f90', 'java':'java', 'simplace':'java', 'sirius':'cs','bioma':'cs', "openalea":"py", "apsim":"cs", "record":"cpp", "dssat":"f90", "stics":"f90", "sirius2":'cs'}
 
-cymltx_languages = ['dssat', "simplace", "bioma", "openalea", "f90", "stics"]
+cymltx_languages = ['dssat', "simplace", "bioma", "openalea", "f90", "stics", "py"]
 langs = ["cs", "cpp", "java", "f90", "r", "py"]
 
 domain_class = ["cs", "java", 'sirius','cpp', "bioma", "sirius2"]

src/pycropml/transpiler/antlr_py/bioma/run.py

@@ -425,6 +425,7 @@ def run_bioma(component, output):
         env = {m.name:m.pseudo_type for j in rr.declarations for m in j.decl}
         zz = CheckingInOut( {},isAlgo = True)
         r_ch = zz.process(vv)
+        print(zz.inputs, zz.outputs)
         z.modelunit(description, var_, all_var_pa,var,  list(set(zz.inputs)), list(set(zz.outputs)))
         print(z.model.name) 
         #print(z.model.outputs)

src/pycropml/transpiler/antlr_py/createXml.py

@@ -128,7 +128,6 @@ def run_compo(self):
 
         composition = ns.Composition()
         for m in md.model:
-            print("uuu", m)
             composition.append(ns.Model(name=m, id=self.pkgname+'.'+m, filename='unit.'+m+'.xml'))
 
         links = ns.Links()

src/pycropml/transpiler/antlr_py/csharp/csharp_preprocessing.py

@@ -49,6 +49,19 @@ def inst_dclass(meth):
 
 class CheckingInOut(Middleware):
 
+    """_summary_
+    This code defines a middleware class called "CheckingInOut" 
+    that checks the inputs and outputs of a given code block. 
+    It does this by keeping track of the current scope and environment, 
+    and adding any new variables to the environment. 
+    It also keeps track of the inputs and outputs of the code block 
+    by checking if a variable is already in the current scope or not. 
+    The middleware class has methods for different types of statements 
+    and expressions, such as assignment, if statements, for loops, and function calls. 
+    The purpose of this middleware is to ensure that the inputs and outputs 
+    of a code block are well-defined and can be used by other parts of a program.
+    """
+    
     def __init__(self, env_init=None, isAlgo=False):
         if env_init is None:
             self.env_init = {}
@@ -80,8 +93,9 @@ def action_assignment(self, tree):
         if tree.target.type == "local":
             t_name = tree.target.name
             type_ = tree.target.pseudo_type
-            if t_name not in self.current_scope and not self.isAlgo:
+            if t_name not in self.current_scope and not self.isAlgo: # self.env[-1]
                 self.inputs.append(t_name) 
+            
             self.env[-1][t_name] = type_
             self.outputs.append(t_name)
 
@@ -123,33 +137,48 @@ def action_declaration(self, tree):
         for d in tree.decl:
             if "value" in dir(d):
                 self.transform_default(d.value)
+            self.env[-1][d.name] = d.type
+            self.current_scope = self.current()
         return tree
 
 
     def action_local(self, tree):
-        if tree.name not in self.current_scope:
+        
+        if tree.name not in self.current_scope:# and tree.name  not in self.outputs:
             self.inputs.append(tree.name)
+            self.env[-1][tree.name] = tree.type 
+            self.current_scope = self.current()      
         return tree
 
     def action_if_statement(self, tree):
         self.env.append({})
         self.transform(tree.test)
         self.transform(tree.block)
+        m1 = self.env[-1]
+        print("pppppp", m1)
         self.env.pop()
         self.current_scope = self.current()
 
         if tree.otherwise:
             self.env.append({})
             self.transform(tree.otherwise)
+            m2 = self.env[-1]
+            print("nnnnnnnn", m2)
             self.env.pop()
+            common_keys = m1.keys( ) & m2.keys()
+            common_dict = {k:m1[k] for k in common_keys}
+            self.env[-1].update(common_dict)
             self.current_scope = self.current()  
+        print("iiiii", self.inputs)
+        print("ifff", self.current_scope)   
         return tree
 
-    def action_elseif_statement(self, tree):
-        return self.workflow(tree)
+    #def action_elseif_statement(self, tree):
+        #print("oooooooooooooooo")
+        #return self.workflow(tree)
 
-    def action_else_statement(self, tree):
-        return self.workflow(tree)
+    #def action_else_statement(self, tree):
+        #return self.workflow(tree)
 
     def action_for_statement(self, tree):
         return self.workflow(tree)

src/pycropml/transpiler/antlr_py/extract_metadata_from_comment.py

@@ -102,6 +102,7 @@ def attval(pat_name, string):
     lines = att[0][0].split('\n')[1:-1]
     dic = {}
     for line in lines:
+        if not line: continue
         attribute = re.search(pattern_attr_val, line).group("attribute")
         value = re.search(pattern_attr_val, line, re.ASCII).group("value").replace('\r', "")
         dic[attribute] = str(value)

src/pycropml/transpiler/antlr_py/fortran/f90_cyml.py

@@ -304,13 +304,26 @@ def visit_ExprStatNode(self, node):
             "expr": self.visit(node.expr)
         }
 
+    def visit_sliceindex(self, node):
+        rec = self.visit(node.receiver)
+        print(rec)
+        return {'type': 'sliceindex',
+                'receiver': self.visit(node.receiver),
+                'message': 'sliceindex',
+                'args': self.visit(node.args),
+                'pseudo_type': rec["pseudo_type"]}
+    
     def visit_index(self, node):
         z = self.visit(node.sequence)
         index = self.visit(node.index)
+        if not isinstance(index, list): index = index
+        elif isinstance(index, list) and len(index)==1: index = index[0]
+        else: print("#########TODO") #TODO
+        #print("bababa", index)
         return {'type': 'index',
             'sequence': z,
             'index': {"type":"binary_op", "op":"-", "left":index, "right":{"type":"int", "value":"1","pseudo_type":"int"}},
-            'pseudo_type': z["pseudo_type"]}
+            'pseudo_type': z["pseudo_type"][-1]}
 
     def visit_while_statement(self, node):
 
@@ -350,7 +363,6 @@ def visit_unary_op(self, node):
 
     def visit_whereconstruct(self, node):
         test = self.visit(node.test)
-        print(test, "yuuuuuuuuuuuu")
         body = self.visit(node.body)
         m = transform_to_syntax_tree(body)
         r = TransformLocal()

src/pycropml/transpiler/antlr_py/fortran/fortranExtraction.py

@@ -28,7 +28,6 @@ def __init__(self):
 
     def getProcess(self, tree):
         self.getTypeNode(tree, "function_definition") 
-        print([m.name for m in self.getTree])
         res = []
         for n in self.getTree:
             if n.comments:
@@ -94,6 +93,7 @@ def modelunit(self, file, tree):
     def externFunction(self, algo): 
         self.getTypeNode(algo, "call_stmt")
         custom_call = self.getTree
+        
         methNames = set({c.name for c in custom_call}) if custom_call else set()
         return methNames
 

src/pycropml/transpiler/antlr_py/fortran/fortranTransformer.py

@@ -383,6 +383,12 @@ class ActionStmt(AliasNode):
 
 class AcImpliedDo(AliasNode):
     _fields_spec = ["acImpliedDo","impliedDoVariable" ,"expression"]
+    
+class SFExprList(AliasNode):
+    _fields_spec = ["expression", "DOUBLECOLON",  "COLON"]
+
+class SubscriptTripletTail(AliasNode):
+    _fields_spec = ["expression", "DOUBLECOLON",  "COLON"]
 
 
 
@@ -631,6 +637,10 @@ def visit_ActionStmt(self, node):
         return ActionStmt.from_spec(node)
     def visit_AcImpliedDo(self, node):
         return AcImpliedDo.from_spec(node)
+    def visit_SFExprList(self, node):
+        return SFExprList.from_spec(node)
+    def visit_SubscriptTripletTail(self, node):
+        return SubscriptTripletTail.from_spec(node)
 
 class AstTransformer():
     def __init__(self, tree, code :str = None ,comments: str=None, env=None):
@@ -642,7 +652,6 @@ def __init__(self, tree, code :str = None ,comments: str=None, env=None):
             self.type_env = Env(dict(list(TYPED_API.items())), None)
             self.type_env['arrays']={}
         self.code : str = code
-        print(self.type_env['arrays'])
         if self.code:
             self.codelines = self.code.split("\n")
 
@@ -1144,21 +1153,23 @@ def visit_typedeclarationstmt(self, node, typeSpec, entityDeclList, DOUBLECOLON,
         if attrSpecSeq:
             self.attr = {}
             attr = self.visit(attrSpecSeq)
-        if attr and "DIMENSION" in attr and "ALLOCATABLE" in attr and attr["DIMENSION"] == [":"]:
+            
+        #if attr and "DIMENSION" in attr and "ALLOCATABLE" in attr and attr["DIMENSION"] == [":"]:
+        if attr and ("allocatable" in attr or "ALLOCATABLE" in attr):
             typ = "list"
             pseudo_type = ["list", elemtype_]
         else : 
             typ = elemtype_
             pseudo_type = elemtype_
         for j in names:
             zj = {"type":typ, "name": str(j["name"]), "pseudo_type":pseudo_type}
-            if "dim" in j:
+            if "dim" in j and typ!="list":
                 zj["type"] = "array"
                 zj["dim"] = j["dim"]
                 zj["elts"] = j["elts"]
                 zj["pseudo_type"] = ["array", elemtype_]  
                 self.type_env['arrays'].update({zj["name"]: zj["elts"] }) 
-            elif attr and  "DIMENSION" in attr and "ALLOCATABLE" not in attr:
+            elif attr and  "DIMENSION" in attr and ("ALLOCATABLE" not in attr and "allocatable" not in attr):
                 zj["type"] = "array"
                 zj["dim"] = len(attr["DIMENSION"])
                 zj["elts"] = attr["DIMENSION"]
@@ -1172,8 +1183,8 @@ def visit_typedeclarationstmt(self, node, typeSpec, entityDeclList, DOUBLECOLON,
         return res
 
     def visit_attrspecseq(self, node, attrSpecSeq,attrSpec,comments, location):
-        if "DIMENSION" in dir(attrSpec) : self.attr.update({"DIMENSION": self.visit(attrSpec.arraySpec)})
-        elif "INTENT" in dir(attrSpec):  self.attr.update({"INTENT": self.visit(attrSpec.intentSpec)})
+        if ("DIMENSION" in dir(attrSpec) or "dimmension" in dir(attrSpec) ) : self.attr.update({"DIMENSION": self.visit(attrSpec.arraySpec)})
+        elif ("INTENT" in dir(attrSpec) or "intent" in dir(attrSpec)):  self.attr.update({"INTENT": self.visit(attrSpec.intentSpec)})
         else : self.attr.update({self.visit(attrSpec):None})
 
         if attrSpecSeq: 
@@ -1241,17 +1252,17 @@ def visit_assignmentstmt(self, node, label, NAME, sFExprListRef, substringRange,
                         "value" : self.visit(expression),
                         "pseudo_type":"VOID",
                         "comments":comments}
-                if isinstance(res["target"]["pseudo_type"], list) and res["target"]["pseudo_type"][0]=="array" and res["value"]["type"] in ["int", "float", "str", "bool"]:
-                    type_ = res["value"]["type"]
-                    res["value"] = {'type': 'array',
+                if isinstance(res["target"]["pseudo_type"], list) and (res["target"]["pseudo_type"][0]=="array" or res["target"]["pseudo_type"][0]=="list") and res["value"]["pseudo_type"] in ["int", "float", "str", "bool"]:
+                    type_ = res["value"]["pseudo_type"]
+                    res["value"] = {'type': res["target"]["pseudo_type"][0],
                                     'elements': {'type': 'binary_op',
                                     'op': '*',
                                     'left': {'type': 'list',
                                     'pseudo_type': ['list', type_],
                                     'elements': [res["value"]]},
                                     'right': self.type_env['arrays'][res["target"]["name"]],
                                     'pseudo_type': ['list', type_]},
-                                    'pseudo_type': ['array', type_]}
+                                    'pseudo_type': type_}
                 if self.recursive and str(NAME)==self.out:
                         return {"type":"implicit_return",
                                 "value": res["value"],
@@ -1279,6 +1290,7 @@ def visit_sfexprlistref(self, node,sFExprList, commaSectionSubscript,comments, l
             return  self.visit(sFExprList)       
         else:
             return self.translate_list(commaSectionSubscript)
+        
 
     def visit_expression(self, node, level5Expr, expression, definedBinaryOp, comments,location):
         if definedBinaryOp:
@@ -1946,12 +1958,34 @@ def visit_sectionsubscriptlist(self, node,sectionSubscript, comments,location ):
 
     def visit_sectionsubscript(self, node, expression,subscriptTripletTail,comments,location):
         if expression:
+            res = self.visit(expression)
+            #print("uuuuuuuuu", res)
             if subscriptTripletTail:
-                pass
+                r = self.visit(subscriptTripletTail)
+                #print("uuuuuuuuu2", r)
+                if "args" in r and r["colon"]==1:
+                    res2 = {"sliceindex":[res, r["args"][0]]}
+                    return res2
+                else:
+                    print(f" visit_sectionsubscript not implemented at {location}")
             else:
-                return self.visit(expression)
+                return res
         else:
             return self.visit(subscriptTripletTail)
+
+    def visit_subscripttriplettail(self, node, expression, COLON, DOUBLECOLON, comments, location):
+        if expression:
+            res = self.visit(expression)
+            if COLON:
+                if len(res)==1:
+                    return {"args":res, "colon":1}
+                else:
+                    return {"args":res, "colon":2}
+            elif DOUBLECOLON:
+                return {"args":res, "colon":3}
+        else:
+            return {"colon":3}
+
 
 
     def visit_functionarglist(self, node, functionArg, functionArgList,sectionSubscriptList,comments, location):
@@ -2001,16 +2035,25 @@ def translate_func(self, name, args, location):
                 return z
         id_type = self.type_env[name]
         if id_type and isinstance(id_type, list):
+            args = args[0][0]
+            if "sliceindex" in args:
+                res = {'type': 'sliceindex',
+                        'receiver': {'type': 'local',
+                                    'name': name,
+                                    'pseudo_type': id_type},
+                        'message': 'sliceindex',
+                        'args': [args["sliceindex"][0],args["sliceindex"][1]],
+                        'pseudo_type': id_type}
+                return res
             return {'type': 'index',
                     'sequence': {'type': 'local',
                     'name': name,
                     'pseudo_type': id_type},
-                    'index': args[0][0],
+                    'index': args,
                     'pseudo_type': id_type[-1] }
 
         else:
             fname = name
-            print(name, "jjhhhhhhhhh")
             c = self.type_env.top['functions']
             if fname in c:
                 pseudo_type = c[fname][-1]
@@ -2377,6 +2420,19 @@ def visit_arrayconstructor(self, node, OBRACKETSLASH, CBRACKETSLASH, acValueList
     def visit_acimplieddo(self, node, acImpliedDo,impliedDoVariable ,expression, comments, location):
         print("akklll", location)
         return 
+    
+    def visit_sfexprlist(self, node, expression, COLON, DOUBLECOLON, comments, location):
+        res = self.visit(expression)
+        if not COLON and not DOUBLECOLON:
+            return res
+        elif COLON and expression:
+            print("uiiiiiiii", "TODO") #TODO
+
+
+            
+        
+                
+        
 
 
 

src/pycropml/transpiler/antlr_py/fortran/fortran_preprocessing.py

@@ -106,7 +106,8 @@ def action_call_stmt(self, tree):
         inputs = [args[n] for n in subr.inputs_pos]
         if otherparams: inputs = otherparams + inputs
         outputs = [args[n] for n in subr.outputs_pos]
-        tree =Node(type="assignment", target = Node(type="tuple", elements=outputs), value = Node(type="custom_call", function=name, args=inputs), comments = comments)
+        if len(outputs)==1: tree =Node(type="assignment", target = Node(type="local", name=outputs[0].name, pseudo_type=outputs[0].pseudo_type), value = Node(type="custom_call", function=name, args=inputs), comments = comments)
+        else: tree =Node(type="assignment", target = Node(type="tuple", elements=outputs), value = Node(type="custom_call", function=name, args=inputs), comments = comments)
         return self.transform_default(tree)