Diff 76854

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

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
#		#
# o cleanup ctypes wrapping, would be nice to separate the ctypes details more		# o cleanup ctypes wrapping, would be nice to separate the ctypes details more
# clearly, and hide from the external interface (i.e., help(cindex)).		# clearly, and hide from the external interface (i.e., help(cindex)).
#		#
# o implement additional SourceLocation, SourceRange, and File methods.		# o implement additional SourceLocation, SourceRange, and File methods.

from ctypes import *		from ctypes import *
import collections		import collections
		import sys

import clang.enumerations		import clang.enumerations

# ctypes doesn't implicitly convert c_void_p to the appropriate wrapper		# ctypes doesn't implicitly convert c_void_p to the appropriate wrapper
# object. This is a problem, because it means that from_parameter will see an		# object. This is a problem, because it means that from_parameter will see an
# integer and pass the wrong value on platforms where int != void*. Work around		# integer and pass the wrong value on platforms where int != void*. Work around
# this by marshalling object arguments as void**.		# this by marshalling object arguments as void**.
c_object_p = POINTER(c_void_p)		c_object_p = POINTER(c_void_p)

		if sys.version_info[0] > 2:
		# Python 3 strings are unicode, translate them to/from utf8 for C-interop
		# Python 3 replaces xrange with range, we want xrange behaviour
		xrange = range

		class c_string_p(c_char_p):
		def __init__(self, p=None):
		if type(p) == str:
		p = p.encode("utf8")
		super(c_char_p, self).__init__(p)

		def __str__(self):
		return str(self.value)

		@property
		def value(self):
		if super(c_char_p, self).value is None:
		return None
		return super(c_char_p, self).value.decode("utf8")

		@classmethod
		def from_param(cls, param):
		return cls(param)
		else:
		c_string_p = c_char_p


callbacks = {}		callbacks = {}

### Exception Classes ###		### Exception Classes ###

class TranslationUnitLoadError(Exception):		class TranslationUnitLoadError(Exception):
"""Represents an error that occurred when loading a TranslationUnit.		"""Represents an error that occurred when loading a TranslationUnit.

This is raised in the case where a TranslationUnit could not be		This is raised in the case where a TranslationUnit could not be
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	def __get__(self, instance, instance_type=None):
setattr(instance, self.wrapped.__name__, value)		setattr(instance, self.wrapped.__name__, value)

return value		return value


class _CXString(Structure):		class _CXString(Structure):
"""Helper for transforming CXString results."""		"""Helper for transforming CXString results."""

_fields_ = [("spelling", c_char_p), ("free", c_int)]		_fields_ = [("spelling", c_string_p), ("free", c_int)]

def __del__(self):		def __del__(self):
conf.lib.clang_disposeString(self)		conf.lib.clang_disposeString(self)

@staticmethod		@staticmethod
def from_result(res, fn, args):		def from_result(res, fn, args):
assert isinstance(res, _CXString)		assert isinstance(res, _CXString)
return conf.lib.clang_getCString(res)		return conf.lib.clang_getCString(res)
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines	def severity(self):
return conf.lib.clang_getDiagnosticSeverity(self)		return conf.lib.clang_getDiagnosticSeverity(self)

@property		@property
def location(self):		def location(self):
return conf.lib.clang_getDiagnosticLocation(self)		return conf.lib.clang_getDiagnosticLocation(self)

@property		@property
def spelling(self):		def spelling(self):
return conf.lib.clang_getDiagnosticSpelling(self)		return str(conf.lib.clang_getDiagnosticSpelling(self))

@property		@property
def ranges(self):		def ranges(self):
class RangeIterator:		class RangeIterator:
def __init__(self, diag):		def __init__(self, diag):
self.diag = diag		self.diag = diag

def __len__(self):		def __len__(self):
Show All 12 Lines	def fixits(self):
def __init__(self, diag):		def __init__(self, diag):
self.diag = diag		self.diag = diag

def __len__(self):		def __len__(self):
return int(conf.lib.clang_getDiagnosticNumFixIts(self.diag))		return int(conf.lib.clang_getDiagnosticNumFixIts(self.diag))

def __getitem__(self, key):		def __getitem__(self, key):
range = SourceRange()		range = SourceRange()
value = conf.lib.clang_getDiagnosticFixIt(self.diag, key,		value = str(conf.lib.clang_getDiagnosticFixIt(self.diag, key,
byref(range))		byref(range)))
if len(value) == 0:		if len(value) == 0:
raise IndexError		raise IndexError

return FixIt(range, value)		return FixIt(range, value)

return FixItIterator(self)		return FixItIterator(self)

@property		@property
Show All 16 Lines	class Diagnostic(object):
@property		@property
def category_number(self):		def category_number(self):
"""The category number for this diagnostic or 0 if unavailable."""		"""The category number for this diagnostic or 0 if unavailable."""
return conf.lib.clang_getDiagnosticCategory(self)		return conf.lib.clang_getDiagnosticCategory(self)

@property		@property
def category_name(self):		def category_name(self):
"""The string name of the category for this diagnostic."""		"""The string name of the category for this diagnostic."""
return conf.lib.clang_getDiagnosticCategoryText(self)		return str(conf.lib.clang_getDiagnosticCategoryText(self))

@property		@property
def option(self):		def option(self):
"""The command-line option that enables this diagnostic."""		"""The command-line option that enables this diagnostic."""
return conf.lib.clang_getDiagnosticOption(self, None)		return str(conf.lib.clang_getDiagnosticOption(self, None))

@property		@property
def disable_option(self):		def disable_option(self):
"""The command-line option that disables this diagnostic."""		"""The command-line option that disables this diagnostic."""
disable = _CXString()		disable = _CXString()
conf.lib.clang_getDiagnosticOption(self, byref(disable))		conf.lib.clang_getDiagnosticOption(self, byref(disable))

return conf.lib.clang_getCString(disable)		return str(conf.lib.clang_getCString(disable))

def format(self, options=None):		def format(self, options=None):
"""		"""
Format this diagnostic for display. The options argument takes		Format this diagnostic for display. The options argument takes
Diagnostic.Display* flags, which can be combined using bitwise OR. If		Diagnostic.Display* flags, which can be combined using bitwise OR. If
the options argument is not provided, the default display options will		the options argument is not provided, the default display options will
be used.		be used.
"""		"""
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines	class BaseEnumeration(object):
respectively.		respectively.

"""		"""

def __init__(self, value):		def __init__(self, value):
if value >= len(self.__class__._kinds):		if value >= len(self.__class__._kinds):
self.__class__._kinds += [None] * (value - len(self.__class__._kinds) + 1)		self.__class__._kinds += [None] * (value - len(self.__class__._kinds) + 1)
if self.__class__._kinds[value] is not None:		if self.__class__._kinds[value] is not None:
raise ValueError,'{0} value {1} already loaded'.format(		raise ValueError('{0} value {1} already loaded'.format(
str(self.__class__), value)		str(self.__class__), value))
self.value = value		self.value = value
self.__class__._kinds[value] = self		self.__class__._kinds[value] = self
self.__class__._name_map = None		self.__class__._name_map = None


def from_param(self):		def from_param(self):
return self.value		return self.value

@property		@property
def name(self):		def name(self):
"""Get the enumeration name of this cursor kind."""		"""Get the enumeration name of this cursor kind."""
if self._name_map is None:		if self._name_map is None:
self._name_map = {}		self._name_map = {}
for key, value in self.__class__.__dict__.items():		for key, value in self.__class__.__dict__.items():
if isinstance(value, self.__class__):		if isinstance(value, self.__class__):
self._name_map[value] = key		self._name_map[value] = key
return self._name_map[self]		return str(self._name_map[self])

@classmethod		@classmethod
def from_id(cls, id):		def from_id(cls, id):
if id >= len(cls._kinds) or cls._kinds[id] is None:		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]		return cls._kinds[id]

def __repr__(self):		def __repr__(self):
return '%s.%s' % (self.__class__, self.name,)		return '%s.%s' % (self.__class__, self.name,)


class CursorKind(BaseEnumeration):		class CursorKind(BaseEnumeration):
"""		"""
A CursorKind describes the kind of entity that a cursor points to.		A CursorKind describes the kind of entity that a cursor points to.
"""		"""

# The required BaseEnumeration declarations.		# The required BaseEnumeration declarations.
_kinds = []		_kinds = []
_name_map = None		_name_map = None

@staticmethod		@staticmethod
def get_all_kinds():		def get_all_kinds():
"""Return all CursorKind enumeration instances."""		"""Return all CursorKind enumeration instances."""
return filter(None, CursorKind._kinds)		return [x for x in CursorKind._kinds if x]

def is_declaration(self):		def is_declaration(self):
"""Test if this is a declaration kind."""		"""Test if this is a declaration kind."""
return conf.lib.clang_isDeclaration(self)		return conf.lib.clang_isDeclaration(self)

def is_reference(self):		def is_reference(self):
"""Test if this is a reference kind."""		"""Test if this is a reference kind."""
return conf.lib.clang_isReference(self)		return conf.lib.clang_isReference(self)
▲ Show 20 Lines • Show All 814 Lines • ▼ Show 20 Lines	class Cursor(Structure):
def kind(self):		def kind(self):
"""Return the kind of this cursor."""		"""Return the kind of this cursor."""
return CursorKind.from_id(self._kind_id)		return CursorKind.from_id(self._kind_id)

@property		@property
def spelling(self):		def spelling(self):
"""Return the spelling of the entity pointed at by the cursor."""		"""Return the spelling of the entity pointed at by the cursor."""
if not hasattr(self, '_spelling'):		if not hasattr(self, '_spelling'):
self._spelling = conf.lib.clang_getCursorSpelling(self)		self._spelling = str(conf.lib.clang_getCursorSpelling(self))

return self._spelling		return str(self._spelling)

@property		@property
def displayname(self):		def displayname(self):
"""		"""
Return the display name for the entity referenced by this cursor.		Return the display name for the entity referenced by this cursor.

The display name contains extra information that helps identify the		The display name contains extra information that helps identify the
cursor, such as the parameters of a function or template or the		cursor, such as the parameters of a function or template or the
arguments of a class template specialization.		arguments of a class template specialization.
"""		"""
if not hasattr(self, '_displayname'):		if not hasattr(self, '_displayname'):
self._displayname = conf.lib.clang_getCursorDisplayName(self)		self._displayname = str(conf.lib.clang_getCursorDisplayName(self))

return self._displayname		return self._displayname

@property		@property
def mangled_name(self):		def mangled_name(self):
"""Return the mangled name for the entity referenced by this cursor."""		"""Return the mangled name for the entity referenced by this cursor."""
if not hasattr(self, '_mangled_name'):		if not hasattr(self, '_mangled_name'):
self._mangled_name = conf.lib.clang_Cursor_getMangling(self)		self._mangled_name = str(conf.lib.clang_Cursor_getMangling(self))

return self._mangled_name		return self._mangled_name

@property		@property
def location(self):		def location(self):
"""		"""
Return the source location (the starting character) of the entity		Return the source location (the starting character) of the entity
pointed at by the cursor.		pointed at by the cursor.
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines	class Cursor(Structure):

@property		@property
def objc_type_encoding(self):		def objc_type_encoding(self):
"""Return the Objective-C type encoding as a str."""		"""Return the Objective-C type encoding as a str."""
if not hasattr(self, '_objc_type_encoding'):		if not hasattr(self, '_objc_type_encoding'):
self._objc_type_encoding = \		self._objc_type_encoding = \
conf.lib.clang_getDeclObjCTypeEncoding(self)		conf.lib.clang_getDeclObjCTypeEncoding(self)

return self._objc_type_encoding		return str(self._objc_type_encoding)

@property		@property
def hash(self):		def hash(self):
"""Returns a hash of the cursor as an int."""		"""Returns a hash of the cursor as an int."""
if not hasattr(self, '_hash'):		if not hasattr(self, '_hash'):
self._hash = conf.lib.clang_hashCursor(self)		self._hash = conf.lib.clang_hashCursor(self)

return self._hash		return self._hash
Show All 30 Lines	def referenced(self):
if not hasattr(self, '_referenced'):		if not hasattr(self, '_referenced'):
self._referenced = conf.lib.clang_getCursorReferenced(self)		self._referenced = conf.lib.clang_getCursorReferenced(self)

return self._referenced		return self._referenced

@property		@property
def brief_comment(self):		def brief_comment(self):
"""Returns the brief comment text associated with that Cursor"""		"""Returns the brief comment text associated with that Cursor"""
return conf.lib.clang_Cursor_getBriefCommentText(self)		r = conf.lib.clang_Cursor_getBriefCommentText(self)
		if not r:
		return None
		return str(r)

@property		@property
def raw_comment(self):		def raw_comment(self):
"""Returns the raw comment text associated with that Cursor"""		"""Returns the raw comment text associated with that Cursor"""
return conf.lib.clang_Cursor_getRawCommentText(self)		r = conf.lib.clang_Cursor_getRawCommentText(self)
		if not r:
		return None
		return str(r)

def get_arguments(self):		def get_arguments(self):
"""Return an iterator for accessing the arguments of this cursor."""		"""Return an iterator for accessing the arguments of this cursor."""
num_args = conf.lib.clang_Cursor_getNumArguments(self)		num_args = conf.lib.clang_Cursor_getNumArguments(self)
for i in range(0, num_args):		for i in xrange(0, num_args):
yield conf.lib.clang_Cursor_getArgument(self, i)		yield conf.lib.clang_Cursor_getArgument(self, i)

def get_num_template_arguments(self):		def get_num_template_arguments(self):
"""Returns the number of template args associated with this cursor."""		"""Returns the number of template args associated with this cursor."""
return conf.lib.clang_Cursor_getNumTemplateArguments(self)		return conf.lib.clang_Cursor_getNumTemplateArguments(self)

def get_template_argument_kind(self, num):		def get_template_argument_kind(self, num):
"""Returns the TemplateArgumentKind for the indicated template		"""Returns the TemplateArgumentKind for the indicated template
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines	class StorageClass(object):
# The unique kind objects, index by id.		# The unique kind objects, index by id.
_kinds = []		_kinds = []
_name_map = None		_name_map = None

def __init__(self, value):		def __init__(self, value):
if value >= len(StorageClass._kinds):		if value >= len(StorageClass._kinds):
StorageClass._kinds += [None] * (value - len(StorageClass._kinds) + 1)		StorageClass._kinds += [None] * (value - len(StorageClass._kinds) + 1)
if StorageClass._kinds[value] is not None:		if StorageClass._kinds[value] is not None:
raise ValueError,'StorageClass already loaded'		raise ValueError('StorageClass already loaded')
self.value = value		self.value = value
StorageClass._kinds[value] = self		StorageClass._kinds[value] = self
StorageClass._name_map = None		StorageClass._name_map = None

def from_param(self):		def from_param(self):
return self.value		return self.value

@property		@property
def name(self):		def name(self):
"""Get the enumeration name of this storage class."""		"""Get the enumeration name of this storage class."""
if self._name_map is None:		if self._name_map is None:
self._name_map = {}		self._name_map = {}
for key,value in StorageClass.__dict__.items():		for key,value in StorageClass.__dict__.items():
if isinstance(value,StorageClass):		if isinstance(value,StorageClass):
self._name_map[value] = key		self._name_map[value] = key
return self._name_map[self]		return self._name_map[self]

@staticmethod		@staticmethod
def from_id(id):		def from_id(id):
if id >= len(StorageClass._kinds) or not StorageClass._kinds[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]		return StorageClass._kinds[id]

def __repr__(self):		def __repr__(self):
return 'StorageClass.%s' % (self.name,)		return 'StorageClass.%s' % (self.name,)

StorageClass.INVALID = StorageClass(0)		StorageClass.INVALID = StorageClass(0)
StorageClass.NONE = StorageClass(1)		StorageClass.NONE = StorageClass(1)
StorageClass.EXTERN = StorageClass(2)		StorageClass.EXTERN = StorageClass(2)
Show All 36 Lines	class TypeKind(BaseEnumeration):

# The unique kind objects, indexed by id.		# The unique kind objects, indexed by id.
_kinds = []		_kinds = []
_name_map = None		_name_map = None

@property		@property
def spelling(self):		def spelling(self):
"""Retrieve the spelling of this TypeKind."""		"""Retrieve the spelling of this TypeKind."""
return conf.lib.clang_getTypeKindSpelling(self.value)		return str(conf.lib.clang_getTypeKindSpelling(self.value))

def __repr__(self):		def __repr__(self):
return 'TypeKind.%s' % (self.name,)		return 'TypeKind.%s' % (self.name,)

TypeKind.INVALID = TypeKind(0)		TypeKind.INVALID = TypeKind(0)
TypeKind.UNEXPOSED = TypeKind(1)		TypeKind.UNEXPOSED = TypeKind(1)
TypeKind.VOID = TypeKind(2)		TypeKind.VOID = TypeKind(2)
TypeKind.BOOL = TypeKind(3)		TypeKind.BOOL = TypeKind(3)
▲ Show 20 Lines • Show All 259 Lines • ▼ Show 20 Lines	def get_size(self):
Retrieve the size of the record.		Retrieve the size of the record.
"""		"""
return conf.lib.clang_Type_getSizeOf(self)		return conf.lib.clang_Type_getSizeOf(self)

def get_offset(self, fieldname):		def get_offset(self, fieldname):
"""		"""
Retrieve the offset of a field in the record.		Retrieve the offset of a field in the record.
"""		"""
return conf.lib.clang_Type_getOffsetOf(self, c_char_p(fieldname))		return conf.lib.clang_Type_getOffsetOf(self, fieldname)

def get_ref_qualifier(self):		def get_ref_qualifier(self):
"""		"""
Retrieve the ref-qualifier of the type.		Retrieve the ref-qualifier of the type.
"""		"""
return RefQualifierKind.from_id(		return RefQualifierKind.from_id(
conf.lib.clang_Type_getCXXRefQualifier(self))		conf.lib.clang_Type_getCXXRefQualifier(self))

Show All 10 Lines	def get_fields(self):
fields = []		fields = []
conf.lib.clang_Type_visitFields(self,		conf.lib.clang_Type_visitFields(self,
callbacks['fields_visit'](visitor), fields)		callbacks['fields_visit'](visitor), fields)
return iter(fields)		return iter(fields)

@property		@property
def spelling(self):		def spelling(self):
"""Retrieve the spelling of this Type."""		"""Retrieve the spelling of this Type."""
return conf.lib.clang_getTypeSpelling(self)		return str(conf.lib.clang_getTypeSpelling(self))

def __eq__(self, other):		def __eq__(self, other):
if type(other) != type(self):		if type(other) != type(self):
return False		return False

return conf.lib.clang_equalTypes(self, other)		return conf.lib.clang_equalTypes(self, other)

def __ne__(self, other):		def __ne__(self, other):
Show All 15 Lines	def __init__(self, obj):
self.obj = self._as_parameter_ = obj		self.obj = self._as_parameter_ = obj

def from_param(self):		def from_param(self):
return self._as_parameter_		return self._as_parameter_


class _CXUnsavedFile(Structure):		class _CXUnsavedFile(Structure):
"""Helper for passing unsaved file arguments."""		"""Helper for passing unsaved file arguments."""
_fields_ = [("name", c_char_p), ("contents", c_char_p), ('length', c_ulong)]		_fields_ = [("name", c_string_p), ("contents", c_string_p), ('length', c_ulong)]

# Functions calls through the python interface are rather slow. Fortunately,		# Functions calls through the python interface are rather slow. Fortunately,
# for most symboles, we do not need to perform a function call. Their spelling		# for most symboles, we do not need to perform a function call. Their spelling
# never changes and is consequently provided by this spelling cache.		# never changes and is consequently provided by this spelling cache.
SpellingCache = {		SpellingCache = {
# 0: CompletionChunk.Kind("Optional"),		# 0: CompletionChunk.Kind("Optional"),
# 1: CompletionChunk.Kind("TypedText"),		# 1: CompletionChunk.Kind("TypedText"),
# 2: CompletionChunk.Kind("Text"),		# 2: CompletionChunk.Kind("Text"),
Show All 29 Lines	class Kind:
return "<ChunkKind: %s>" % self		return "<ChunkKind: %s>" % self

def __init__(self, completionString, key):		def __init__(self, completionString, key):
self.cs = completionString		self.cs = completionString
self.key = key		self.key = key
self.__kindNumberCache = -1		self.__kindNumberCache = -1

def __repr__(self):		def __repr__(self):
return "{'" + self.spelling + "', " + str(self.kind) + "}"		return "{'" + str(self.spelling) + "', " + str(self.kind) + "}"

@CachedProperty		@CachedProperty
def spelling(self):		def spelling(self):
if self.__kindNumber in SpellingCache:		if self.__kindNumber in SpellingCache:
return SpellingCache[self.__kindNumber]		return SpellingCache[self.__kindNumber]
return conf.lib.clang_getCompletionChunkText(self.cs, self.key).spelling		return conf.lib.clang_getCompletionChunkText(self.cs, self.key).spelling

# We do not use @CachedProperty here, as the manual implementation is		# We do not use @CachedProperty here, as the manual implementation is
▲ Show 20 Lines • Show All 292 Lines • ▼ Show 20 Lines	def from_source(cls, filename, args=None, unsaved_files=None, options=0,
if unsaved_files is None:		if unsaved_files is None:
unsaved_files = []		unsaved_files = []

if index is None:		if index is None:
index = Index.create()		index = Index.create()

args_array = None		args_array = None
if len(args) > 0:		if len(args) > 0:
args_array = (c_char_p * len(args))(* args)		args_array = (c_string_p * len(args))()
		for i,a in enumerate(args):
		args_array[i] = c_string_p(a)

unsaved_array = None		unsaved_array = None
if len(unsaved_files) > 0:		if len(unsaved_files) > 0:
unsaved_array = (_CXUnsavedFile * len(unsaved_files))()		unsaved_array = (_CXUnsavedFile * len(unsaved_files))()
for i, (name, contents) in enumerate(unsaved_files):		for i, (name, contents) in enumerate(unsaved_files):
if hasattr(contents, "read"):		if hasattr(contents, "read"):
contents = contents.read()		contents = contents.read()

unsaved_array[i].name = name		unsaved_array[i].name = c_string_p(name)
unsaved_array[i].contents = contents		unsaved_array[i].contents = c_string_p(contents)
unsaved_array[i].length = len(contents)		unsaved_array[i].length = len(contents)

ptr = conf.lib.clang_parseTranslationUnit(index, filename, args_array,		ptr = conf.lib.clang_parseTranslationUnit(index, filename, args_array,
len(args), unsaved_array,		len(args), unsaved_array,
len(unsaved_files), options)		len(unsaved_files), options)

if not ptr:		if not ptr:
raise TranslationUnitLoadError("Error parsing translation unit.")		raise TranslationUnitLoadError("Error parsing translation unit.")
Show All 38 Lines	class TranslationUnit(ClangObject):
@property		@property
def cursor(self):		def cursor(self):
"""Retrieve the cursor that represents the given translation unit."""		"""Retrieve the cursor that represents the given translation unit."""
return conf.lib.clang_getTranslationUnitCursor(self)		return conf.lib.clang_getTranslationUnitCursor(self)

@property		@property
def spelling(self):		def spelling(self):
"""Get the original translation unit source file name."""		"""Get the original translation unit source file name."""
return conf.lib.clang_getTranslationUnitSpelling(self)		return str(conf.lib.clang_getTranslationUnitSpelling(self))

def get_includes(self):		def get_includes(self):
"""		"""
Return an iterable sequence of FileInclusion objects that describe the		Return an iterable sequence of FileInclusion objects that describe the
sequence of inclusions in a translation unit. The first object in		sequence of inclusions in a translation unit. The first object in
this sequence is always the input file. Note that this method will not		this sequence is always the input file. Note that this method will not
recursively iterate over header files included through precompiled		recursively iterate over header files included through precompiled
headers.		headers.
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines	def reparse(self, unsaved_files=None, options=0):
unsaved_files_array = 0		unsaved_files_array = 0
if len(unsaved_files):		if len(unsaved_files):
unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()		unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()
for i,(name,value) in enumerate(unsaved_files):		for i,(name,value) in enumerate(unsaved_files):
if not isinstance(value, str):		if not isinstance(value, str):
# FIXME: It would be great to support an efficient version		# FIXME: It would be great to support an efficient version
# of this, one day.		# of this, one day.
value = value.read()		value = value.read()
print value		print(value)
if not isinstance(value, str):		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].name = name
unsaved_files_array[i].contents = value		unsaved_files_array[i].contents = value
unsaved_files_array[i].length = len(value)		unsaved_files_array[i].length = len(value)
ptr = conf.lib.clang_reparseTranslationUnit(self, len(unsaved_files),		ptr = conf.lib.clang_reparseTranslationUnit(self, len(unsaved_files),
unsaved_files_array, options)		unsaved_files_array, options)

def save(self, filename):		def save(self, filename):
"""Saves the TranslationUnit to a file.		"""Saves the TranslationUnit to a file.
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines	def codeComplete(self, path, line, column, unsaved_files=None,
unsaved_files_array = 0		unsaved_files_array = 0
if len(unsaved_files):		if len(unsaved_files):
unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()		unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()
for i,(name,value) in enumerate(unsaved_files):		for i,(name,value) in enumerate(unsaved_files):
if not isinstance(value, str):		if not isinstance(value, str):
# FIXME: It would be great to support an efficient version		# FIXME: It would be great to support an efficient version
# of this, one day.		# of this, one day.
value = value.read()		value = value.read()
print value		print(value)
if not isinstance(value, str):		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].name = c_string_p(name)
unsaved_files_array[i].contents = value		unsaved_files_array[i].contents = c_string_p(value)
unsaved_files_array[i].length = len(value)		unsaved_files_array[i].length = len(value)
ptr = conf.lib.clang_codeCompleteAt(self, path, line, column,		ptr = conf.lib.clang_codeCompleteAt(self, path, line, column,
unsaved_files_array, len(unsaved_files), options)		unsaved_files_array, len(unsaved_files), options)
if ptr:		if ptr:
return CodeCompletionResults(ptr)		return CodeCompletionResults(ptr)
return None		return None

def get_tokens(self, locations=None, extent=None):		def get_tokens(self, locations=None, extent=None):
Show All 18 Lines	class File(ClangObject):
@staticmethod		@staticmethod
def from_name(translation_unit, file_name):		def from_name(translation_unit, file_name):
"""Retrieve a file handle within the given translation unit."""		"""Retrieve a file handle within the given translation unit."""
return File(conf.lib.clang_getFile(translation_unit, file_name))		return File(conf.lib.clang_getFile(translation_unit, file_name))

@property		@property
def name(self):		def name(self):
"""Return the complete file and path name of the file."""		"""Return the complete file and path name of the file."""
return conf.lib.clang_getCString(conf.lib.clang_getFileName(self))		return str(conf.lib.clang_getCString(conf.lib.clang_getFileName(self)))

@property		@property
def time(self):		def time(self):
"""Return the last modification time of the file."""		"""Return the last modification time of the file."""
return conf.lib.clang_getFileTime(self)		return conf.lib.clang_getFileTime(self)

def __str__(self):		def __str__(self):
return self.name		return str(self.name)

def __repr__(self):		def __repr__(self):
return "<File: %s>" % (self.name)		return "<File: %s>" % (self.name)

@staticmethod		@staticmethod
def from_cursor_result(res, fn, args):		def from_cursor_result(res, fn, args):
assert isinstance(res, File)		assert isinstance(res, File)

▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines	def __init__(self, cmd, ccmds):
self.cmd = cmd		self.cmd = cmd
# Keep a reference to the originating CompileCommands		# Keep a reference to the originating CompileCommands
# to prevent garbage collection		# to prevent garbage collection
self.ccmds = ccmds		self.ccmds = ccmds

@property		@property
def directory(self):		def directory(self):
"""Get the working directory for this CompileCommand"""		"""Get the working directory for this CompileCommand"""
return conf.lib.clang_CompileCommand_getDirectory(self.cmd)		return str(conf.lib.clang_CompileCommand_getDirectory(self.cmd))

@property		@property
def filename(self):		def filename(self):
"""Get the working filename for this CompileCommand"""		"""Get the working filename for this CompileCommand"""
return conf.lib.clang_CompileCommand_getFilename(self.cmd)		return str(conf.lib.clang_CompileCommand_getFilename(self.cmd))

@property		@property
def arguments(self):		def arguments(self):
"""		"""
Get an iterable object providing each argument in the		Get an iterable object providing each argument in the
command line for the compiler invocation as a _CXString.		command line for the compiler invocation as a _CXString.

Invariant : the first argument is the compiler executable		Invariant : the first argument is the compiler executable
"""		"""
length = conf.lib.clang_CompileCommand_getNumArgs(self.cmd)		length = conf.lib.clang_CompileCommand_getNumArgs(self.cmd)
for i in xrange(length):		for i in xrange(length):
yield conf.lib.clang_CompileCommand_getArg(self.cmd, i)		yield str(conf.lib.clang_CompileCommand_getArg(self.cmd, i))

class CompileCommands(object):		class CompileCommands(object):
"""		"""
CompileCommands is an iterable object containing all CompileCommand		CompileCommands is an iterable object containing all CompileCommand
that can be used for building a specific file.		that can be used for building a specific file.
"""		"""
def __init__(self, ccmds):		def __init__(self, ccmds):
self.ccmds = ccmds		self.ccmds = ccmds
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines	class Token(Structure):
]		]

@property		@property
def spelling(self):		def spelling(self):
"""The spelling of this token.		"""The spelling of this token.

This is the textual representation of the token in source.		This is the textual representation of the token in source.
"""		"""
return conf.lib.clang_getTokenSpelling(self._tu, self)		return str(conf.lib.clang_getTokenSpelling(self._tu, self))

@property		@property
def kind(self):		def kind(self):
"""Obtain the TokenKind of the current token."""		"""Obtain the TokenKind of the current token."""
return TokenKind.from_value(conf.lib.clang_getTokenKind(self))		return TokenKind.from_value(conf.lib.clang_getTokenKind(self))

@property		@property
def location(self):		def location(self):
Show All 26 Lines
functionList = [		functionList = [
("clang_annotateTokens",		("clang_annotateTokens",
[TranslationUnit, POINTER(Token), c_uint, POINTER(Cursor)]),		[TranslationUnit, POINTER(Token), c_uint, POINTER(Cursor)]),

("clang_CompilationDatabase_dispose",		("clang_CompilationDatabase_dispose",
[c_object_p]),		[c_object_p]),

("clang_CompilationDatabase_fromDirectory",		("clang_CompilationDatabase_fromDirectory",
[c_char_p, POINTER(c_uint)],		[c_string_p, POINTER(c_uint)],
c_object_p,		c_object_p,
CompilationDatabase.from_result),		CompilationDatabase.from_result),

("clang_CompilationDatabase_getAllCompileCommands",		("clang_CompilationDatabase_getAllCompileCommands",
[c_object_p],		[c_object_p],
c_object_p,		c_object_p,
CompileCommands.from_result),		CompileCommands.from_result),

("clang_CompilationDatabase_getCompileCommands",		("clang_CompilationDatabase_getCompileCommands",
[c_object_p, c_char_p],		[c_object_p, c_string_p],
c_object_p,		c_object_p,
CompileCommands.from_result),		CompileCommands.from_result),

("clang_CompileCommands_dispose",		("clang_CompileCommands_dispose",
[c_object_p]),		[c_object_p]),

("clang_CompileCommands_getCommand",		("clang_CompileCommands_getCommand",
[c_object_p, c_uint],		[c_object_p, c_uint],
Show All 18 Lines	functionList = [
_CXString,		_CXString,
_CXString.from_result),		_CXString.from_result),

("clang_CompileCommand_getNumArgs",		("clang_CompileCommand_getNumArgs",
[c_object_p],		[c_object_p],
c_uint),		c_uint),

("clang_codeCompleteAt",		("clang_codeCompleteAt",
[TranslationUnit, c_char_p, c_int, c_int, c_void_p, c_int, c_int],		[TranslationUnit, c_string_p, c_int, c_int, c_void_p, c_int, c_int],
POINTER(CCRStructure)),		POINTER(CCRStructure)),

("clang_codeCompleteGetDiagnostic",		("clang_codeCompleteGetDiagnostic",
[CodeCompletionResults, c_int],		[CodeCompletionResults, c_int],
Diagnostic),		Diagnostic),

("clang_codeCompleteGetNumDiagnostics",		("clang_codeCompleteGetNumDiagnostics",
[CodeCompletionResults],		[CodeCompletionResults],
c_int),		c_int),

("clang_createIndex",		("clang_createIndex",
[c_int, c_int],		[c_int, c_int],
c_object_p),		c_object_p),

("clang_createTranslationUnit",		("clang_createTranslationUnit",
[Index, c_char_p],		[Index, c_string_p],
c_object_p),		c_object_p),

("clang_CXXConstructor_isConvertingConstructor",		("clang_CXXConstructor_isConvertingConstructor",
[Cursor],		[Cursor],
bool),		bool),

("clang_CXXConstructor_isCopyConstructor",		("clang_CXXConstructor_isCopyConstructor",
[Cursor],		[Cursor],
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines	# [CXTUResourceUsage]),
_CXString),		_CXString),

("clang_getCompletionPriority",		("clang_getCompletionPriority",
[c_void_p],		[c_void_p],
c_int),		c_int),

("clang_getCString",		("clang_getCString",
[_CXString],		[_CXString],
c_char_p),		c_string_p),

("clang_getCursor",		("clang_getCursor",
[TranslationUnit, SourceLocation],		[TranslationUnit, SourceLocation],
Cursor),		Cursor),

("clang_getCursorDefinition",		("clang_getCursorDefinition",
[Cursor],		[Cursor],
Cursor,		Cursor,
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines	# CXTUResourceUsage),
c_longlong),		c_longlong),

("clang_getEnumDeclIntegerType",		("clang_getEnumDeclIntegerType",
[Cursor],		[Cursor],
Type,		Type,
Type.from_result),		Type.from_result),

("clang_getFile",		("clang_getFile",
[TranslationUnit, c_char_p],		[TranslationUnit, c_string_p],
c_object_p),		c_object_p),

("clang_getFileName",		("clang_getFileName",
[File],		[File],
_CXString), # TODO go through _CXString.from_result?		_CXString), # TODO go through _CXString.from_result?

("clang_getFileTime",		("clang_getFileTime",
[File],		[File],
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines	# CXTUResourceUsage),

("clang_getTranslationUnitSpelling",		("clang_getTranslationUnitSpelling",
[TranslationUnit],		[TranslationUnit],
_CXString,		_CXString,
_CXString.from_result),		_CXString.from_result),

("clang_getTUResourceUsageName",		("clang_getTUResourceUsageName",
[c_uint],		[c_uint],
c_char_p),		c_string_p),

("clang_getTypeDeclaration",		("clang_getTypeDeclaration",
[Type],		[Type],
Cursor,		Cursor,
Cursor.from_result),		Cursor.from_result),

("clang_getTypedefDeclUnderlyingType",		("clang_getTypedefDeclUnderlyingType",
[Cursor],		[Cursor],
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines	# CXTUResourceUsage),
[Cursor],		[Cursor],
bool),		bool),

("clang_isVolatileQualifiedType",		("clang_isVolatileQualifiedType",
[Type],		[Type],
bool),		bool),

("clang_parseTranslationUnit",		("clang_parseTranslationUnit",
[Index, c_char_p, c_void_p, c_int, c_void_p, c_int, c_int],		[Index, c_string_p, c_void_p, c_int, c_void_p, c_int, c_int],
c_object_p),		c_object_p),

("clang_reparseTranslationUnit",		("clang_reparseTranslationUnit",
[TranslationUnit, c_int, c_void_p, c_int],		[TranslationUnit, c_int, c_void_p, c_int],
c_int),		c_int),

("clang_saveTranslationUnit",		("clang_saveTranslationUnit",
[TranslationUnit, c_char_p, c_uint],		[TranslationUnit, c_string_p, c_uint],
c_int),		c_int),

("clang_tokenize",		("clang_tokenize",
[TranslationUnit, SourceRange, POINTER(POINTER(Token)), POINTER(c_uint)]),		[TranslationUnit, SourceRange, POINTER(POINTER(Token)), POINTER(c_uint)]),

("clang_visitChildren",		("clang_visitChildren",
[Cursor, callbacks['cursor_visit'], py_object],		[Cursor, callbacks['cursor_visit'], py_object],
c_uint),		c_uint),
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines	# CXTUResourceUsage),
c_longlong),		c_longlong),

("clang_Type_getClassType",		("clang_Type_getClassType",
[Type],		[Type],
Type,		Type,
Type.from_result),		Type.from_result),

("clang_Type_getOffsetOf",		("clang_Type_getOffsetOf",
[Type, c_char_p],		[Type, c_string_p],
c_longlong),		c_longlong),

("clang_Type_getSizeOf",		("clang_Type_getSizeOf",
[Type],		[Type],
c_longlong),		c_longlong),

("clang_Type_getCXXRefQualifier",		("clang_Type_getCXXRefQualifier",
[Type],		[Type],
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines	def register_functions(lib, ignore_errors):

This must be called as part of library instantiation so Python knows how		This must be called as part of library instantiation so Python knows how
to call out to the shared library.		to call out to the shared library.
"""		"""

def register(item):		def register(item):
return register_function(lib, item, ignore_errors)		return register_function(lib, item, ignore_errors)

map(register, functionList)		for f in functionList:
		register(f)

class Config:		class Config:
library_path = None		library_path = None
library_file = None		library_file = None
compatibility_check = True		compatibility_check = True
loaded = False		loaded = False

@staticmethod		@staticmethod
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

cfe/trunk/bindings/python/tests/cindex/test_translation_unit.py

	Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
	#define SOME_DEFINE y			#define SOME_DEFINE y
	""")			""")
	])			])
	spellings = [c.spelling for c in tu.cursor.get_children()]			spellings = [c.spelling for c in tu.cursor.get_children()]
	assert spellings[-2] == 'x'			assert spellings[-2] == 'x'
	assert spellings[-1] == 'y'			assert spellings[-1] == 'y'

	def test_unsaved_files_2():			def test_unsaved_files_2():
	import StringIO			try:
				from StringIO import StringIO
				except:
				from io import StringIO

	tu = TranslationUnit.from_source('fake.c', unsaved_files = [			tu = TranslationUnit.from_source('fake.c', unsaved_files = [
	('fake.c', StringIO.StringIO('int x;'))])			('fake.c', StringIO('int x;'))])
	spellings = [c.spelling for c in tu.cursor.get_children()]			spellings = [c.spelling for c in tu.cursor.get_children()]
	assert spellings[-1] == 'x'			assert spellings[-1] == 'x'

	def normpaths_equal(path1, path2):			def normpaths_equal(path1, path2):
	""" Compares two paths for equality after normalizing them with			""" Compares two paths for equality after normalizing them with
	os.path.normpath			os.path.normpath
	"""			"""
	return os.path.normpath(path1) == os.path.normpath(path2)			return os.path.normpath(path1) == os.path.normpath(path2)
	▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

Support for Python 3 in libclang python bindings
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 76854

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

cfe/trunk/bindings/python/tests/cindex/test_translation_unit.py

This is an archive of the discontinued LLVM Phabricator instance.

Support for Python 3 in libclang python bindingsClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 76854

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

cfe/trunk/bindings/python/tests/cindex/test_translation_unit.py

Support for Python 3 in libclang python bindings
ClosedPublic