Fix Python 3 language issues and add an explicit check for Python version == 2.

[jbcoe]

Summary

Python bindings cannot support Python 3 without work being done to fix Unicode c-string conversion.

This was attempted in https://reviews.llvm.org/D26082. That patch was reverted due to memory access issues on Linux.

This revision fixes enough language compatibility issues for the clang module to be loaded and raise an error if the Python version is not 2.

[rengolin]

Adding the two reviewers that were on the original patch for safety.

[jbcoe]

Fix typo in comment.

[rengolin]

Ping. Would be good to decide this for 4.0 RC1

[compnerd]

The change beyond the one comment looks good. Its unfortunate that the the string handling in python forces us to prevent the module from being loaded in python3. I mentioned one approach to @jbcoe that I think could work:

We run 2to3 on the source and install both with a suffixed name, switching the imported version based on sys.version[0].

bindings/python/clang/__init__.py

27 ↗

(On Diff #84324)

ouch ... this makes my head hurt. Is this even supported? *If* it works, I think it may be an accident of the lexer/parser implementation in python. Please rewrite this as:

import sys
if sys.version_info[0] != 2:
  raise Exception("only python 2 is supported.")

[jbcoe]

Fix whitespace errors induced by comment formatting.

[rengolin]

Jonathan,

After this is approved and committed, please create a bug in bugzilla against the 4.0 back-ports (and CC me), so that Hans can collect it into the release.

thanks,
--renato

[jbcoe]

Added bug https://llvm.org/bugs/show_bug.cgi?id=31673

cfe/trunk/bindings/python/clang/__init__.py

 
 The available modules are:
 
   cindex
 
     Bindings for the Clang indexing library.
 """
 
+
+# Python 3 uses unicode for strings. The bindings, in particular the interaction
+# with ctypes, need modifying to handle conversions between unicode and
+# c-strings.
+import sys 
+if sys.version_info[0] != 2: 
+    raise Exception("Only Python 2 is supported.")
+
 __all__ = ['cindex']
 

cfe/trunk/bindings/python/clang/cindex.py

class BaseEnumeration(object):
     respectively.
 
     """
 
     def __init__(self, value):
         if value >= len(self.__class__._kinds):
             self.__class__._kinds += [None] * (value - len(self.__class__._kinds) + 1)
         if self.__class__._kinds[value] is not None:
-            raise ValueError,'{0} value {1} already loaded'.format(
-                str(self.__class__), value)
+            raise ValueError('{0} value {1} already loaded'.format(
+                str(self.__class__), value))
         self.value = value
         self.__class__._kinds[value] = self
         self.__class__._name_map = None
 
 
     def from_param(self):
         return self.value
 
     @property
     def name(self):
         """Get the enumeration name of this cursor kind."""
         if self._name_map is None:
             self._name_map = {}
             for key, value in self.__class__.__dict__.items():
                 if isinstance(value, self.__class__):
                     self._name_map[value] = key
         return self._name_map[self]
 
     @classmethod
     def from_id(cls, id):
         if id >= len(cls._kinds) or cls._kinds[id] is None:
-            raise ValueError,'Unknown template argument kind %d' % id
+            raise ValueError('Unknown template argument kind %d' % id)
         return cls._kinds[id]
 
     def __repr__(self):
         return '%s.%s' % (self.__class__, self.name,)
 
 
 class CursorKind(BaseEnumeration):
     """
class StorageClass(object):
     # The unique kind objects, index by id.
     _kinds = []
     _name_map = None
 
     def __init__(self, value):
         if value >= len(StorageClass._kinds):
             StorageClass._kinds += [None] * (value - len(StorageClass._kinds) + 1)
         if StorageClass._kinds[value] is not None:
-            raise ValueError,'StorageClass already loaded'
+            raise ValueError('StorageClass already loaded')
         self.value = value
         StorageClass._kinds[value] = self
         StorageClass._name_map = None
 
     def from_param(self):
         return self.value
 
     @property
     def name(self):
         """Get the enumeration name of this storage class."""
         if self._name_map is None:
             self._name_map = {}
             for key,value in StorageClass.__dict__.items():
                 if isinstance(value,StorageClass):
                     self._name_map[value] = key
         return self._name_map[self]
 
     @staticmethod
     def from_id(id):
         if id >= len(StorageClass._kinds) or not StorageClass._kinds[id]:
-            raise ValueError,'Unknown storage class %d' % id
+            raise ValueError('Unknown storage class %d' % id)
         return StorageClass._kinds[id]
 
     def __repr__(self):
         return 'StorageClass.%s' % (self.name,)
 
 StorageClass.INVALID = StorageClass(0)
 StorageClass.NONE = StorageClass(1)
 StorageClass.EXTERN = StorageClass(2)
def reparse(self, unsaved_files=None, options=0):
         unsaved_files_array = 0
         if len(unsaved_files):
             unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()
             for i,(name,value) in enumerate(unsaved_files):
                 if not isinstance(value, str):
                     # FIXME: It would be great to support an efficient version
                     # of this, one day.
                     value = value.read()
-                    print value
+                    print(value)
                 if not isinstance(value, str):
-                    raise TypeError,'Unexpected unsaved file contents.'
+                    raise TypeError('Unexpected unsaved file contents.')
                 unsaved_files_array[i].name = name
                 unsaved_files_array[i].contents = value
                 unsaved_files_array[i].length = len(value)
         ptr = conf.lib.clang_reparseTranslationUnit(self, len(unsaved_files),
                 unsaved_files_array, options)
 
     def save(self, filename):
         """Saves the TranslationUnit to a file.
def codeComplete(self, path, line, column, unsaved_files=None,
         unsaved_files_array = 0
         if len(unsaved_files):
             unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()
             for i,(name,value) in enumerate(unsaved_files):
                 if not isinstance(value, str):
                     # FIXME: It would be great to support an efficient version
                     # of this, one day.
                     value = value.read()
-                    print value
+                    print(value)
                 if not isinstance(value, str):
-                    raise TypeError,'Unexpected unsaved file contents.'
+                    raise TypeError('Unexpected unsaved file contents.')
                 unsaved_files_array[i].name = name
                 unsaved_files_array[i].contents = value
                 unsaved_files_array[i].length = len(value)
         ptr = conf.lib.clang_codeCompleteAt(self, path, line, column,
                 unsaved_files_array, len(unsaved_files), options)
         if ptr:
             return CodeCompletionResults(ptr)
         return None