Changeset 71c5f4d in sasmodels

Timestamp:

Dec 11, 2017 5:35:15 PM (7 years ago)

Author:

Omer Eisenberg <omereis@…>

Children:

e2719fc

Parents:

7f79cba

Message:

included constants in C. Fixed bug in C for loop

Files:

• .vscode/launch.json (added)
• err.txt (added)
• run.txt (added)
• run_c.bat (added)
• sasmodels/autoc.py (modified) (3 diffs)
• sasmodels/py2c.py (modified) (13 diffs)
• vcvarsall.bat (added)
• xlate.c (added)
• xlate.o (added)

sasmodels/autoc.py

@@ -10 +10 @@
 import numpy as np
 
-from . import codegen
+from . import py2c
 from . import special
 
@@ -129 +129 @@
 
     # translate source
-    functions = codegen.translate(
+    functions = py2c.translate(
         [code[name] for name in ordered_dag(depends) if name in code],
         constants)
@@ -136 +136 @@
     print("\n".join(snippets))
     #return
-    raise RuntimeError("not yet converted...")
+#    raise RuntimeError("not yet converted...")
 
     # update model info

sasmodels/py2c.py

@@ -48 +48 @@
 import ast
 import sys
+import os
 from ast import NodeVisitor
 
@@ -88 +89 @@
 
 #def to_source(node, indent_with=' ' * 4, add_line_information=False):
-def to_source(node, func_name):
+def to_source(node, func_name, global_vectors):
     """This function can convert a node tree back into python sourcecode.
     This is useful for debugging purposes, especially if you're dealing with
@@ -105 +106 @@
     of the nodes are added to the output.  This can be used to spot wrong line
     number information of statement nodes.
+
+    global_vectors arguments is a list of strings, holding the names of global
+    variables already declared as arrays
     """
+#    print(str(node))
+#    return
     generator = SourceGenerator(' ' * 4, False)
-    generator.required_functions = func_name
+    generator.global_vectors = global_vectors
+#    generator.required_functions = func_name
     generator.visit(node)
 
 #    return ''.join(generator.result)
     return ''.join(generator.c_proc)
+
+EXTREN_DOUBLE = "extern double "
+
+def get_c_array_value(val):
+    val_str = str(val).strip()
+    val_str = val_str.replace('[','')
+    val_str = val_str.replace(']','')
+    val_str = val_str.strip()
+    double_blank = "  " in val_str
+    while (double_blank):
+        val_str = val_str.replace('  ',' ')
+        double_blank = "  " in val_str
+    val_str = val_str.replace(' ',',')
+    return (val_str)
+
+def write_include_const (snippets, constants):
+    c_globals=[]
+    snippets.append("#include <math.h>\n")
+    const_names = constants.keys()
+    for name in const_names:
+        c_globals.append(name)
+        val = constants[name]
+        var_dcl = "double "# + " = "
+        if (hasattr(val, "__len__")): # the value is an array
+            val_str = get_c_array_value(val)
+            var_dcl += str(name) + "[] = {" + str(val_str) + "}"
+        else:
+            var_dcl += str(name) + " = " + str(val)
+        var_dcl += ";\n"
+        snippets.append(var_dcl)
+            
+    return (c_globals)
+#    for c_var in constants:
+#        sTmp = EXTREN_DOUBLE + str(c_var) + ";"
+#        c_externs.append (EXTREN_DOUBLE + c_var + ";")
+#    snippets.append (c_externs)
 
 def isevaluable(s):
@@ -154 +197 @@
         self.is_sequence = False
         self.visited_args = False
+        self.global_vectors = []
 
     def write_python(self, x):
@@ -342 +386 @@
         return (s)
 
+    def write_C_Pointers (self, start_var):
+        if (len (self.C_DclPointers) > 0):
+            vars = ""
+            for c_ptr in self.C_DclPointers:
+                if (len(vars) > 0):
+                    vars += ", "
+                if (c_ptr not in self.arguments):
+                    vars += "*" + c_ptr
+                if (c_ptr in self.C_Vars):
+                    if (c_ptr in self.C_Vars):
+                        self.C_Vars.remove (c_ptr)
+            if (len(vars) > 0):
+                c_dcl = "    double " + vars + ";"
+                self.c_proc.insert (start_var, c_dcl + "\n")
+                start_var += 1
+        return start_var
+
     def insert_C_Vars (self, start_var):
         fLine = False
@@ -372 +433 @@
                 self.c_proc.insert (start_var, c_dcl + "\n")
                 start_var += 1
-        if (len (self.C_DclPointers) > 0):
-            vars = ''
-            for n in range(len(self.C_DclPointers)):
-                if (len(vars) > 0):
-                    vars += ', '
-                vars += "*" + self.C_DclPointers[n]
-            if (len(vars) > 0):
-                c_dcl = "    double " + vars + ";"
-                self.c_proc.insert (start_var, c_dcl + "\n")
-                start_var += 1
         self.C_Vars.clear()
         self.C_IntVars.clear()
         self.C_Vectors.clear()
         self.C_Pointers.clear()
+        self.C_DclPointers.clear()
         if (fLine == True):
             self.c_proc.insert (start_var, "\n")
@@ -398 +450 @@
             self.c_proc.insert (start_var + 1, "\n")
 
-    def writeInclude (self):
-        if (self.MathIncludeed == False):
-            self.add_c_line("#include <math.h>\n")
-            self.add_c_line("static double pi = 3.14159265359;\n")
-            self.MathIncludeed = True
+#    def writeInclude (self):
+#        if (self.MathIncludeed == False):
+#            self.add_c_line("#include <math.h>\n")
+#            self.add_c_line("static double pi = 3.14159265359;\n")
+#            self.MathIncludeed = True
 
     def ListToString (self, strings):
@@ -431 +483 @@
                 args_str += ", "
         self.strMethodSignature = 'double ' + self.name + ' (' + args_str + ")"
-        if (self.signature_line > 0):
+        if (self.signature_line >= 0):
             self.c_proc.insert (self.signature_line, self.strMethodSignature)
 
@@ -440 +492 @@
         self.arguments = []
         self.name = node.name
-        if self.name not in self.required_functions[0]:
-            return
+#        if self.name not in self.required_functions[0]:
+#            return
         print("Parsing '" + self.name + "'")
         args_str = ""
@@ -447 +499 @@
         self.visit(node.args)
 # for C
-        self.writeInclude()
+#        self.writeInclude()
         self.getMethodSignature ()
 # for C
@@ -547 +599 @@
                     self.body_or_else(node)
                     self.write_c ("}")
+                    self.add_current_line () # just for breaking point. to be deleted. 
                     fForDone = True
         if (fForDone == False):
@@ -731 +784 @@
             name = node.id
 #       add variable to C_Vars if it ins't there yet, not an argument and not a number
-        if ((name not in self.C_Functions) and (name not in self.C_Vars) and (name not in self.C_IntVars) and (name not in self.arguments) and (name.isnumeric () == False)):
-            if (self.InSubscript):
-                self.C_IntVars.append (node.id)
-            else:
-                self.C_Vars.append (node.id)
+        if (name not in self.global_vectors):
+            if ((name not in self.C_Functions) and (name not in self.C_Vars) and (name not in self.C_IntVars) and (name not in self.arguments) and (name.isnumeric () == False)):
+                if (self.InSubscript):
+                    self.C_IntVars.append (node.id)
+                else:
+                    self.C_Vars.append (node.id)
 
     def visit_Str(self, node):
@@ -1023 +1077 @@
         print(tree_source)
 
-def translate (functions, constants=0):
+
+def write_consts (constants):
+    f = False
+    if (constants is not None):
+        f = True
+
+def translate(functions, constants):
+    # type: (List[Tuple[str, str, int]], Dict[str, Any]) -> str
+#    print ("Size of functions is: " + str(len(functions)))
+    if (os.path.exists ("xlate.c")):
+        os.remove("xlate.c")
+    snippets = []
+    global_vectors = write_include_const (snippets, constants)
+    const_keys = constants.keys ()
+    for source, filename, offset in functions:
+        tree = ast.parse(source)
+        snippet = to_source(tree, filename, global_vectors)#, offset)
+        snippets.append(snippet)
+    if (constants is not None):
+        write_consts (constants)
+    c_text = "\n".join(snippets)
+    try:
+        translated = open ("xlate.c", "a+")
+        translated.write (c_text)
+        translated.close()
+    except Exception as excp:
+        strErr = "Error:\n" + str(excp.args)
+        print(strErr)
+    return (c_text)
+
+def translate_from_file (functions, constants=0):
+    print ("Size of functions is: " + len(functions))
     sniplets = []
     fname = functions[1]