Compatibility for older versions of cmake, python, open cascade, boost

src/ifcexpressparser/codegen.py

@@ -0,0 +1,34 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+class Base(object):
+    """
+    A base class for all code generation classes. Currently only working around
+    some python 2/3 incompatibilities in terms of unicode file handling.
+    """
+    def emit(self):
+        import platform
+        if tuple(map(int, platform.python_version_tuple())) < (2, 8):
+            from io import open as unicode_open
+        else:
+            unicode_open = open
+            unicode = lambda x, *args, **kwargs: x
+        f = unicode_open(self.file_name, 'w', encoding='utf-8')
+        f.write(unicode(repr(self), encoding='utf-8', errors='ignore'))
+        f.close()

src/ifcexpressparser/enum_header.py

@@ -18,8 +18,9 @@
 ###############################################################################
 
 import templates
+import codegen
 
-class EnumHeader:
+class EnumHeader(codegen.Base):
     def __init__(self, mapping):
         enumerable_types = sorted(set([name for name, type in mapping.schema.types.items()] + [name for name, type in mapping.schema.entities.items()]))
         
@@ -30,9 +31,9 @@ class EnumHeader:
         }
         
         self.schema_name = mapping.schema.name.capitalize()
+        
+        self.file_name = '%senum.h'%self.schema_name
+        
+        
     def __repr__(self):
         return self.str
-    def emit(self):
-        f = open('%senum.h'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()

src/ifcexpressparser/header.py

@@ -17,10 +17,11 @@
 #                                                                             #
 ###############################################################################
 
+import codegen
 import templates
 import documentation
 
-class Header:
+class Header(codegen.Base):
     def __init__(self, mapping):
         declarations = []
 
@@ -123,10 +124,9 @@ class Header:
         }
 
         self.schema_name = mapping.schema.name.capitalize()
+        
+        self.file_name = '%s.h'%self.schema_name
+        
+        
     def __repr__(self):
         return self.str
-    def emit(self):
-        f = open('%s.h'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()
-

src/ifcexpressparser/implementation.py

@@ -17,9 +17,10 @@
 #                                                                             #
 ###############################################################################
 
+import codegen
 import templates
 
-class Implementation:
+class Implementation(codegen.Base):
     def __init__(self, mapping):
         enumeration_functions = []
         entity_implementations = []
@@ -230,10 +231,9 @@ class Implementation:
         }
 
         self.schema_name = mapping.schema.name.capitalize()
+        
+        self.file_name = '%s.cpp'%self.schema_name
+        
+        
     def __repr__(self):
         return self.str
-    def emit(self):
-        f = open('%s.cpp'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()
-

src/ifcexpressparser/latebound_header.py

@@ -17,9 +17,10 @@
 #                                                                             #
 ###############################################################################
 
+import codegen
 import templates
 
-class LateBoundHeader:
+class LateBoundHeader(codegen.Base):
     def __init__(self, mapping):
         self.str = templates.lb_header % {
             'schema_name_upper' : mapping.schema.name.upper(),
@@ -27,9 +28,9 @@ class LateBoundHeader:
         }
         
         self.schema_name = mapping.schema.name.capitalize()
+        
+        self.file_name = '%s-latebound.h'%self.schema_name
+        
+        
     def __repr__(self):
         return self.str
-    def emit(self):
-        f = open('%s-latebound.h'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()

src/ifcexpressparser/latebound_implementation.py

@@ -17,9 +17,10 @@
 #                                                                             #
 ###############################################################################
 
+import codegen
 import templates
 
-class LateBoundImplementation:
+class LateBoundImplementation(codegen.Base):
     def __init__(self, mapping):
         schema_name = mapping.schema.name.capitalize()
         
@@ -110,10 +111,9 @@ class LateBoundImplementation:
         }
 
         self.schema_name = mapping.schema.name.capitalize()
+        
+        self.file_name = '%s-latebound.cpp'%self.schema_name
+        
+        
     def __repr__(self):
         return self.str
-    def emit(self):
-        f = open('%s-latebound.cpp'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()
-

src/ifcexpressparser/mapping.py

@@ -17,6 +17,8 @@
 #                                                                             #
 ###############################################################################
 
+from __future__ import print_function
+
 import sys
 import nodes
 import templates
@@ -33,11 +35,11 @@ class Mapping:
         'binary'  : 'boost::dynamic_bitset<>'
     }
     
-    supported_argument_types = {
+    supported_argument_types = set([
         'INT', 'BOOL', 'DOUBLE', 'STRING', 'BINARY', 'ENUMERATION', 'ENTITY_INSTANCE',
         'AGGREGATE_OF_INT', 'AGGREGATE_OF_DOUBLE', 'AGGREGATE_OF_STRING', 'AGGREGATE_OF_BINARY', 'AGGREGATE_OF_ENTITY_INSTANCE',
         'AGGREGATE_OF_AGGREGATE_OF_INT', 'AGGREGATE_OF_AGGREGATE_OF_DOUBLE', 'AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE',
-    }
+    ])
 
     def __init__(self, schema):
         self.schema = schema

src/ifcexpressparser/schema.py

@@ -18,8 +18,13 @@
 ###############################################################################
 
 import nodes
+import platform
 import collections
 
+if tuple(map(int, platform.python_version_tuple())) < (2, 7):
+    import ordereddict
+    collections.OrderedDict = ordereddict.OrderedDict
+
 class Schema:
     def is_enumeration(self, v):
         return str(v) in self.enumerations
@@ -34,12 +39,12 @@ class Schema:
     def __init__(self, parsetree):
         self.name = parsetree[1]
 
-        sort = lambda d: collections.OrderedDict(sorted(d.items()))
+        sort = lambda d: collections.OrderedDict(sorted(d))
 
-        self.types = sort({t.name:t for t in parsetree if isinstance(t, nodes.TypeDeclaration)})
-        self.entities = sort({t.name:t for t in parsetree if isinstance(t, nodes.EntityDeclaration)})
+        self.types = sort([(t.name,t) for t in parsetree if isinstance(t, nodes.TypeDeclaration)])
+        self.entities = sort([(t.name,t) for t in parsetree if isinstance(t, nodes.EntityDeclaration)])
 
-        of_type = lambda *types: sort({a: b.type.type for a,b in self.types.items() if any(isinstance(b.type.type, ty) for ty in types)})
+        of_type = lambda *types: sort([(a, b.type.type) for a,b in self.types.items() if any(isinstance(b.type.type, ty) for ty in types)])
 
         self.enumerations = of_type(nodes.EnumerationType)
         self.selects = of_type(nodes.SelectType)