From 3f26194a9cd8340a6839bde02dc0207c1a6f4937 Mon Sep 17 00:00:00 2001 From: Michael Berg-Mohnicke Date: Fri, 28 Feb 2025 19:09:05 +0100 Subject: [PATCH 1/6] dev dump --- src/pycropml/cyml.py | 3 + .../transpiler/generators/cppGenerator.py | 80 ++++++++++++++++++- src/pycropml/transpiler/rules/cppRules.py | 23 ++++-- 3 files changed, 95 insertions(+), 11 deletions(-) diff --git a/src/pycropml/cyml.py b/src/pycropml/cyml.py index 478a5c4..fb22348 100644 --- a/src/pycropml/cyml.py +++ b/src/pycropml/cyml.py @@ -164,6 +164,9 @@ def transpile_package(package, language): name = os.path.split(file)[1].split(".")[0] for model in models: # in the case we haven't the same order if name.lower() == model.name.lower() and prefix(model) != "function": + #getattr(getattr(pycropml.transpiler.generators, f'{NAMES[language]}Generator'), + # f'header_mu_cpp2')(model, tg_rep, mc_name) + test = Main(file, language, model, T.model.name) test.parse() test.to_ast(source) diff --git a/src/pycropml/transpiler/generators/cppGenerator.py b/src/pycropml/transpiler/generators/cppGenerator.py index d16da31..452a91c 100644 --- a/src/pycropml/transpiler/generators/cppGenerator.py +++ b/src/pycropml/transpiler/generators/cppGenerator.py @@ -439,6 +439,7 @@ def visit_module(self, node): '#include \n' '#include \n' '#include \n' + '#include \n' '#include \n') if self.model: self.write(f'#include "{self.model.name}.h"\n') @@ -657,7 +658,14 @@ def visit_declaration(self, node): self.write(f"std::vector<{self.types[n.pseudo_type[1]]}> {n.name};") else: self.write(f"std::vector<{self.types[n.pseudo_type[1]]}> {n.name}") - self.write(f"({n.elts[0].name if 'name' in dir(n.elts[0]) else n.elts[0].value});") + if "name" in dir(n.elts[0]): + self.write(f"({n.elts[0].name});") + elif "value" in dir(n.elts[0]): + self.write(f"({n.elts[0].value});") + else: + self.write(f"(") + self.visit(n.elts[0]) + self.write(");") elif 'value' in dir(n) and n.type in ("int", "float", "str", "bool"): self.write(f"{self.types[n.type]} {n.name}") self.write(" = ") @@ -821,7 +829,19 @@ def write_comma(): self.write(')') def visit_standard_call(self, node): - node.function = self.functions[node.namespace][node.function] + ns = self.functions[node.namespace] + fn_name = node.function + node.function = ns[node.function] if fn_name in ns else None + if not node.function: # search other namespaces + for ns_name, ns2 in self.functions.items(): + if ns_name == node.namespace: + continue + if fn_name in ns2: + node.function = ns2[fn_name] + break + if not node.function: + print(f"Couldn't find function {fn_name} in namespace {node.namespace}") + return self.visit_call(node) def visit_importfrom(self, node): @@ -1191,7 +1211,7 @@ def instanceModels(self): def to_struct_cpp(models, rep, name): header_cpp(models, rep, name) - header_mu_cpp(models, rep, name) + #header_mu_cpp(models, rep, name) headerCompo(models, rep, name) generator = CppTrans(models) generator.result = [f'#include "{name}State.h"\n'] @@ -1313,7 +1333,7 @@ def header_mu_cpp(models, rep, name): file_func = mf.filename path_func = Path(os.path.join(m.path, "crop2ml", file_func)) func_tree = parser(Path(path_func)) - newtree = AstTransformer(func_tree, path_func) + newtree = AstTransformer(func_tree, path_func, m) # print(newtree) dict_ast = newtree.transformer() node_ast = transform_to_syntax_tree(dict_ast) @@ -1346,6 +1366,50 @@ def header_mu_cpp(models, rep, name): h = [] +def header_mu_cpp2(model, rep, name): + #mc = models[0].name + mc = model.name + m = model + h = [] + init = False + #for m in models[0].model: + if m.function: + for mf in m.function: + file_func = mf.filename + path_func = Path(os.path.join(m.path, "crop2ml", file_func)) + func_tree = parser(Path(path_func)) + newtree = AstTransformer(func_tree, path_func, m) + # print(newtree) + dict_ast = newtree.transformer() + node_ast = transform_to_syntax_tree(dict_ast) + z = {} + for f in filter(lambda x: x.type == "function_definition", node_ast.body): + z[f.name] = [f.return_type, f.params] + h.append(z) + if m.initialization: + init = True + generator = CppTrans([m]) + generator.result = [f''' +#pragma once +#define _USE_MATH_DEFINES +#include +#include +#include +#include +#include "{name}State.h" +#include "{name}Rate.h" +#include "{name}Auxiliary.h" +#include "{name}Exogenous.h" +'''] + generator.model2Node() + param = generator.node_param + generator.generate_hpp(param, f"{m.name}", mc=mc, h=h, init=init, ns=rep.name) + z = ''.join(generator.result) + filename = Path(os.path.join(rep, f"{m.name}.h")) + with open(filename, "wb") as tg_file: + tg_file.write(z.encode('utf-8')) + h = [] + def headerCompo(models, rep, name): """ Header file of model composite""" mc = models[0].name @@ -1456,6 +1520,14 @@ def visit_assignment(self, node): break self.write(f"_{name}.Calculate_Model(s, s1, r, a, ex);") self.newline(node) + elif "function" in dir(node.value) and node.value.function.split('_')[0]=="init": + name = node.value.function.split('init_')[1] + for m in self.modelt.model: + if name.lower() == signature2(m).lower(): + name = signature2(m) + break + self.write(f"_{name}.Init(s, s1, r, a, ex);") + self.newline(node) else: self.newline(node) if node.value.name not in self.modeltparams: diff --git a/src/pycropml/transpiler/rules/cppRules.py b/src/pycropml/transpiler/rules/cppRules.py index f353101..133e95f 100644 --- a/src/pycropml/transpiler/rules/cppRules.py +++ b/src/pycropml/transpiler/rules/cppRules.py @@ -67,13 +67,21 @@ def translateInsert(node): def translateContains(node): - return Node(type="binary_op", op="!=", - left=Node("custom_call", receiver=node.receiver, function="find", - args=[Node(type="local", name=f"{node.receiver.name}.begin()"), - Node(type="local", name=f"{node.receiver.name}.end()"), - node.args[0]]), - right=Node(type="local", name="%s.end()" % node.receiver.name)) - + if "name" in dir(node.receiver): + return Node(type="binary_op", op="!=", + left=Node("custom_call", receiver=node.receiver, function="find", + args=[Node(type="local", name=f"{node.receiver.name}.begin()"), + Node(type="local", name=f"{node.receiver.name}.end()"), + node.args[0]]), + right=Node(type="local", name="%s.end()" % node.receiver.name)) + else: + if "elements" in dir(node.receiver): + args_str = ", ".join([str(arg.value) for arg in node.receiver.elements]) + return Node(type="binary_op", op=">", + left=Node("custom_call", receiver=node.receiver, + function=f"set<{node.receiver.pseudo_type[1]}>(\"{args_str}\").find", + args=[node.args[0]]), + right=Node(type="int", value="0")) def translateIndex(node): return Node(type="binary_op", op="-", @@ -113,6 +121,7 @@ def __init__(self): binary_op = {"and": "&&", "or": "||", "not": "!", + "is_not": "!=", "<": "<", ">": ">", "==": "==", From 6f6b7cde4ab1b7634a427597f928c8ca03806864 Mon Sep 17 00:00:00 2001 From: Michael Berg-Mohnicke Date: Fri, 21 Mar 2025 12:41:25 +0100 Subject: [PATCH 2/6] dev dump --- .../transpiler/generators/cppGenerator.py | 3 +- src/pycropml/transpiler/rules/cppRules.py | 84 ++++++++++--------- 2 files changed, 46 insertions(+), 41 deletions(-) diff --git a/src/pycropml/transpiler/generators/cppGenerator.py b/src/pycropml/transpiler/generators/cppGenerator.py index 452a91c..96b5a1d 100644 --- a/src/pycropml/transpiler/generators/cppGenerator.py +++ b/src/pycropml/transpiler/generators/cppGenerator.py @@ -92,7 +92,8 @@ def visit_import(self, node): pass def visit_none(self, node): - pass + self.write("null") + #pass def visit_cond_expr_node(self, node): self.visit(node.test) diff --git a/src/pycropml/transpiler/rules/cppRules.py b/src/pycropml/transpiler/rules/cppRules.py index 133e95f..0199dca 100644 --- a/src/pycropml/transpiler/rules/cppRules.py +++ b/src/pycropml/transpiler/rules/cppRules.py @@ -2,19 +2,19 @@ from pycropml.transpiler.pseudo_tree import Node -def translateLenList(node): +def translate_len_list(node): return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) -def translateLenStr(node): +def translate_len_str(node): return Node("method_call", receiver=node.receiver, message=".length()", args=[], pseudo_type=node.pseudo_type) -def translateLog(node): +def translate_log(node): return Node("call", function="std::log10", args=[node.args[0]], pseudo_type=node.pseudo_type) -def translateSum(node): +def translate_sum(node): if "name" in dir(node.receiver): print(node.receiver.y) return Node("call", function="accumulate", @@ -24,24 +24,24 @@ def translateSum(node): pseudo_type=node.pseudo_type) -def translateNotContains(node): +def translate_not_contains(node): return Node("call", function="!", args=[Node("standard_method_call", receiver=node.receiver, message="contains?", args=node.args, pseudo_type=node.pseudo_type)]) -def translateLenDict(node): +def translate_len_dict(node): return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) -def translateLenArray(node): +def translate_len_array(node): return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) -def translatekeyDict(node): +def translate_key_dict(node): return Node("method_call", receiver=node.receiver, message=".Keys", args=[], pseudo_type=node.pseudo_type) -def translateget(node): +def translate_get(node): if "value" in dir(node.args[0]): return Node('index', sequence=Node('local', name=node.receiver.name, pseudo_type=node.receiver.pseudo_type), @@ -54,19 +54,19 @@ def translateget(node): pseudo_type="Void") -def translatePop(node): +def translate_pop(node): return Node("custom_call", receiver=node.receiver, function="%s.erase" % node.receiver.name, args=[ Node(type="binary_op", left=Node(type="local", name=f"{node.receiver.name}.begin()"), op="+", right=node.args)], pseudo_type=node.pseudo_type) -def translateInsert(node): +def translate_insert(node): return Node("custom_call", receiver=node.receiver, function=f"{node.receiver.name}.insert", args=[Node(type="binary_op", left=Node(type="local", name=f"{node.receiver.name}.begin()"), op="+", right=node.args[0]), node.args[1]], pseudo_type=node.pseudo_type) -def translateContains(node): +def translate_contains(node): if "name" in dir(node.receiver): return Node(type="binary_op", op="!=", left=Node("custom_call", receiver=node.receiver, function="find", @@ -83,13 +83,13 @@ def translateContains(node): args=[node.args[0]]), right=Node(type="int", value="0")) -def translateIndex(node): +def translate_index(node): return Node(type="binary_op", op="-", left=Node("custom_call", receiver=node.receiver, function="find", args=[Node(type="local", name=f"{node.receiver.name}.begin()"), Node(type="local", name=f"{node.receiver.name}.end()"), node.args[0]]), - right=Node(type="local", name="%s.begin()" % node.receiver.name)) + right=Node(type="local", name=f"{node.receiver.name}.begin()")) def translate_min_max(node, f): @@ -106,13 +106,17 @@ def translate_min_max(node, f): return node -def translateMIN(node): +def translate_min(node): return translate_min_max(node, "std::min") -def translateMAX(node): +def translate_max(node): return translate_min_max(node, "std::max") +def translate_is_nan(node): + return Node(type="binary_op", op="==", + left=node.args[0], + right=Node(type="local", name="std::nan")) class CppRules(GeneralRule): def __init__(self): @@ -134,10 +138,10 @@ def __init__(self): "!=": "!="} unary_op = { - 'not': '!', - '+': '+', - '-': '-', - '~': '~' + "not": "!", + "+": "+", + "-": "-", + "~": "~" } types = { @@ -169,7 +173,7 @@ def __init__(self): functions = { 'math': { 'ln': 'std::log', - 'log': translateLog, + 'log': translate_log, 'tan': 'std::tan', 'sin': 'std::sin', 'cos': 'std::cos', @@ -181,8 +185,8 @@ def __init__(self): 'round': 'std::round', 'exp': 'std::exp', 'pow': 'std::pow', - 'floor': 'std::floor' - + 'floor': 'std::floor', + "isnan": translate_is_nan, }, 'io': { 'print': "std::cout << ", @@ -191,12 +195,12 @@ def __init__(self): 'write_file': 'File.WriteAllText' }, 'system': { - 'min': translateMIN, - 'max': translateMAX, + 'min': translate_min, + 'max': translate_max, 'abs': 'std::abs', 'pow': 'std::pow'}, 'datetime': { - 'datetime': lambda node: Node(type="str", value=argsToStr(node.args)) + 'datetime': lambda node: Node(type="str", value=args_to_str(node.args)) } } @@ -216,29 +220,29 @@ def __init__(self): 'str': { 'int': 'int', 'find': '.find', - 'len': translateLenStr + 'len': translate_len_str }, 'list': { - 'len': translateLenList, + 'len': translate_len_list, 'append': '.push_back', - 'sum': translateSum, - 'pop': translatePop, - 'insert_at': translateInsert, - 'contains?': translateContains, - 'not contains?': translateNotContains, - 'index': translateIndex, + 'sum': translate_sum, + 'pop': translate_pop, + 'insert_at': translate_insert, + 'contains?': translate_contains, + 'not contains?': translate_not_contains, + 'index': translate_index, "allocate": lambda node: Node("assignment", target=node.receiver, value=Node("list", elements=node.args, pseudo_type=node.receiver.pseudo_type)) }, 'dict': { - 'len': translateLenDict, - 'keys': translatekeyDict, - "get": translateget + 'len': translate_len_dict, + 'keys': translate_key_dict, + "get": translate_get }, 'array': { - 'len': translateLenArray, - 'sum': translateSum, + 'len': translate_len_array, + 'sum': translate_sum, 'append': '.Add', "allocate": lambda node: Node("assignment", target=node.receiver, value=Node("list", elements=node.args, @@ -306,7 +310,7 @@ def __init__(self): ''' -def argsToStr(args): +def args_to_str(args): t = [] for arg in args: t.append(arg.value) From 3deaa48a8926595d30fdd28f8ae7dd07f76a5cec Mon Sep 17 00:00:00 2001 From: Michael Berg-Mohnicke Date: Fri, 21 Mar 2025 18:59:33 +0100 Subject: [PATCH 3/6] apsim campbell for cpp2 compiles --- .../transpiler/generators/cpp2Generator.py | 98 +++++++++- src/pycropml/transpiler/rules/cpp2Rules.py | 176 ++++++++++-------- 2 files changed, 187 insertions(+), 87 deletions(-) diff --git a/src/pycropml/transpiler/generators/cpp2Generator.py b/src/pycropml/transpiler/generators/cpp2Generator.py index 66c78fb..de97f6d 100644 --- a/src/pycropml/transpiler/generators/cpp2Generator.py +++ b/src/pycropml/transpiler/generators/cpp2Generator.py @@ -56,6 +56,11 @@ def visit_comparison(self, node): # self.write(')') def visit_binary_op(self, node): + # ignore checks against none (nullptr) because we use value types for lists and arrays + if node.right.type == "none" and node.left.pseudo_type[0] in ["list", "array"]: + self.write("true") + return + op = node.op prec = self.binop_precedence.get(op, 0) self.operator_enter(prec) @@ -92,7 +97,8 @@ def visit_import(self, node): pass def visit_none(self, node): - pass + self.write("null") + #pass def visit_cond_expr_node(self, node): self.visit(node.test) @@ -177,7 +183,10 @@ def visit_dict(self, node): self.write(u'}') def visit_bool(self, node): - self.write("true") if node.value == True else self.write("false") + if isinstance(node.value, str): + self.write(node.value) + elif isinstance(node.value, bool): + self.write("true") if node.value == True else self.write("false") def visit_standard_method_call(self, node): l = node.receiver.pseudo_type @@ -247,6 +256,7 @@ def visit_sliceindex(self, node): self.write(u"]") def visit_assignment(self, node): + dv = dir(node.value) if node.value.type == "binary_op" and node.value.left.type == "list": self.visit(node.target) self.write(".assign(") @@ -255,7 +265,6 @@ def visit_assignment(self, node): self.visit(node.value.left.elements[0]) self.write(");") - elif "function" in dir(node.value) and node.value.function.split('_')[0] == "model": name = node.value.function.split('model_')[1] for m in self.model.model: @@ -323,6 +332,57 @@ def visit_assignment(self, node): elif node.value.type == "none": pass + elif node.target.type == "sliceindex" and node.value.type == "sliceindex": + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + + elif node.target.type == "sliceindex" and "pseudo_type" in dv and node.value.pseudo_type[0] == "array": + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < ") + self.visit(node.value) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif node.target.type == "sliceindex": + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write("; _i < (") + self.visit(node.target.args[1]) + self.write("); _i++) {") + self.newline(node) + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write(";") + self.newline(node) + self.write("}") + self.newline(node) + else: self.newline(node) self.visit(node.target) @@ -465,6 +525,7 @@ def visit_module(self, node): '#include \n' '#include \n' '#include \n' + '#include \n' '#include \n') if self.model: self.write(f'#include "{self.model.name}.h"\n') @@ -697,7 +758,14 @@ def visit_declaration(self, node): self.write(f"std::vector<{self.types[n.pseudo_type[1]]}> {n.name};") else: self.write(f"std::vector<{self.types[n.pseudo_type[1]]}> {n.name}") - self.write(f"({n.elts[0].name if 'name' in dir(n.elts[0]) else n.elts[0].value});") + if "name" in dir(n.elts[0]): + self.write(f"({n.elts[0].name});") + elif "value" in dir(n.elts[0]): + self.write(f"({n.elts[0].value});") + else: + self.write(f"(") + self.visit(n.elts[0]) + self.write(");") elif 'value' in dn and n.type in ("int", "float", "str", "bool"): if "feat" in dn and n.feat in ("OUT", "INOUT") and is_init_or_model_func: self.write(f"{self.struct_name_for(n.name)}.{n.name} = ") @@ -893,7 +961,19 @@ def write_comma(): self.write(')') def visit_standard_call(self, node): - node.function = self.functions[node.namespace][node.function] + ns = self.functions[node.namespace] + fn_name = node.function + node.function = ns[node.function] if fn_name in ns else None + if not node.function: # search other namespaces + for ns_name, ns2 in self.functions.items(): + if ns_name == node.namespace: + continue + if fn_name in ns2: + node.function = ns2[fn_name] + break + if not node.function: + print(f"Couldn't find function {fn_name} in namespace {node.namespace}") + return self.visit_call(node) def visit_importfrom(self, node): @@ -1565,6 +1645,14 @@ def visit_assignment(self, node): break self.write(f"_{name}.Calculate_Model(s, s1, r, a, ex);") self.newline(node) + elif "function" in dir(node.value) and node.value.function.split('_')[0]=="init": + name = node.value.function.split('init_')[1] + for m in self.modelt.model: + if name.lower() == signature2(m).lower(): + name = signature2(m) + break + self.write(f"_{name}.Init(s, s1, r, a, ex);") + self.newline(node) else: self.newline(node) if node.value.name not in self.modeltparams: diff --git a/src/pycropml/transpiler/rules/cpp2Rules.py b/src/pycropml/transpiler/rules/cpp2Rules.py index 7fcc658..193cee6 100644 --- a/src/pycropml/transpiler/rules/cpp2Rules.py +++ b/src/pycropml/transpiler/rules/cpp2Rules.py @@ -1,20 +1,20 @@ from pycropml.transpiler.rules.generalRule import GeneralRule from pycropml.transpiler.pseudo_tree import Node +def translate_len_list(node): + return Node("call", function="int", args=[ + Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type)]) -def translateLenList(node): - return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) - -def translateLenStr(node): +def translate_len_str(node): return Node("method_call", receiver=node.receiver, message=".length()", args=[], pseudo_type=node.pseudo_type) -def translateLog(node): +def translate_log(node): return Node("call", function="std::log10", args=[node.args[0]], pseudo_type=node.pseudo_type) -def translateSum(node): +def translate_sum(node): if "name" in dir(node.receiver): #print(node.receiver.y) if "cpp_struct_name" in dir(node.receiver) and node.receiver.cpp_struct_name is not None: @@ -28,64 +28,74 @@ def translateSum(node): pseudo_type=node.pseudo_type) -def translateNotContains(node): +def translate_not_contains(node): return Node("call", function="!", args=[Node("standard_method_call", receiver=node.receiver, message="contains?", args=node.args, pseudo_type=node.pseudo_type)]) -def translateLenDict(node): - return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) +def translate_len_dict(node): + return Node("call", function="int", args=[ + Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type)]) -def translateLenArray(node): - return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) +def translate_len_array(node): + return Node("call", function="int", args=[ + Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type)]) -def translatekeyDict(node): +def translate_key_dict(node): return Node("method_call", receiver=node.receiver, message=".Keys", args=[], pseudo_type=node.pseudo_type) -def translateget(node): +def translate_get(node): if "value" in dir(node.args[0]): - return Node('index', sequence=Node('local', name=node.receiver.name, + 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, + 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 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=f"{node.receiver.name}.begin()"), op="+", - right=node.args)], pseudo_type=node.pseudo_type) +def translate_pop(node): + return Node("custom_call", receiver=node.receiver, function=f"{node.receiver.name}.erase", + args=[Node(type="binary_op", left=Node(type="local", name=f"{node.receiver.name}.begin()"), op="+", + right=node.args)], pseudo_type=node.pseudo_type) -def translateInsert(node): +def translate_insert(node): return Node("custom_call", receiver=node.receiver, function=f"{node.receiver.name}.insert", args=[Node(type="binary_op", left=Node(type="local", name=f"{node.receiver.name}.begin()"), op="+", right=node.args[0]), node.args[1]], pseudo_type=node.pseudo_type) -def translateContains(node): - return Node(type="binary_op", op="!=", - left=Node("custom_call", receiver=node.receiver, function="find", - args=[Node(type="local", name=f"{node.receiver.name}.begin()"), - Node(type="local", name=f"{node.receiver.name}.end()"), - node.args[0]]), - right=Node(type="local", name="%s.end()" % node.receiver.name)) - - -def translateIndex(node): +def translate_contains(node): + if "name" in dir(node.receiver): + return Node(type="binary_op", op="!=", + left=Node("custom_call", receiver=node.receiver, function="find", + args=[Node(type="local", name=f"{node.receiver.name}.begin()"), + Node(type="local", name=f"{node.receiver.name}.end()"), + node.args[0]]), + right=Node(type="local", name="%s.end()" % node.receiver.name)) + else: + if "elements" in dir(node.receiver): + args_str = ", ".join([str(arg.value) for arg in node.receiver.elements]) + return Node(type="binary_op", op=">", + left=Node("custom_call", receiver=node.receiver, + function=f"std::set<{CppRules.types[node.receiver.pseudo_type[1]]}>({{\"{args_str}\"}}).count", + args=[node.args[0]]), + right=Node(type="int", value="0")) + +def translate_index(node): return Node(type="binary_op", op="-", left=Node("custom_call", receiver=node.receiver, function="find", args=[Node(type="local", name=f"{node.receiver.name}.begin()"), Node(type="local", name=f"{node.receiver.name}.end()"), node.args[0]]), - right=Node(type="local", name="%s.begin()" % node.receiver.name)) + right=Node(type="local", name=f"{node.receiver.name}.begin()")) def translate_min_max(node, f): @@ -102,14 +112,13 @@ def translate_min_max(node, f): return node -def translateMIN(node): +def translate_min(node): return translate_min_max(node, "std::min") -def translateMAX(node): +def translate_max(node): return translate_min_max(node, "std::max") - class CppRules(GeneralRule): def __init__(self): GeneralRule.__init__(self) @@ -117,6 +126,7 @@ def __init__(self): binary_op = {"and": "&&", "or": "||", "not": "!", + "is_not": "!=", "<": "<", ">": ">", "==": "==", @@ -129,13 +139,14 @@ def __init__(self): "!=": "!="} unary_op = { - 'not': '!', - '+': '+', - '-': '-', - '~': '~' + "not": "!", + "+": "+", + "-": "-", + "~": "~" } types = { + "size_t": "int", "int": "int", "float": "double", "double": "double", @@ -162,42 +173,43 @@ def __init__(self): } functions = { - 'math': { - 'ln': 'std::log', - 'log': translateLog, - 'tan': 'std::tan', - 'sin': 'std::sin', - 'cos': 'std::cos', - 'asin': 'std::asin', - 'acos': 'std::acos', - 'atan': 'std::atan', - 'sqrt': 'std::sqrt', - 'ceil': '(int) std::ceil', - 'round': 'std::round', - 'exp': 'std::exp', - 'pow': 'std::pow', - 'floor': 'std::floor' - + "math": { + "ln": "std::log", + "log": translate_log, + "tan": "std::tan", + "sin": "std::sin", + "cos": "std::cos", + "asin": "std::asin", + "acos": "std::acos", + "atan": "std::atan", + "sqrt": "std::sqrt", + "ceil": "(int) std::ceil", + "round": "std::round", + "exp": "std::exp", + "pow": "std::pow", + "floor": "std::floor", + "isnan": "std::isnan", + }, + "io": { + "print": "std::cout << ", + "read": "Console.ReadLine", + "read_file": "File.ReadAllText", + "write_file": "File.WriteAllText" }, - 'io': { - 'print': "std::cout << ", - 'read': 'Console.ReadLine', - 'read_file': 'File.ReadAllText', - 'write_file': 'File.WriteAllText' + "system": { + "min": translate_min, + "max": translate_max, + "abs": "std::abs", + "pow": "std::pow" }, - 'system': { - 'min': translateMIN, - 'max': translateMAX, - 'abs': 'std::abs', - 'pow': 'std::pow'}, - 'datetime': { - 'datetime': lambda node: Node(type="str", value=argsToStr(node.args)) + "datetime": { + "datetime": lambda node: Node(type="str", value=args_to_str(node.args)) } } constant = { - 'math': { - 'pi': 'M_PI' + "math": { + "pi": "M_PI" } } @@ -211,29 +223,29 @@ def __init__(self): 'str': { 'int': 'int', 'find': '.find', - 'len': translateLenStr + 'len': translate_len_str }, 'list': { - 'len': translateLenList, + 'len': translate_len_list, 'append': '.push_back', - 'sum': translateSum, - 'pop': translatePop, - 'insert_at': translateInsert, - 'contains?': translateContains, - 'not contains?': translateNotContains, - 'index': translateIndex, + 'sum': translate_sum, + 'pop': translate_pop, + 'insert_at': translate_insert, + 'contains?': translate_contains, + 'not contains?': translate_not_contains, + 'index': translate_index, "allocate": lambda node: Node("assignment", target=node.receiver, value=Node("list", elements=node.args, pseudo_type=node.receiver.pseudo_type)) }, 'dict': { - 'len': translateLenDict, - 'keys': translatekeyDict, - "get": translateget + 'len': translate_len_dict, + 'keys': translate_key_dict, + "get": translate_get }, 'array': { - 'len': translateLenArray, - 'sum': translateSum, + 'len': translate_len_array, + 'sum': translate_sum, 'append': '.Add', "allocate": lambda node: Node("assignment", target=node.receiver, value=Node("list", elements=node.args, @@ -301,7 +313,7 @@ def __init__(self): ''' -def argsToStr(args): +def args_to_str(args): t = [] for arg in args: t.append(arg.value) From fd631766c8eb7b46291f42528efbab7cd8f56db0 Mon Sep 17 00:00:00 2001 From: Michael Berg-Mohnicke Date: Fri, 21 Mar 2025 19:07:16 +0100 Subject: [PATCH 4/6] moved some cpp2 changes also to cpp -> but cpp won't compile apsimcampbell atm --- .../transpiler/generators/cppGenerator.py | 65 +++++++++++++++- src/pycropml/transpiler/rules/cpp2Rules.py | 1 - src/pycropml/transpiler/rules/cppRules.py | 77 +++++++++---------- 3 files changed, 100 insertions(+), 43 deletions(-) diff --git a/src/pycropml/transpiler/generators/cppGenerator.py b/src/pycropml/transpiler/generators/cppGenerator.py index 96b5a1d..8d8fbc1 100644 --- a/src/pycropml/transpiler/generators/cppGenerator.py +++ b/src/pycropml/transpiler/generators/cppGenerator.py @@ -56,6 +56,11 @@ def visit_comparison(self, node): # self.write(')') def visit_binary_op(self, node): + # ignore checks against none (nullptr) because we use value types for lists and arrays + if node.right.type == "none" and node.left.pseudo_type[0] in ["list", "array"]: + self.write("true") + return + op = node.op prec = self.binop_precedence.get(op, 0) self.operator_enter(prec) @@ -178,7 +183,10 @@ def visit_dict(self, node): self.write(u'}') def visit_bool(self, node): - self.write(node.value) #if node.value == True else self.write("false") + if isinstance(node.value, str): + self.write(node.value) + elif isinstance(node.value, bool): + self.write("true") if node.value == True else self.write("false") def visit_standard_method_call(self, node): l = node.receiver.pseudo_type @@ -238,6 +246,7 @@ def visit_sliceindex(self, node): self.write(u"]") def visit_assignment(self, node): + dv = dir(node.value) if node.value.type == "binary_op" and node.value.left.type == "list": self.visit(node.target) self.write(".assign(") @@ -246,7 +255,6 @@ def visit_assignment(self, node): self.visit(node.value.left.elements[0]) self.write(");") - elif "function" in dir(node.value) and node.value.function.split('_')[0] == "model": name = node.value.function.split('model_')[1] for m in self.model.model: @@ -314,6 +322,57 @@ def visit_assignment(self, node): elif node.value.type == "none": pass + elif node.target.type == "sliceindex" and node.value.type == "sliceindex": + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + + elif node.target.type == "sliceindex" and "pseudo_type" in dv and node.value.pseudo_type[0] == "array": + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < ") + self.visit(node.value) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif node.target.type == "sliceindex": + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write("; _i < (") + self.visit(node.target.args[1]) + self.write("); _i++) {") + self.newline(node) + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write(";") + self.newline(node) + self.write("}") + self.newline(node) + else: self.newline(node) self.visit(node.target) @@ -1212,7 +1271,7 @@ def instanceModels(self): def to_struct_cpp(models, rep, name): header_cpp(models, rep, name) - #header_mu_cpp(models, rep, name) + header_mu_cpp(models, rep, name) headerCompo(models, rep, name) generator = CppTrans(models) generator.result = [f'#include "{name}State.h"\n'] diff --git a/src/pycropml/transpiler/rules/cpp2Rules.py b/src/pycropml/transpiler/rules/cpp2Rules.py index 193cee6..5322ab3 100644 --- a/src/pycropml/transpiler/rules/cpp2Rules.py +++ b/src/pycropml/transpiler/rules/cpp2Rules.py @@ -146,7 +146,6 @@ def __init__(self): } types = { - "size_t": "int", "int": "int", "float": "double", "double": "double", diff --git a/src/pycropml/transpiler/rules/cppRules.py b/src/pycropml/transpiler/rules/cppRules.py index 0199dca..0a5cc11 100644 --- a/src/pycropml/transpiler/rules/cppRules.py +++ b/src/pycropml/transpiler/rules/cppRules.py @@ -3,7 +3,8 @@ def translate_len_list(node): - return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) + return Node("call", function="int", args=[ + Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type)]) def translate_len_str(node): @@ -30,11 +31,13 @@ def translate_not_contains(node): def translate_len_dict(node): - return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) + return Node("call", function="int", args=[ + Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type)]) def translate_len_array(node): - return Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type) + return Node("call", function="int", args=[ + Node("method_call", receiver=node.receiver, message=".size()", args=[], pseudo_type=node.pseudo_type)]) def translate_key_dict(node): @@ -79,7 +82,7 @@ def translate_contains(node): args_str = ", ".join([str(arg.value) for arg in node.receiver.elements]) return Node(type="binary_op", op=">", left=Node("custom_call", receiver=node.receiver, - function=f"set<{node.receiver.pseudo_type[1]}>(\"{args_str}\").find", + function=f"std::set<{CppRules.types[node.receiver.pseudo_type[1]]}>({{\"{args_str}\"}}).count", args=[node.args[0]]), right=Node(type="int", value="0")) @@ -113,11 +116,6 @@ def translate_min(node): def translate_max(node): return translate_min_max(node, "std::max") -def translate_is_nan(node): - return Node(type="binary_op", op="==", - left=node.args[0], - right=Node(type="local", name="std::nan")) - class CppRules(GeneralRule): def __init__(self): GeneralRule.__init__(self) @@ -171,42 +169,43 @@ def __init__(self): } functions = { - 'math': { - 'ln': 'std::log', - 'log': translate_log, - 'tan': 'std::tan', - 'sin': 'std::sin', - 'cos': 'std::cos', - 'asin': 'std::asin', - 'acos': 'std::acos', - 'atan': 'std::atan', - 'sqrt': 'std::sqrt', - 'ceil': '(int) std::ceil', - 'round': 'std::round', - 'exp': 'std::exp', - 'pow': 'std::pow', - 'floor': 'std::floor', - "isnan": translate_is_nan, + "math": { + "ln": "std::log", + "log": translate_log, + "tan": "std::tan", + "sin": "std::sin", + "cos": "std::cos", + "asin": "std::asin", + "acos": "std::acos", + "atan": "std::atan", + "sqrt": "std::sqrt", + "ceil": "(int) std::ceil", + "round": "std::round", + "exp": "std::exp", + "pow": "std::pow", + "floor": "std::floor", + "isnan": "std::isnan", + }, + "io": { + "print": "std::cout << ", + "read": "Console.ReadLine", + "read_file": "File.ReadAllText", + "write_file": "File.WriteAllText" }, - 'io': { - 'print': "std::cout << ", - 'read': 'Console.ReadLine', - 'read_file': 'File.ReadAllText', - 'write_file': 'File.WriteAllText' + "system": { + "min": translate_min, + "max": translate_max, + "abs": "std::abs", + "pow": "std::pow" }, - 'system': { - 'min': translate_min, - 'max': translate_max, - 'abs': 'std::abs', - 'pow': 'std::pow'}, - 'datetime': { - 'datetime': lambda node: Node(type="str", value=args_to_str(node.args)) + "datetime": { + "datetime": lambda node: Node(type="str", value=args_to_str(node.args)) } } constant = { - 'math': { - 'pi': 'M_PI' + "math": { + "pi": "M_PI" } } From 6c083e1bef047024210a8f5c10dc40935b53b85c Mon Sep 17 00:00:00 2001 From: Michael Berg-Mohnicke Date: Tue, 25 Mar 2025 10:31:28 +0100 Subject: [PATCH 5/6] update to slices code !!! does not support full python slice semantics (no resizing of target) --- .../transpiler/generators/cpp2Generator.py | 414 +++++++++++++++++- .../transpiler/generators/cppGenerator.py | 414 +++++++++++++++++- 2 files changed, 816 insertions(+), 12 deletions(-) diff --git a/src/pycropml/transpiler/generators/cpp2Generator.py b/src/pycropml/transpiler/generators/cpp2Generator.py index de97f6d..8feb185 100644 --- a/src/pycropml/transpiler/generators/cpp2Generator.py +++ b/src/pycropml/transpiler/generators/cpp2Generator.py @@ -257,6 +257,7 @@ def visit_sliceindex(self, node): def visit_assignment(self, node): dv = dir(node.value) + dt = dir(node.target) if node.value.type == "binary_op" and node.value.left.type == "list": self.visit(node.target) self.write(".assign(") @@ -332,7 +333,11 @@ def visit_assignment(self, node): elif node.value.type == "none": pass - elif node.target.type == "sliceindex" and node.value.type == "sliceindex": + # all combinations of copies between slices + # assumes right now that the slices have the same size + # so no contraction or expansion of the target slice/array + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" + and node.value.type == "sliceindex" and node.value.message == "sliceindex"): self.write("for (int _i=") self.visit(node.target.args[0]) self.write(", _k=") @@ -350,8 +355,69 @@ def visit_assignment(self, node): self.write("[_k];") self.newline(node) self.write("}") + self.newline(node) - elif node.target.type == "sliceindex" and "pseudo_type" in dv and node.value.pseudo_type[0] == "array": + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" + and node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): self.write("for (int _i=") self.visit(node.target.args[0]) self.write(", _k=0; _i < (") @@ -360,6 +426,7 @@ def visit_assignment(self, node): self.visit(node.value) self.write(".size(); _i++, _k++) {") self.newline(node) + self.write(" ") self.visit(node.target.receiver) self.write("[_i] = ") self.visit(node.value) @@ -368,17 +435,352 @@ def visit_assignment(self, node): self.write("}") self.newline(node) - elif node.target.type == "sliceindex": + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): self.write("for (int _i=") self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) self.write("; _i < (") - self.visit(node.target.args[1]) - self.write("); _i++) {") + self.visit(node.target.args[0]) + self.write(") && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=0, _k=0; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") self.visit(node.target.receiver) self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=0, _k=0; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): + self.write("for (int _i=0, _k=0; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < ") self.visit(node.value) - self.write(";") + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" + and node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" + and node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target) + self.write(".size() && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target) + self.write(".size() && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") self.newline(node) self.write("}") self.newline(node) diff --git a/src/pycropml/transpiler/generators/cppGenerator.py b/src/pycropml/transpiler/generators/cppGenerator.py index 8d8fbc1..e9d98f0 100644 --- a/src/pycropml/transpiler/generators/cppGenerator.py +++ b/src/pycropml/transpiler/generators/cppGenerator.py @@ -247,6 +247,7 @@ def visit_sliceindex(self, node): def visit_assignment(self, node): dv = dir(node.value) + dt = dir(node.target) if node.value.type == "binary_op" and node.value.left.type == "list": self.visit(node.target) self.write(".assign(") @@ -322,7 +323,11 @@ def visit_assignment(self, node): elif node.value.type == "none": pass - elif node.target.type == "sliceindex" and node.value.type == "sliceindex": + # all combinations of copies between slices + # assumes right now that the slices have the same size + # so no contraction or expansion of the target slice/array + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" + and node.value.type == "sliceindex" and node.value.message == "sliceindex"): self.write("for (int _i=") self.visit(node.target.args[0]) self.write(", _k=") @@ -340,8 +345,69 @@ def visit_assignment(self, node): self.write("[_k];") self.newline(node) self.write("}") + self.newline(node) - elif node.target.type == "sliceindex" and "pseudo_type" in dv and node.value.pseudo_type[0] == "array": + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" + and node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.args[1]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): self.write("for (int _i=") self.visit(node.target.args[0]) self.write(", _k=0; _i < (") @@ -350,6 +416,7 @@ def visit_assignment(self, node): self.visit(node.value) self.write(".size(); _i++, _k++) {") self.newline(node) + self.write(" ") self.visit(node.target.receiver) self.write("[_i] = ") self.visit(node.value) @@ -358,17 +425,352 @@ def visit_assignment(self, node): self.write("}") self.newline(node) - elif node.target.type == "sliceindex": + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): self.write("for (int _i=") self.visit(node.target.args[0]) + self.write(", _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < (") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_from" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): + self.write("for (int _i=") + self.visit(node.target.args[0]) + self.write(", _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) self.write("; _i < (") - self.visit(node.target.args[1]) - self.write("); _i++) {") + self.visit(node.target.args[0]) + self.write(") && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=0, _k=0; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") self.visit(node.target.receiver) self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=0, _k=0; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "sliceindex_to" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): + self.write("for (int _i=0, _k=0; _i < (") + self.visit(node.target.args[0]) + self.write(") && _k < ") self.visit(node.value) - self.write(";") + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" + and node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" + and node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif (node.target.type == "sliceindex" and node.target.message == "slice_" and + "pseudo_type" in dv and node.value.pseudo_type[0] == "array"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target.receiver) + self.write(".size() && _k < ") + self.visit(node.value) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target.receiver) + self.write("[_i] = ") + self.visit(node.value) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "sliceindex"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target) + self.write(".size() && _k < (") + self.visit(node.value.args[1]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_from"): + self.write("for (int _i=0, _k=") + self.visit(node.value.args[0]) + self.write("; _i < ") + self.visit(node.target) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "sliceindex_to"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target) + self.write(".size() && _k < (") + self.visit(node.value.args[0]) + self.write("); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") + self.newline(node) + self.write("}") + self.newline(node) + + elif ("pseudo_type" in dt and node.target.pseudo_type[0] == "array" and + node.value.type == "sliceindex" and node.value.message == "slice_"): + self.write("for (int _i=0, _k=0; _i < ") + self.visit(node.target) + self.write(".size() && _k < ") + self.visit(node.value.receiver) + self.write(".size(); _i++, _k++) {") + self.newline(node) + self.write(" ") + self.visit(node.target) + self.write("[_i] = ") + self.visit(node.value.receiver) + self.write("[_k];") self.newline(node) self.write("}") self.newline(node) From 1cd7d1179f5a2131c042d5a286a5fda79181d0a7 Mon Sep 17 00:00:00 2001 From: Michael Berg-Mohnicke Date: Thu, 30 Oct 2025 11:04:01 +0100 Subject: [PATCH 6/6] different formating for if statement --- .../transpiler/generators/cpp2Generator.py | 106 ++++++++---------- 1 file changed, 48 insertions(+), 58 deletions(-) diff --git a/src/pycropml/transpiler/generators/cpp2Generator.py b/src/pycropml/transpiler/generators/cpp2Generator.py index 8feb185..2481823 100644 --- a/src/pycropml/transpiler/generators/cpp2Generator.py +++ b/src/pycropml/transpiler/generators/cpp2Generator.py @@ -91,7 +91,7 @@ def visit_unary_op(self, node): def visit_breakstatnode(self, node): self.newline(node) - self.write('break;') + self.write("break;") def visit_import(self, node): pass @@ -109,20 +109,19 @@ def visit_cond_expr_node(self, node): def visit_if_statement(self, node): self.newline(node) - self.write('if (') + self.write("if (") self.visit(node.test) - self.write(')') - self.newline(node) - self.write('{') + self.write(") {") self.newline(node) self.body(node.block) self.newline(node) - self.write('}') + self.write("}") + self.newline(node) while True: else_ = node.otherwise if len(else_) == 0: break - elif len(else_) == 1 and else_[0].type == 'elseif_statement': + elif len(else_) == 1 and else_[0].type == "elseif_statement": self.visit(else_[0]) else: self.visit(else_) @@ -131,23 +130,19 @@ def visit_if_statement(self, node): def visit_elseif_statement(self, node): self.newline() - self.write('else if ( ') + self.write("else if (") self.visit(node.test) - self.write(')') - self.newline(node) - self.write('{') + self.write(") {") self.body(node.block) self.newline(node) - self.write('}') + self.write("}") def visit_else_statement(self, node): self.newline() - self.write('else') - self.newline(node) - self.write('{') + self.write("else {") self.body(node.block) self.newline(node) - self.write('}') + self.write("}") def visit_print(self, node): pass @@ -622,7 +617,6 @@ def visit_assignment(self, node): self.newline(node) self.write("}") self.newline(node) - self.newline(node) elif (node.target.type == "sliceindex" and node.target.message == "slice_" and node.value.type == "sliceindex" and node.value.message == "sliceindex"): @@ -1168,7 +1162,7 @@ def visit_declaration(self, node): self.write(f"(") self.visit(n.elts[0]) self.write(");") - elif 'value' in dn and n.type in ("int", "float", "str", "bool"): + elif "value" in dn and n.type in ("int", "float", "str", "bool"): if "feat" in dn and n.feat in ("OUT", "INOUT") and is_init_or_model_func: self.write(f"{self.struct_name_for(n.name)}.{n.name} = ") else: @@ -1178,7 +1172,7 @@ def visit_declaration(self, node): else: self.visit(n) self.write(";") - elif n.type == 'datetime': + elif n.type == "datetime": if "feat" in dn and n.feat in ("OUT", "INOUT") and is_init_or_model_func: self.write(f"{self.struct_name_for(n.name)}.{n.name}") else: @@ -1187,40 +1181,40 @@ def visit_declaration(self, node): self.write(" = ") self.visit(n.elts) self.write(";") - elif 'elements' in dn and n.type in ("list", "tuple"): + elif "elements" in dn and n.type in ("list", "tuple"): if "feat" in dn and n.feat in ("OUT", "INOUT") and is_init_or_model_func: if n.type == "list": self.write(f"{self.struct_name_for(n.name)}.{n.name} = ") - self.write(u'{') + self.write("{") self.comma_separated_list(n.elements) - self.write(u'};') + self.write("};") else: if n.type == "list": self.visit_decl(n.pseudo_type) self.write(n.name) self.write(" = ") - self.write(u'{') + self.write("{") self.comma_separated_list(n.elements) - self.write(u'};') - if n.type == 'tuple': + self.write("};") + if n.type == "tuple": pass - elif 'pairs' in dn and n.type == "dict": + elif "pairs" in dn and n.type == "dict": self.visit_decl(n.pseudo_type) self.write(n.name) - self.write(u' = {') + self.write(" = {") self.comma_separated_list(n.pairs) - self.write(u'};') + self.write("};") self.newline(node) def visit_list_decl(self, node, pa=None): if not isinstance(node[1], list): self.write(self.types[node[1]]) - self.write('>') + self.write(">") else: node = node[1] self.visit_decl(node, pa) - self.write('>') + self.write(">") if pa and "name" in dir(pa): self.write(f" {pa.name}") @@ -1229,11 +1223,11 @@ def visit_dict_decl(self, node): self.write(",") if not isinstance(node[2], list): self.write(self.types[node[2]]) - self.write('>') + self.write(">") else: node = node[2] self.visit_decl(node) - self.write('>') + self.write(">") def visit_tuple_decl(self, node): self.visit_decl(node[0]) @@ -1241,7 +1235,7 @@ def visit_tuple_decl(self, node): self.visit_decl(n) self.write(",") self.visit_decl(node[-1]) - self.write('>') + self.write(">") def visit_float_decl(self, node, pa=None): self.write(self.types[node]) @@ -1300,23 +1294,23 @@ def visit_array_decl(self, node, pa=None): else:""" node = node[1] self.visit_decl(node) - self.write('> ') + self.write("> ") if pa: self.write(pa.name) def visit_decl(self, node, pa=None): if isinstance(node, list): if node[0] == "list": - self.write('std::vector<') + self.write("std::vector<") self.visit_list_decl(node, pa) elif node[0] == "dict": self.write("std::map<") self.visit_dict_decl(node) elif node[0] == "tuple": - self.write('std::tuple<') + self.write("std::tuple<") self.visit_tuple_decl(node) elif node[0] == "array": - self.write('std::vector<') + self.write("std::vector<") self.visit_array_decl(node, pa) else: if node == "float": @@ -1331,11 +1325,11 @@ def visit_decl(self, node, pa=None): self.visit_datetime_decl(node) def visit_pair(self, node): - self.write(u'{') + self.write("{") self.visit(node.key) - self.write(u", ") + self.write(", ") self.visit(node.value) - self.write(u'}') + self.write("}") def visit_call(self, node): want_comma = [] @@ -1353,14 +1347,14 @@ def write_comma(): self.visit(node.function(node)) else: self.write(node.function) - self.write('(') + self.write("(") if isinstance(node.args, list): for arg in node.args: write_comma() self.visit(arg) else: self.visit(node.args) - self.write(')') + self.write(")") def visit_standard_call(self, node): ns = self.functions[node.namespace] @@ -1383,14 +1377,12 @@ def visit_importfrom(self, node): def visit_for_statement(self, node): self.newline(node) - self.write("for(") + self.write("for (") if "iterators" in dir(node): self.visit(node.iterators) if "sequences" in dir(node): self.visit(node.sequences) - self.write(')') - self.newline(node) - self.write('{') + self.write(") {") if "iterators" in dir(node): self.newline(node) self.indentation += 1 @@ -1399,10 +1391,11 @@ def visit_for_statement(self, node): self.body(node.block) self.newline(node) self.write('}') + self.newline(node) def visit_for_iterator_with_index(self, node): self.visit(node.index) - self.write(' , ') + self.write(', ') self.visit(node.iterator) def visit_for_sequence_with_index(self, node): @@ -1422,34 +1415,31 @@ def visit_for_range_statement(self, node): self.visit(node.index) self.write("=") self.visit(node.start) - self.write(' ; ') + self.write("; ") self.visit(node.index) self.write("!=") self.visit(node.end) - self.write(' ; ') + self.write("; ") self.visit(node.index) self.write("+=") if "value" in dir(node.step) and node.step.value == 1: self.write("1") else: self.visit(node.step) - self.write(')') - self.newline(node) - self.write('{') + self.write(") {") self.body(node.block) self.newline(node) - self.write('}') + self.write("}") + self.newline(node) def visit_while_statement(self, node): self.newline(node) - self.write('while ( ') + self.write("while ( ") self.visit(node.test) - self.write(')') - self.newline(node) - self.write('{') + self.write(") {") self.body_or_else(node) self.newline(node) - self.write('}') + self.write("}") class Cpp2Trans(Cpp2Generator):