vil02 · vil02 · Dec 29, 2022 · Dec 29, 2022 · Dec 29, 2022 · Dec 29, 2022
diff --git a/string_to_code/core.py b/string_to_code/core.py
@@ -114,6 +114,13 @@ def initial_call_str(self, in_atom_to_str, in_function_call_to_str):
             res = in_function_call_to_str(self.initial_call.function_name)
         return res
 
+    def needed_function_definitions_str_list(self, in_function_to_str):
+        """
+        returns a list of string representations of the definition of
+        the needed functions
+        """
+        return [in_function_to_str(_) for _ in self.needed_functions]
+
     def needed_function_definitions_str(
         self, in_function_to_str, in_definition_separator="\n\n"
     ):
@@ -122,7 +129,7 @@ def needed_function_definitions_str(
         the needed functions
         """
         return in_definition_separator.join(
-            in_function_to_str(_) for _ in self.needed_functions
+            self.needed_function_definitions_str_list(in_function_to_str)
         )
 
     @property

diff --git a/string_to_code/to_cpp.py b/string_to_code/to_cpp.py
@@ -2,6 +2,7 @@
 provides string_to_cpp utilities
 """
 from . import core
+from . import utils
 
 
 def atom_to_code(in_atom):
@@ -26,51 +27,48 @@ def function_call_str(in_function_name):
     return f"{in_function_name}();"
 
 
-def function_to_code(in_function):
+def _proc_single_body_line(in_line_data):
+    if isinstance(in_line_data, core.Atom):
+        res = atom_to_code(in_line_data)
+    else:
+        res = function_call_str(in_line_data.function_name)
+    return "    " + res
+
+
+def function_to_code(in_function, function_prefix="inline void"):
     """
     returns a string representing the code of the function definiton in C++
     """
     assert isinstance(in_function, core.SimpleFunction)
 
-    def proc_single_body_line(in_line_data):
-        if isinstance(in_line_data, core.Atom):
-            res = atom_to_code(in_line_data)
-        else:
-            res = function_call_str(in_line_data.function_name)
-        return "    " + res
-
     function_body = "\n".join(
-        proc_single_body_line(_) for _ in in_function.called_list
+        _proc_single_body_line(_) for _ in in_function.called_list
     )
 
-    return "\n".join(
-        [f"inline void {in_function.function_name}()", "{", function_body, "}"]
+    res = "\n".join(
+        [
+            f"{function_prefix} {in_function.function_name}()",
+            "{",
+            function_body,
+            "}",
+        ]
     )
+    return res
 
 
-def proc(in_str, gen_function_names=None):
-    """
-    returns a C++ code printing in_str to the standard output
-    """
-    if gen_function_names is None:
-        gen_function_names = core.gen_function_names()
+def _main_call_to_code(in_initial_call):
+    function_body = [in_initial_call] if in_initial_call is not None else []
+    main_function = core.SimpleFunction("main", function_body)
+    return function_to_code(main_function, "int")
 
-    printer_program = core.get_printer_program(in_str, gen_function_names)
-    function_definitions = printer_program.needed_function_definitions_str(
-        function_to_code, "\n\n\n"
-    )
-    if function_definitions:
-        function_definitions = function_definitions + "\n\n"
-    call_in_main_str = printer_program.initial_call_str(
-        atom_to_code, function_call_str
-    )
-    if call_in_main_str:
-        call_in_main_str = "\n    " + call_in_main_str
 
-    res = function_definitions + "\n".join(
-        ["int main()", "{" + call_in_main_str, "    return 0;", "}", ""]
-    )
-    if call_in_main_str:
-        assert "std::putchar" in res
+def _join_to_final(main_call, function_definitions):
+    res = "\n\n".join(function_definitions + [main_call]) + "\n"
+    if function_definitions or "std::putchar" in main_call:
         res = "#include <cstdio>\n\n" + res
     return res
+
+
+proc = utils.get_proc_function(
+    _main_call_to_code, function_to_code, _join_to_final
+)
diff --git a/string_to_code/utils.py b/string_to_code/utils.py
@@ -0,0 +1,23 @@
+"""
+utilities for to_some_language modules
+"""
+
+from . import core
+
+
+def get_proc_function(main_call_to_code, function_to_code, join_to_final):
+    """returns the proc function"""
+
+    def inner(in_str, gen_function_names=None, **kwargs):
+        if gen_function_names is None:
+            gen_function_names = core.gen_function_names()
+        printer_program = core.get_printer_program(in_str, gen_function_names)
+        main_call = main_call_to_code(printer_program.initial_call)
+        function_definitions = (
+            printer_program.needed_function_definitions_str_list(
+                function_to_code
+            )
+        )
+        return join_to_final(main_call, function_definitions, **kwargs)
+
+    return inner