Merge branch 'sql-to-cpp' into cpp-unparsing-extensions

Author: EraYaN

transpyle/cpp/__init__.py

@@ -6,8 +6,14 @@
 from .unparser import Cpp14Unparser
 from .compiler import CppSwigCompiler
 
+<<<<<<< HEAD
 __all__ = ['CppParser', 'CppAstGeneralizer', 'Cpp14Unparser', 'CppSwigCompiler']
 
+=======
+# Annotation to mark a class as a struct. (Python -> Cpp)
+def struct(f):
+    return f
+>>>>>>> sql-to-cpp
 
 class CppBinder(Binder):
 

transpyle/cpp/unparser.py

@@ -101,7 +101,7 @@ def for_header_to_tuple(target, target_type, iter_) -> t.Tuple[
         init = typed_ast3.Assign(targets=[target], value=begin, type_comment=None)
     else:
         init = typed_ast3.AnnAssign(target=target, annotation=target_type, value=begin, simple=True)
-    condition = typed_ast3.Compare(left=target, ops=[typed_ast3.Lt()], comparators=[end])
+    condition = typed_ast3.Expr(typed_ast3.Compare(left=target, ops=[typed_ast3.Lt()], comparators=[end]))
     increment = typed_ast3.AugAssign(target=target, op=typed_ast3.Add(), value=step)
     return init, condition, increment
 
@@ -133,6 +133,7 @@ def _unsupported_syntax(self, syntax, comment: str = None):
         self.fill('! TODO: unsupported syntax')
         unparsing_unsupported('C++', syntax, comment)
 
+    # Misusing ast.Index to signify reference types. Should probably fork typed-ast or something. The ast generalizer does something string based.
     def dispatch_type(self, type_hint):
         _LOG.debug('dispatching type hint %s', type_hint)
         if is_generic_type(type_hint):
@@ -154,8 +155,32 @@ def dispatch_type(self, type_hint):
             self.write('*')
             return
         if isinstance(type_hint, typed_ast3.Subscript):
+<<<<<<< HEAD
             _LOG.error('encountered unsupported subscript form: %s',
                        horast.unparse(type_hint).strip())
+=======
+            if isinstance(type_hint.value, typed_ast3.Attribute) \
+                    and isinstance(type_hint.value.value, typed_ast3.Name):
+                unparsed = horast.unparse(type_hint.value).strip()
+                self.write(PY_TO_CPP_TYPES[unparsed])
+                if unparsed == 'st.ndarray':
+                    self.write('<')
+                    sli = type_hint.slice
+                    self.write('>')
+                return
+            elif isinstance(type_hint.value, typed_ast3.Name):
+                unparsed = horast.unparse(type_hint.value).strip()
+                self.write(unparsed)
+                self.write('<')
+                if isinstance(type_hint.slice, typed_ast3.Subscript):
+                    self.dispatch_type(type_hint.slice)
+                else:
+                    self.write(horast.unparse(type_hint.slice).strip())
+                self.write(' >')
+                if isinstance(type_hint.slice, typed_ast3.Index):
+                    self.write('&')
+                return
+>>>>>>> sql-to-cpp
             self._unsupported_syntax(type_hint)
         if isinstance(type_hint, typed_ast3.Attribute):
             if isinstance(type_hint.value, typed_ast3.Name):
@@ -169,12 +194,19 @@ def dispatch_type(self, type_hint):
             assert type_hint.value is None
             self.write('void')
             return
+
         self.dispatch(type_hint)
+        if isinstance(type_hint, typed_ast3.Index):
+            if isinstance(type_hint.value, typed_ast3.Name):
+                self.write('&')
 
     def _Expr(self, tree):
         super()._Expr(tree)
         self.write(';')
 
+    def _Pass(self, tree):
+        self.fill('/* pass */')
+
     def _Import(self, t):
         self.fill('/* Python import')
         # raise NotImplementedError('not supported yet')
@@ -183,7 +215,11 @@ def _Import(self, t):
         # #include "boost/multi_array.hpp"
 
     def _ImportFrom(self, t):
-        raise NotImplementedError('not supported yet')
+        self.fill('/* Python import')
+        # raise NotImplementedError('not supported yet')
+        super()._ImportFrom(t)
+        self.fill('*/')
+        # #include "boost/multi_array.hpp"
 
     def _Assign(self, t):
         if self._context != 'for header':
@@ -213,12 +249,19 @@ def _AnnAssign(self, t):
             self._unsupported_syntax(t, 'which is not simple')
         self.dispatch_type(t.annotation)
         self.write(' ')
-        self.dispatch(t.target)
+        try:
+            self.dispatch(t.target)
+        except AttributeError as e:
+            print(e)
         if t.value:
             self.write(' = ')
             self.dispatch(t.value)
+<<<<<<< HEAD
         if self._context != 'for header':
             self.write(';')
+=======
+        self.write(';')
+>>>>>>> sql-to-cpp
 
     def _Return(self, t):
         super()._Return(t)
@@ -228,6 +271,7 @@ def _Pass(self, t):
         self.fill(';')
 
     def _ClassDef(self, t):
+<<<<<<< HEAD
         self.write('\n')
         if t.decorator_list:
             self._unsupported_syntax(t, 'with decorators')
@@ -248,6 +292,25 @@ def _ClassDef(self, t):
                 else:
                     comma = True
                 self.dispatch(e)
+=======
+        if len(t.decorator_list) > 1:
+            self._unsupported_syntax(t, ' with decorators')
+        self.write('\n')
+        self.fill()
+        is_struct = False
+        if len(t.decorator_list) == 1:
+            is_struct = t.decorator_list[0].id=='struct'
+        if is_struct:
+            self.write('struct')
+        else:
+            self.write('class')
+
+        self.write(' {}'.format(t.name))
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+>>>>>>> sql-to-cpp
 
         self.enter()
         for stmt in t.body:
@@ -341,6 +404,7 @@ def _AsyncFunctionDef(self, t):
 
     def _For(self, t):
         self.fill('for (')
+<<<<<<< HEAD
         init, cond, increment = for_header_to_tuple(t.target, t.resolved_type_comment, t.iter)
         self._context = 'for header'
         self.dispatch(init)
@@ -349,6 +413,18 @@ def _For(self, t):
         self.write('; ')
         self.dispatch(increment)
         self._context = None
+=======
+        init, cond, increment = for_header_to_tuple(t.target, t.type_comment, t.iter)
+        #self.dispatch(init)
+        #self.dispatch(cond)
+        #self.dispatch(increment)
+        unparser = Cpp14Unparser()
+        self.write(unparser.unparse(init).strip('\n\r;)('))
+        self.write('; ')
+        self.write(unparser.unparse(cond).strip('\n\r;)('))
+        self.write('; ')
+        self.write(unparser.unparse(increment).strip('\n\r;)('))
+>>>>>>> sql-to-cpp
         # self.dispatch(t.iter)
         self.write(')')
         self.enter()
@@ -383,6 +459,11 @@ def _If(self, t):
             self.dispatch(t.orelse)
             self.leave()
 
+<<<<<<< HEAD
+=======
+        #raise NotImplementedError('not supported yet')
+
+>>>>>>> sql-to-cpp
     def _While(self, t):
         raise NotImplementedError('not supported yet')
 
@@ -446,6 +527,7 @@ def _Compare(self, compare):
 
     def _Attribute(self, t):
         if isinstance(t.value, typed_ast3.Name):
+<<<<<<< HEAD
             if t.value.id == 'self':
                 self.write('this')
                 self.write('->')
@@ -456,6 +538,22 @@ def _Attribute(self, t):
                 self._includes['cmath'] = True
             self.write(unparsed)
             return
+=======
+            try:
+                unparsed = {
+                    ('a', 'shape'): '???',
+                    ('b', 'shape'): '???',
+                    ('c', 'shape'): '???',
+                    ('np', 'single'): 'int32_t',
+                    ('np', 'double'): 'int64_t',
+                    ('np', 'zeros'): 'boost::multi_array',
+                    ('st', 'ndarray'): 'boost::multi_array'
+                    }[t.value.id, t.attr]
+                self.write(unparsed)
+                return
+            except Exception:
+                pass
+>>>>>>> sql-to-cpp
         self.dispatch(t.value)
         self.write('.')
         self.write(t.attr)
@@ -501,18 +599,57 @@ def _Call(self, t):
 
     def _arg(self, t):
         if t.annotation is None:
+<<<<<<< HEAD
             self._unsupported_syntax(t, 'without annotation')
+=======
+            self._unsupported_syntax(t, ' without annotation')
+>>>>>>> sql-to-cpp
         self.dispatch_type(t.annotation)
         self.write(' ')
         self.write(t.arg)
 
     def _Comment(self, node):
-        if node.eol:
-            self.write(' //')
+        if node.value.s.startswith("pragma"):
+            if node.eol:
+                self.write('\n#')
+            else:
+                self.fill('#')
         else:
-            self.fill('//')
+            if node.eol:
+                self.write(' //')
+            else:
+                self.fill('//')
         self.write(node.value.s)
 
+<<<<<<< HEAD
+=======
+    def _NameConstant(self, node):
+        if node.value == 'False':
+            self.write("false")
+        elif node.value == 'True':
+            self.write("true")
+        elif node.value == 'None':
+            self.write("null")
+        else:
+            self.write(node.value)
+
+    def _Str(self, node):
+        self.write('"')
+        self.write(node.s.replace('"', '\\"').replace("\0", "\\0").replace("\n", "\\n").replace("\t", "\\t").replace("\r", "\\r"))
+        self.write('"')
+
+    def _Bytes(self, node):
+        # Char
+        if len(node.s) == 1:
+            self.write("'")
+            self.write(node.s.replace("'", "\\'").replace("\0", "\\0").replace("\n", "\\n").replace("\t", "\\t").replace("\r", "\\r"))
+            self.write("'")
+        else:
+            self._Str(node)
+
+    def _unsupported_syntax(self, tree, comment: str = ''):
+        raise SyntaxError('unparsing {}{} to C++ is not supported'.format(type(tree), comment))
+>>>>>>> sql-to-cpp
 
 class Cpp14HeaderUnparserBackend(Cpp14UnparserBackend):