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

Author: EraYaN

transpyle/cpp/__init__.py

@@ -8,6 +8,9 @@
 
 __all__ = ['CppParser', 'CppAstGeneralizer', 'Cpp14Unparser', 'CppSwigCompiler']
 
+# Annotation to mark a class as a struct. (Python -> Cpp)
+def struct(f):
+    return f
 
 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,27 @@ def dispatch_type(self, type_hint):
             self.write('*')
             return
         if isinstance(type_hint, typed_ast3.Subscript):
-            _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
             self._unsupported_syntax(type_hint)
         if isinstance(type_hint, typed_ast3.Attribute):
             if isinstance(type_hint.value, typed_ast3.Name):
@@ -169,12 +189,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 +210,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,7 +244,10 @@ 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)
@@ -229,9 +263,14 @@ def _Pass(self, t):
 
     def _ClassDef(self, t):
         self.write('\n')
-        if t.decorator_list:
-            self._unsupported_syntax(t, 'with decorators')
-        self.fill('class {}'.format(t.name))
+        if len(t.decorator_list) > 1:
+            self._unsupported_syntax(t, 'with too many decorators')
+
+        if is_struct:
+            self.fill('struct {}'.format(t.name))
+        else:
+            self.fill('class {}'.format(t.name))
+
         if t.bases:
             _LOG.warning('C++: assuming base classes are inherited as public')
             self.write(': public ')
@@ -248,7 +287,7 @@ def _ClassDef(self, t):
                 else:
                     comma = True
                 self.dispatch(e)
-
+                
         self.enter()
         for stmt in t.body:
             if isinstance(stmt, typed_ast3.FunctionDef):
@@ -507,12 +546,44 @@ def _arg(self, t):
         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)
 
+    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))
 
 class Cpp14HeaderUnparserBackend(Cpp14UnparserBackend):