1. Juri Pakaste
  2. nsstringgen

Commits

Juri Pakaste  committed 43733d6

Moved all the libs under nsstringgen package

  • Participants
  • Parent commits 3118bd3
  • Branches default

Comments (0)

Files changed (11)

File NSStringFromEnumGenerator.py

  • Ignore whitespace
-#!/usr/bin/python
-
-from collections import namedtuple, OrderedDict
-from functools import reduce
-from tempfile import NamedTemporaryFile
-import os.path
-import sys
-
-import clang.cindex
-
-class NSGException(Exception):
-    pass
-
-EnumValue = namedtuple("EnumValue", "name, value")
-
-class ParsedEnum(object):
-    def __init__(self, name, typedef_name, values = None):
-        self.name = name if name is not None else ""
-        self.typedef_name = typedef_name if typedef_name is not None else ""
-        self.values = values if values is not None else []
-
-    @property
-    def preferred_name(self):
-        if self.typedef_name:
-            return self.typedef_name
-        return self.name
-
-    def __repr__(self):
-        return "ParsedEnum({0}, {1}, {2})".format(repr(self.name), repr(self.typedef_name), self.values)
-
-def print_tree(node, depth = 0):
-    indent = depth * "  "
-    defn = node.get_definition()
-    r = ["{0}node:          {1}".format(indent, node),
-         "{0}spelling:      {1}".format(indent, node.spelling),
-         "{0}displayname:   {1}".format(indent, node.displayname),
-         "{0}kind:          {1}".format(indent, node.kind),
-         "{0}type:          {1}".format(indent, node.type.kind),
-         "{0}is_definition: {1}".format(indent, node.is_definition()),
-         "{0}extent:        {1}".format(indent, node.extent),
-         "{0}definition:    {1} {2} ({3})".format(indent, defn, defn.kind if defn else None, "Same" if defn is not None and node == defn else "Not same"),
-         "----------------------------------------"]
-    for c in node.get_children():
-        r.extend(print_tree(c, depth + 1))
-    return r
-
-class FileReader(object):
-    def __init__(self, size):
-        self.size = size
-        self.files = OrderedDict()
-        self.fixed_files = {}
-
-    def insert_content(self, sourcefile, content):
-        self.fixed_files[os.path.abspath(sourcefile)] = content
-
-    def read_extent(self, sourcefile, extent):
-        sfpath = os.path.abspath(sourcefile)
-        content = self.fixed_files.get(sfpath)
-        if not content:
-            content = self.files.get(sfpath)
-            if not content:
-                with open(sfpath) as fo:
-                    content = fo.read()
-                self.files[sfpath] = content
-            else:
-                # refresh LRU order
-                del self.files[sfpath]
-                self.files[sfpath] = content
-            while len(self.files) > self.size:
-                self.files.popitem(last = False)
-        return content[extent.start.offset:extent.end.offset]
-
-def extract_value(sourcefile, extent):
-    with open(sourcefile) as fo:
-        fo.seek(extent.start.offset)
-        bytes = fo.read(extent.end.offset - extent.start.offset)
-        return bytes
-
-def handle_enum(node, typedef_name, file_reader):
-    # sys.stdout.write("\n".join(print_tree(node)) + "\n")
-
-    pe = ParsedEnum(node.spelling, typedef_name)
-    for c in node.get_children():
-        if c.kind == clang.cindex.CursorKind.ENUM_CONSTANT_DECL:
-            name = c.spelling
-            value = None
-
-            childlist = list(c.get_children())
-            if len(childlist) > 0:
-                vbytes = file_reader.read_extent(c.location.file.name, childlist[0].extent)
-                value = vbytes
-
-            pe.values.append(EnumValue(name, value))
-    return pe
-
-def create_finder(path, file_reader):
-    ppath = os.path.abspath(path)
-
-    def find_enums(node, parents = ()):
-        enums = []
-
-        # we get nil files at the start for some reason
-        if node.location.file is not None and os.path.abspath(node.location.file.name) != ppath:
-            return []
-        try:
-            kind = node.kind
-        except ValueError:
-            # a cursor kind not recognized by cindex.py
-            kind = clang.cindex.CursorKind.UNEXPOSED_DECL
-        # plain enum. see if the parent was a typedef and if so, use its name.
-        if kind == clang.cindex.CursorKind.ENUM_DECL:
-            typedef_name = None
-            if len(parents) and parents[-1].kind == clang.cindex.CursorKind.TYPEDEF_DECL:
-                typedef_name = parents[-1].spelling
-            enums.append(handle_enum(node, typedef_name, file_reader))
-        # typeref inside a typedecl pointing to an enum we can find with get_definition()
-        elif kind == clang.cindex.CursorKind.TYPE_REF and node.type.kind == clang.cindex.TypeKind.ENUM and len(parents) > 0 and parents[-1].kind == clang.cindex.CursorKind.TYPEDEF_DECL:
-            enums.append(handle_enum(node.get_definition(), parents[-1].spelling, file_reader))
-        else:
-            for c in node.get_children():
-                enums.extend(find_enums(c, parents + (node,)))
-        return enums
-    return find_enums
-
-def create_case(enumvalue):
-    if enumvalue.value is None:
-        return "case {0}: return @\"{0}\";".format(enumvalue.name)
-    else:
-        return "case {0}: return [NSString stringWithFormat:@\"{0} (%d)\", {1}];".format(enumvalue.name, enumvalue.value)
-
-def create_fun(parsed_enum):
-    name = parsed_enum.preferred_name
-
-    if parsed_enum.typedef_name:
-        typename = name
-    else:
-        typename = "enum {0}".format(parsed_enum.name)
-
-    decl = "NSString* NSStringFrom{0}({1} v)".format(name, typename)
-    ext_decl = "extern {0};".format(decl)
-
-    defn = "{0} {{".format(decl)
-    switchstart = "  switch (v) {"
-    cases = ["    {0}".format(create_case(ev)) for ev in parsed_enum.values]
-    switchend = "  }"
-    funend = "}"
-    return "\n".join((ext_decl, defn, switchstart, "\n".join(cases), switchend, funend))
-
-def create_mask_fun(parsed_enum):
-    name = parsed_enum.preferred_name
-
-    if parsed_enum.typedef_name:
-        typename = name
-    else:
-        typename = "enum {0}".format(parsed_enum.name)
-
-    decl = "NSString* NSStringFrom{0}({1} v)".format(name, typename)
-    ext_decl = "extern {0};".format(decl)
-    defn = "{0} {{".format(decl)
-
-    lines = [ext_decl, defn]
-    lines.append("  NSMutableArray *bits = [NSMutableArray array];")
-    for ev in parsed_enum.values:
-        check = "  if (v & {0}) [bits addObject:@\"{0}\"];".format(ev.name)
-        lines.append(check)
-    lines.append("  return [bits componentsJoinedByString:@\" | \"];")
-    lines.append("}")
-    return "\n".join(lines)
-
-
-
-def funs_from_file(f, includes, mask, contents = None):
-    index = clang.cindex.Index.create()
-    includeargs = reduce(lambda acc, e: acc + e, [["-include", inc] for inc in includes], []) if includes else []
-    unsaved = []
-    if contents:
-        # create a dummy file if we get contents, because seems libclang is not happy with a name like "-"
-        ntemp = NamedTemporaryFile(suffix = ".h")
-        f = ntemp.name
-        unsaved = [[f, contents]]
-    tu = index.parse(f, args = ["-x", "objective-c"] + includeargs, unsaved_files = unsaved)
-    if not tu:
-        raise NSGException("Unable to parse input {0} for unknown reason".format(f))
-    if tu.diagnostics:
-        msg = "\n".join([str(d) for d in tu.diagnostics])
-        raise NSGException(msg)
-
-    file_reader = FileReader(10)
-    for fname, content in unsaved:
-        file_reader.insert_content(fname, content)
-
-    finder = create_finder(f, file_reader)
-    enums = finder(tu.cursor)
-    creator = create_mask_fun if mask else create_fun
-    return [creator(e) for e in enums if e.preferred_name]
-
-if __name__ == '__main__':
-    for fun in funs_from_file(sys.argv[1]):
-        sys.stdout.write(fun)
-        sys.stdout.write("\n")

File clang/LICENSE.TXT

  • Ignore whitespace
-==============================================================================
-LLVM Release License
-==============================================================================
-University of Illinois/NCSA
-Open Source License
-
-Copyright (c) 2007-2012 University of Illinois at Urbana-Champaign.
-All rights reserved.
-
-Developed by:
-
-    LLVM Team
-
-    University of Illinois at Urbana-Champaign
-
-    http://llvm.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal with
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimers.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimers in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the names of the LLVM Team, University of Illinois at
-      Urbana-Champaign, nor the names of its contributors may be used to
-      endorse or promote products derived from this Software without specific
-      prior written permission.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-SOFTWARE.
-
-==============================================================================
-The LLVM software contains code written by third parties.  Such software will
-have its own individual LICENSE.TXT file in the directory in which it appears.
-This file will describe the copyrights, license, and restrictions which apply
-to that code.
-
-The disclaimer of warranty in the University of Illinois Open Source License
-applies to all code in the LLVM Distribution, and nothing in any of the
-other licenses gives permission to use the names of the LLVM Team or the
-University of Illinois to endorse or promote products derived from this
-Software.
-
-The following pieces of software have additional or alternate copyrights,
-licenses, and/or restrictions:
-
-Program             Directory
--------             ---------
-<none yet>
-

File clang/__init__.py

  • Ignore whitespace
-#===- __init__.py - Clang Python Bindings --------------------*- python -*--===#
-#
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-#===------------------------------------------------------------------------===#
-
-r"""
-Clang Library Bindings
-======================
-
-This package provides access to the Clang compiler and libraries.
-
-The available modules are:
-
-  cindex
-
-    Bindings for the Clang indexing library.
-"""
-
-__all__ = ['cindex']
-

File clang/cindex.py

  • Ignore whitespace
-#===- cindex.py - Python Indexing Library Bindings -----------*- python -*--===#
-#
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-#===------------------------------------------------------------------------===#
-
-r"""
-Clang Indexing Library Bindings
-===============================
-
-This module provides an interface to the Clang indexing library. It is a
-low-level interface to the indexing library which attempts to match the Clang
-API directly while also being "pythonic". Notable differences from the C API
-are:
-
- * string results are returned as Python strings, not CXString objects.
-
- * null cursors are translated to None.
-
- * access to child cursors is done via iteration, not visitation.
-
-The major indexing objects are:
-
-  Index
-
-    The top-level object which manages some global library state.
-
-  TranslationUnit
-
-    High-level object encapsulating the AST for a single translation unit. These
-    can be loaded from .ast files or parsed on the fly.
-
-  Cursor
-
-    Generic object for representing a node in the AST.
-
-  SourceRange, SourceLocation, and File
-
-    Objects representing information about the input source.
-
-Most object information is exposed using properties, when the underlying API
-call is efficient.
-"""
-
-# TODO
-# ====
-#
-# o API support for invalid translation units. Currently we can't even get the
-#   diagnostics on failure because they refer to locations in an object that
-#   will have been invalidated.
-#
-# o fix memory management issues (currently client must hold on to index and
-#   translation unit, or risk crashes).
-#
-# o expose code completion APIs.
-#
-# o cleanup ctypes wrapping, would be nice to separate the ctypes details more
-#   clearly, and hide from the external interface (i.e., help(cindex)).
-#
-# o implement additional SourceLocation, SourceRange, and File methods.
-
-from ctypes import *
-import collections
-
-def get_cindex_library():
-    # FIXME: It's probably not the case that the library is actually found in
-    # this location. We need a better system of identifying and loading the
-    # CIndex library. It could be on path or elsewhere, or versioned, etc.
-    import platform
-    name = platform.system()
-    if name == 'Darwin':
-        return cdll.LoadLibrary('libclang.dylib')
-    elif name == 'Windows':
-        return cdll.LoadLibrary('libclang.dll')
-    else:
-        return cdll.LoadLibrary('libclang.so')
-
-# 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
-# integer and pass the wrong value on platforms where int != void*. Work around
-# this by marshalling object arguments as void**.
-c_object_p = POINTER(c_void_p)
-
-lib = get_cindex_library()
-
-### Structures and Utility Classes ###
-
-class _CXString(Structure):
-    """Helper for transforming CXString results."""
-
-    _fields_ = [("spelling", c_char_p), ("free", c_int)]
-
-    def __del__(self):
-        _CXString_dispose(self)
-
-    @staticmethod
-    def from_result(res, fn, args):
-        assert isinstance(res, _CXString)
-        return _CXString_getCString(res)
-
-class SourceLocation(Structure):
-    """
-    A SourceLocation represents a particular location within a source file.
-    """
-    _fields_ = [("ptr_data", c_void_p * 2), ("int_data", c_uint)]
-    _data = None
-
-    def _get_instantiation(self):
-        if self._data is None:
-            f, l, c, o = c_object_p(), c_uint(), c_uint(), c_uint()
-            SourceLocation_loc(self, byref(f), byref(l), byref(c), byref(o))
-            if f:
-                f = File(f)
-            else:
-                f = None
-            self._data = (f, int(l.value), int(c.value), int(o.value))
-        return self._data
-
-    @staticmethod
-    def from_position(tu, file, line, column):
-        """
-        Retrieve the source location associated with a given file/line/column in
-        a particular translation unit.
-        """
-        return SourceLocation_getLocation(tu, file, line, column)
-
-    @property
-    def file(self):
-        """Get the file represented by this source location."""
-        return self._get_instantiation()[0]
-
-    @property
-    def line(self):
-        """Get the line represented by this source location."""
-        return self._get_instantiation()[1]
-
-    @property
-    def column(self):
-        """Get the column represented by this source location."""
-        return self._get_instantiation()[2]
-
-    @property
-    def offset(self):
-        """Get the file offset represented by this source location."""
-        return self._get_instantiation()[3]
-
-    def __eq__(self, other):
-        return SourceLocation_equalLocations(self, other)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __repr__(self):
-        if self.file:
-            filename = self.file.name
-        else:
-            filename = None
-        return "<SourceLocation file %r, line %r, column %r>" % (
-            filename, self.line, self.column)
-
-class SourceRange(Structure):
-    """
-    A SourceRange describes a range of source locations within the source
-    code.
-    """
-    _fields_ = [
-        ("ptr_data", c_void_p * 2),
-        ("begin_int_data", c_uint),
-        ("end_int_data", c_uint)]
-
-    # FIXME: Eliminate this and make normal constructor? Requires hiding ctypes
-    # object.
-    @staticmethod
-    def from_locations(start, end):
-        return SourceRange_getRange(start, end)
-
-    @property
-    def start(self):
-        """
-        Return a SourceLocation representing the first character within a
-        source range.
-        """
-        return SourceRange_start(self)
-
-    @property
-    def end(self):
-        """
-        Return a SourceLocation representing the last character within a
-        source range.
-        """
-        return SourceRange_end(self)
-
-    def __eq__(self, other):
-        return SourceRange_equalRanges(self, other)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __repr__(self):
-        return "<SourceRange start %r, end %r>" % (self.start, self.end)
-
-class Diagnostic(object):
-    """
-    A Diagnostic is a single instance of a Clang diagnostic. It includes the
-    diagnostic severity, the message, the location the diagnostic occurred, as
-    well as additional source ranges and associated fix-it hints.
-    """
-
-    Ignored = 0
-    Note    = 1
-    Warning = 2
-    Error   = 3
-    Fatal   = 4
-
-    def __init__(self, ptr):
-        self.ptr = ptr
-
-    def __del__(self):
-        _clang_disposeDiagnostic(self)
-
-    @property
-    def severity(self):
-        return _clang_getDiagnosticSeverity(self)
-
-    @property
-    def location(self):
-        return _clang_getDiagnosticLocation(self)
-
-    @property
-    def spelling(self):
-        return _clang_getDiagnosticSpelling(self)
-
-    @property
-    def ranges(self):
-        class RangeIterator:
-            def __init__(self, diag):
-                self.diag = diag
-
-            def __len__(self):
-                return int(_clang_getDiagnosticNumRanges(self.diag))
-
-            def __getitem__(self, key):
-                if (key >= len(self)):
-                    raise IndexError
-                return _clang_getDiagnosticRange(self.diag, key)
-
-        return RangeIterator(self)
-
-    @property
-    def fixits(self):
-        class FixItIterator:
-            def __init__(self, diag):
-                self.diag = diag
-
-            def __len__(self):
-                return int(_clang_getDiagnosticNumFixIts(self.diag))
-
-            def __getitem__(self, key):
-                range = SourceRange()
-                value = _clang_getDiagnosticFixIt(self.diag, key, byref(range))
-                if len(value) == 0:
-                    raise IndexError
-
-                return FixIt(range, value)
-
-        return FixItIterator(self)
-
-    @property
-    def category_number(self):
-        """The category number for this diagnostic."""
-        return _clang_getDiagnosticCategory(self)
-
-    @property
-    def category_name(self):
-        """The string name of the category for this diagnostic."""
-        return _clang_getDiagnosticCategoryName(self.category_number)
-
-    @property
-    def option(self):
-        """The command-line option that enables this diagnostic."""
-        return _clang_getDiagnosticOption(self, None)
-
-    @property
-    def disable_option(self):
-        """The command-line option that disables this diagnostic."""
-        disable = _CXString()
-        _clang_getDiagnosticOption(self, byref(disable))
-
-        return _CXString_getCString(disable)
-
-    def __repr__(self):
-        return "<Diagnostic severity %r, location %r, spelling %r>" % (
-            self.severity, self.location, self.spelling)
-
-    def from_param(self):
-      return self.ptr
-
-class FixIt(object):
-    """
-    A FixIt represents a transformation to be applied to the source to
-    "fix-it". The fix-it shouldbe applied by replacing the given source range
-    with the given value.
-    """
-
-    def __init__(self, range, value):
-        self.range = range
-        self.value = value
-
-    def __repr__(self):
-        return "<FixIt range %r, value %r>" % (self.range, self.value)
-
-### Cursor Kinds ###
-
-class CursorKind(object):
-    """
-    A CursorKind describes the kind of entity that a cursor points to.
-    """
-
-    # The unique kind objects, indexed by id.
-    _kinds = []
-    _name_map = None
-
-    def __init__(self, value):
-        if value >= len(CursorKind._kinds):
-            CursorKind._kinds += [None] * (value - len(CursorKind._kinds) + 1)
-        if CursorKind._kinds[value] is not None:
-            raise ValueError,'CursorKind already loaded'
-        self.value = value
-        CursorKind._kinds[value] = self
-        CursorKind._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 CursorKind.__dict__.items():
-                if isinstance(value,CursorKind):
-                    self._name_map[value] = key
-        return self._name_map[self]
-
-    @staticmethod
-    def from_id(id):
-        if id >= len(CursorKind._kinds) or CursorKind._kinds[id] is None:
-            raise ValueError,'Unknown cursor kind'
-        return CursorKind._kinds[id]
-
-    @staticmethod
-    def get_all_kinds():
-        """Return all CursorKind enumeration instances."""
-        return filter(None, CursorKind._kinds)
-
-    def is_declaration(self):
-        """Test if this is a declaration kind."""
-        return CursorKind_is_decl(self)
-
-    def is_reference(self):
-        """Test if this is a reference kind."""
-        return CursorKind_is_ref(self)
-
-    def is_expression(self):
-        """Test if this is an expression kind."""
-        return CursorKind_is_expr(self)
-
-    def is_statement(self):
-        """Test if this is a statement kind."""
-        return CursorKind_is_stmt(self)
-
-    def is_attribute(self):
-        """Test if this is an attribute kind."""
-        return CursorKind_is_attribute(self)
-
-    def is_invalid(self):
-        """Test if this is an invalid kind."""
-        return CursorKind_is_inv(self)
-
-    def is_translation_unit(self):
-        """Test if this is a translation unit kind."""
-        return CursorKind_is_translation_unit(self)
-
-    def is_preprocessing(self):
-        """Test if this is a preprocessing kind."""
-        return CursorKind_is_preprocessing(self)
-
-    def is_unexposed(self):
-        """Test if this is an unexposed kind."""
-        return CursorKind_is_unexposed(self)
-
-    def __repr__(self):
-        return 'CursorKind.%s' % (self.name,)
-
-# FIXME: Is there a nicer way to expose this enumeration? We could potentially
-# represent the nested structure, or even build a class hierarchy. The main
-# things we want for sure are (a) simple external access to kinds, (b) a place
-# to hang a description and name, (c) easy to keep in sync with Index.h.
-
-###
-# Declaration Kinds
-
-# A declaration whose specific kind is not exposed via this interface.
-#
-# Unexposed declarations have the same operations as any other kind of
-# declaration; one can extract their location information, spelling, find their
-# definitions, etc. However, the specific kind of the declaration is not
-# reported.
-CursorKind.UNEXPOSED_DECL = CursorKind(1)
-
-# A C or C++ struct.
-CursorKind.STRUCT_DECL = CursorKind(2)
-
-# A C or C++ union.
-CursorKind.UNION_DECL = CursorKind(3)
-
-# A C++ class.
-CursorKind.CLASS_DECL = CursorKind(4)
-
-# An enumeration.
-CursorKind.ENUM_DECL = CursorKind(5)
-
-# A field (in C) or non-static data member (in C++) in a struct, union, or C++
-# class.
-CursorKind.FIELD_DECL = CursorKind(6)
-
-# An enumerator constant.
-CursorKind.ENUM_CONSTANT_DECL = CursorKind(7)
-
-# A function.
-CursorKind.FUNCTION_DECL = CursorKind(8)
-
-# A variable.
-CursorKind.VAR_DECL = CursorKind(9)
-
-# A function or method parameter.
-CursorKind.PARM_DECL = CursorKind(10)
-
-# An Objective-C @interface.
-CursorKind.OBJC_INTERFACE_DECL = CursorKind(11)
-
-# An Objective-C @interface for a category.
-CursorKind.OBJC_CATEGORY_DECL = CursorKind(12)
-
-# An Objective-C @protocol declaration.
-CursorKind.OBJC_PROTOCOL_DECL = CursorKind(13)
-
-# An Objective-C @property declaration.
-CursorKind.OBJC_PROPERTY_DECL = CursorKind(14)
-
-# An Objective-C instance variable.
-CursorKind.OBJC_IVAR_DECL = CursorKind(15)
-
-# An Objective-C instance method.
-CursorKind.OBJC_INSTANCE_METHOD_DECL = CursorKind(16)
-
-# An Objective-C class method.
-CursorKind.OBJC_CLASS_METHOD_DECL = CursorKind(17)
-
-# An Objective-C @implementation.
-CursorKind.OBJC_IMPLEMENTATION_DECL = CursorKind(18)
-
-# An Objective-C @implementation for a category.
-CursorKind.OBJC_CATEGORY_IMPL_DECL = CursorKind(19)
-
-# A typedef.
-CursorKind.TYPEDEF_DECL = CursorKind(20)
-
-# A C++ class method.
-CursorKind.CXX_METHOD = CursorKind(21)
-
-# A C++ namespace.
-CursorKind.NAMESPACE = CursorKind(22)
-
-# A linkage specification, e.g. 'extern "C"'.
-CursorKind.LINKAGE_SPEC = CursorKind(23)
-
-# A C++ constructor.
-CursorKind.CONSTRUCTOR = CursorKind(24)
-
-# A C++ destructor.
-CursorKind.DESTRUCTOR = CursorKind(25)
-
-# A C++ conversion function.
-CursorKind.CONVERSION_FUNCTION = CursorKind(26)
-
-# A C++ template type parameter
-CursorKind.TEMPLATE_TYPE_PARAMETER = CursorKind(27)
-
-# A C++ non-type template paramater.
-CursorKind.TEMPLATE_NON_TYPE_PARAMETER = CursorKind(28)
-
-# A C++ template template parameter.
-CursorKind.TEMPLATE_TEMPLATE_PARAMTER = CursorKind(29)
-
-# A C++ function template.
-CursorKind.FUNCTION_TEMPLATE = CursorKind(30)
-
-# A C++ class template.
-CursorKind.CLASS_TEMPLATE = CursorKind(31)
-
-# A C++ class template partial specialization.
-CursorKind.CLASS_TEMPLATE_PARTIAL_SPECIALIZATION = CursorKind(32)
-
-# A C++ namespace alias declaration.
-CursorKind.NAMESPACE_ALIAS = CursorKind(33)
-
-# A C++ using directive
-CursorKind.USING_DIRECTIVE = CursorKind(34)
-
-# A C++ using declaration
-CursorKind.USING_DECLARATION = CursorKind(35)
-
-# A Type alias decl.
-CursorKind.TYPE_ALIAS_DECL = CursorKind(36)
-
-# A Objective-C synthesize decl
-CursorKind.OBJC_SYNTHESIZE_DECL = CursorKind(37)
-
-# A Objective-C dynamic decl
-CursorKind.OBJC_DYNAMIC_DECL = CursorKind(38)
-
-# A C++ access specifier decl.
-CursorKind.CXX_ACCESS_SPEC_DECL = CursorKind(39)
-
-
-###
-# Reference Kinds
-
-CursorKind.OBJC_SUPER_CLASS_REF = CursorKind(40)
-CursorKind.OBJC_PROTOCOL_REF = CursorKind(41)
-CursorKind.OBJC_CLASS_REF = CursorKind(42)
-
-# A reference to a type declaration.
-#
-# A type reference occurs anywhere where a type is named but not
-# declared. For example, given:
-#   typedef unsigned size_type;
-#   size_type size;
-#
-# The typedef is a declaration of size_type (CXCursor_TypedefDecl),
-# while the type of the variable "size" is referenced. The cursor
-# referenced by the type of size is the typedef for size_type.
-CursorKind.TYPE_REF = CursorKind(43)
-CursorKind.CXX_BASE_SPECIFIER = CursorKind(44)
-
-# A reference to a class template, function template, template
-# template parameter, or class template partial specialization.
-CursorKind.TEMPLATE_REF = CursorKind(45)
-
-# A reference to a namespace or namepsace alias.
-CursorKind.NAMESPACE_REF = CursorKind(46)
-
-# A reference to a member of a struct, union, or class that occurs in
-# some non-expression context, e.g., a designated initializer.
-CursorKind.MEMBER_REF = CursorKind(47)
-
-# A reference to a labeled statement.
-CursorKind.LABEL_REF = CursorKind(48)
-
-# A reference toa a set of overloaded functions or function templates
-# that has not yet been resolved to a specific function or function template.
-CursorKind.OVERLOADED_DECL_REF = CursorKind(49)
-
-###
-# Invalid/Error Kinds
-
-CursorKind.INVALID_FILE = CursorKind(70)
-CursorKind.NO_DECL_FOUND = CursorKind(71)
-CursorKind.NOT_IMPLEMENTED = CursorKind(72)
-CursorKind.INVALID_CODE = CursorKind(73)
-
-###
-# Expression Kinds
-
-# An expression whose specific kind is not exposed via this interface.
-#
-# Unexposed expressions have the same operations as any other kind of
-# expression; one can extract their location information, spelling, children,
-# etc. However, the specific kind of the expression is not reported.
-CursorKind.UNEXPOSED_EXPR = CursorKind(100)
-
-# An expression that refers to some value declaration, such as a function,
-# varible, or enumerator.
-CursorKind.DECL_REF_EXPR = CursorKind(101)
-
-# An expression that refers to a member of a struct, union, class, Objective-C
-# class, etc.
-CursorKind.MEMBER_REF_EXPR = CursorKind(102)
-
-# An expression that calls a function.
-CursorKind.CALL_EXPR = CursorKind(103)
-
-# An expression that sends a message to an Objective-C object or class.
-CursorKind.OBJC_MESSAGE_EXPR = CursorKind(104)
-
-# An expression that represents a block literal.
-CursorKind.BLOCK_EXPR = CursorKind(105)
-
-# An integer literal.
-CursorKind.INTEGER_LITERAL = CursorKind(106)
-
-# A floating point number literal.
-CursorKind.FLOATING_LITERAL = CursorKind(107)
-
-# An imaginary number literal.
-CursorKind.IMAGINARY_LITERAL = CursorKind(108)
-
-# A string literal.
-CursorKind.STRING_LITERAL = CursorKind(109)
-
-# A character literal.
-CursorKind.CHARACTER_LITERAL = CursorKind(110)
-
-# A parenthesized expression, e.g. "(1)".
-#
-# This AST node is only formed if full location information is requested.
-CursorKind.PAREN_EXPR = CursorKind(111)
-
-# This represents the unary-expression's (except sizeof and
-# alignof).
-CursorKind.UNARY_OPERATOR = CursorKind(112)
-
-# [C99 6.5.2.1] Array Subscripting.
-CursorKind.ARRAY_SUBSCRIPT_EXPR = CursorKind(113)
-
-# A builtin binary operation expression such as "x + y" or
-# "x <= y".
-CursorKind.BINARY_OPERATOR = CursorKind(114)
-
-# Compound assignment such as "+=".
-CursorKind.COMPOUND_ASSIGNMENT_OPERATOR = CursorKind(115)
-
-# The ?: ternary operator.
-CursorKind.CONDITONAL_OPERATOR = CursorKind(116)
-
-# An explicit cast in C (C99 6.5.4) or a C-style cast in C++
-# (C++ [expr.cast]), which uses the syntax (Type)expr.
-#
-# For example: (int)f.
-CursorKind.CSTYLE_CAST_EXPR = CursorKind(117)
-
-# [C99 6.5.2.5]
-CursorKind.COMPOUND_LITERAL_EXPR = CursorKind(118)
-
-# Describes an C or C++ initializer list.
-CursorKind.INIT_LIST_EXPR = CursorKind(119)
-
-# The GNU address of label extension, representing &&label.
-CursorKind.ADDR_LABEL_EXPR = CursorKind(120)
-
-# This is the GNU Statement Expression extension: ({int X=4; X;})
-CursorKind.StmtExpr = CursorKind(121)
-
-# Represents a C11 generic selection.
-CursorKind.GENERIC_SELECTION_EXPR = CursorKind(122)
-
-# Implements the GNU __null extension, which is a name for a null
-# pointer constant that has integral type (e.g., int or long) and is the same
-# size and alignment as a pointer.
-#
-# The __null extension is typically only used by system headers, which define
-# NULL as __null in C++ rather than using 0 (which is an integer that may not
-# match the size of a pointer).
-CursorKind.GNU_NULL_EXPR = CursorKind(123)
-
-# C++'s static_cast<> expression.
-CursorKind.CXX_STATIC_CAST_EXPR = CursorKind(124)
-
-# C++'s dynamic_cast<> expression.
-CursorKind.CXX_DYNAMIC_CAST_EXPR = CursorKind(125)
-
-# C++'s reinterpret_cast<> expression.
-CursorKind.CXX_REINTERPRET_CAST_EXPR = CursorKind(126)
-
-# C++'s const_cast<> expression.
-CursorKind.CXX_CONST_CAST_EXPR = CursorKind(127)
-
-# Represents an explicit C++ type conversion that uses "functional"
-# notion (C++ [expr.type.conv]).
-#
-# Example:
-# \code
-#   x = int(0.5);
-# \endcode
-CursorKind.CXX_FUNCTIONAL_CAST_EXPR = CursorKind(128)
-
-# A C++ typeid expression (C++ [expr.typeid]).
-CursorKind.CXX_TYPEID_EXPR = CursorKind(129)
-
-# [C++ 2.13.5] C++ Boolean Literal.
-CursorKind.CXX_BOOL_LITERAL_EXPR = CursorKind(130)
-
-# [C++0x 2.14.7] C++ Pointer Literal.
-CursorKind.CXX_NULL_PTR_LITERAL_EXPR = CursorKind(131)
-
-# Represents the "this" expression in C++
-CursorKind.CXX_THIS_EXPR = CursorKind(132)
-
-# [C++ 15] C++ Throw Expression.
-#
-# This handles 'throw' and 'throw' assignment-expression. When
-# assignment-expression isn't present, Op will be null.
-CursorKind.CXX_THROW_EXPR = CursorKind(133)
-
-# A new expression for memory allocation and constructor calls, e.g:
-# "new CXXNewExpr(foo)".
-CursorKind.CXX_NEW_EXPR = CursorKind(134)
-
-# A delete expression for memory deallocation and destructor calls,
-# e.g. "delete[] pArray".
-CursorKind.CXX_DELETE_EXPR = CursorKind(135)
-
-# Represents a unary expression.
-CursorKind.CXX_UNARY_EXPR = CursorKind(136)
-
-# ObjCStringLiteral, used for Objective-C string literals i.e. "foo".
-CursorKind.OBJC_STRING_LITERAL = CursorKind(137)
-
-# ObjCEncodeExpr, used for in Objective-C.
-CursorKind.OBJC_ENCODE_EXPR = CursorKind(138)
-
-# ObjCSelectorExpr used for in Objective-C.
-CursorKind.OBJC_SELECTOR_EXPR = CursorKind(139)
-
-# Objective-C's protocol expression.
-CursorKind.OBJC_PROTOCOL_EXPR = CursorKind(140)
-
-# An Objective-C "bridged" cast expression, which casts between
-# Objective-C pointers and C pointers, transferring ownership in the process.
-#
-# \code
-#   NSString *str = (__bridge_transfer NSString *)CFCreateString();
-# \endcode
-CursorKind.OBJC_BRIDGE_CAST_EXPR = CursorKind(141)
-
-# Represents a C++0x pack expansion that produces a sequence of
-# expressions.
-#
-# A pack expansion expression contains a pattern (which itself is an
-# expression) followed by an ellipsis. For example:
-CursorKind.PACK_EXPANSION_EXPR = CursorKind(142)
-
-# Represents an expression that computes the length of a parameter
-# pack.
-CursorKind.SIZE_OF_PACK_EXPR = CursorKind(143)
-
-# A statement whose specific kind is not exposed via this interface.
-#
-# Unexposed statements have the same operations as any other kind of statement;
-# one can extract their location information, spelling, children, etc. However,
-# the specific kind of the statement is not reported.
-CursorKind.UNEXPOSED_STMT = CursorKind(200)
-
-# A labelled statement in a function.
-CursorKind.LABEL_STMT = CursorKind(201)
-
-# A compound statement
-CursorKind.COMPOUND_STMT = CursorKind(202)
-
-# A case statement.
-CursorKind.CASE_STMT = CursorKind(203)
-
-# A default statement.
-CursorKind.DEFAULT_STMT = CursorKind(204)
-
-# An if statement.
-CursorKind.IF_STMT = CursorKind(205)
-
-# A switch statement.
-CursorKind.SWITCH_STMT = CursorKind(206)
-
-# A while statement.
-CursorKind.WHILE_STMT = CursorKind(207)
-
-# A do statement.
-CursorKind.DO_STMT = CursorKind(208)
-
-# A for statement.
-CursorKind.FOR_STMT = CursorKind(209)
-
-# A goto statement.
-CursorKind.GOTO_STMT = CursorKind(210)
-
-# An indirect goto statement.
-CursorKind.INDIRECT_GOTO_STMT = CursorKind(211)
-
-# A continue statement.
-CursorKind.CONTINUE_STMT = CursorKind(212)
-
-# A break statement.
-CursorKind.BREAK_STMT = CursorKind(213)
-
-# A return statement.
-CursorKind.RETURN_STMT = CursorKind(214)
-
-# A GNU-style inline assembler statement.
-CursorKind.ASM_STMT = CursorKind(215)
-
-# Objective-C's overall @try-@catch-@finally statement.
-CursorKind.OBJC_AT_TRY_STMT = CursorKind(216)
-
-# Objective-C's @catch statement.
-CursorKind.OBJC_AT_CATCH_STMT = CursorKind(217)
-
-# Objective-C's @finally statement.
-CursorKind.OBJC_AT_FINALLY_STMT = CursorKind(218)
-
-# Objective-C's @throw statement.
-CursorKind.OBJC_AT_THROW_STMT = CursorKind(219)
-
-# Objective-C's @synchronized statement.
-CursorKind.OBJC_AT_SYNCHRONIZED_STMT = CursorKind(220)
-
-# Objective-C's autorealease pool statement.
-CursorKind.OBJC_AUTORELEASE_POOL_STMT = CursorKind(221)
-
-# Objective-C's for collection statement.
-CursorKind.OBJC_FOR_COLLECTION_STMT = CursorKind(222)
-
-# C++'s catch statement.
-CursorKind.CXX_CATCH_STMT = CursorKind(223)
-
-# C++'s try statement.
-CursorKind.CXX_TRY_STMT = CursorKind(224)
-
-# C++'s for (* : *) statement.
-CursorKind.CXX_FOR_RANGE_STMT = CursorKind(225)
-
-# Windows Structured Exception Handling's try statement.
-CursorKind.SEH_TRY_STMT = CursorKind(226)
-
-# Windows Structured Exception Handling's except statement.
-CursorKind.SEH_EXCEPT_STMT = CursorKind(227)
-
-# Windows Structured Exception Handling's finally statement.
-CursorKind.SEH_FINALLY_STMT = CursorKind(228)
-
-# The null statement.
-CursorKind.NULL_STMT = CursorKind(230)
-
-# Adaptor class for mixing declarations with statements and expressions.
-CursorKind.DECL_STMT = CursorKind(231)
-
-###
-# Other Kinds
-
-# Cursor that represents the translation unit itself.
-#
-# The translation unit cursor exists primarily to act as the root cursor for
-# traversing the contents of a translation unit.
-CursorKind.TRANSLATION_UNIT = CursorKind(300)
-
-###
-# Attributes
-
-# An attribute whoe specific kind is note exposed via this interface
-CursorKind.UNEXPOSED_ATTR = CursorKind(400)
-
-CursorKind.IB_ACTION_ATTR = CursorKind(401)
-CursorKind.IB_OUTLET_ATTR = CursorKind(402)
-CursorKind.IB_OUTLET_COLLECTION_ATTR = CursorKind(403)
-
-CursorKind.CXX_FINAL_ATTR = CursorKind(404)
-CursorKind.CXX_OVERRIDE_ATTR = CursorKind(405)
-CursorKind.ANNOTATE_ATTR = CursorKind(406)
-CursorKind.ASM_LABEL_ATTR = CursorKind(407)
-
-###
-# Preprocessing
-CursorKind.PREPROCESSING_DIRECTIVE = CursorKind(500)
-CursorKind.MACRO_DEFINITION = CursorKind(501)
-CursorKind.MACRO_INSTANTIATION = CursorKind(502)
-CursorKind.INCLUSION_DIRECTIVE = CursorKind(503)
-
-### Cursors ###
-
-class Cursor(Structure):
-    """
-    The Cursor class represents a reference to an element within the AST. It
-    acts as a kind of iterator.
-    """
-    _fields_ = [("_kind_id", c_int), ("xdata", c_int), ("data", c_void_p * 3)]
-
-    @staticmethod
-    def from_location(tu, location):
-        return Cursor_get(tu, location)
-
-    def __eq__(self, other):
-        return Cursor_eq(self, other)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def is_definition(self):
-        """
-        Returns true if the declaration pointed at by the cursor is also a
-        definition of that entity.
-        """
-        return Cursor_is_def(self)
-
-    def get_definition(self):
-        """
-        If the cursor is a reference to a declaration or a declaration of
-        some entity, return a cursor that points to the definition of that
-        entity.
-        """
-        # TODO: Should probably check that this is either a reference or
-        # declaration prior to issuing the lookup.
-        return Cursor_def(self)
-
-    def get_usr(self):
-        """Return the Unified Symbol Resultion (USR) for the entity referenced
-        by the given cursor (or None).
-
-        A Unified Symbol Resolution (USR) is a string that identifies a
-        particular entity (function, class, variable, etc.) within a
-        program. USRs can be compared across translation units to determine,
-        e.g., when references in one translation refer to an entity defined in
-        another translation unit."""
-        return Cursor_usr(self)
-
-    @property
-    def kind(self):
-        """Return the kind of this cursor."""
-        return CursorKind.from_id(self._kind_id)
-
-    @property
-    def spelling(self):
-        """Return the spelling of the entity pointed at by the cursor."""
-        if not self.kind.is_declaration():
-            # FIXME: clang_getCursorSpelling should be fixed to not assert on
-            # this, for consistency with clang_getCursorUSR.
-            return None
-        if not hasattr(self, '_spelling'):
-            self._spelling = Cursor_spelling(self)
-        return self._spelling
-
-    @property
-    def displayname(self):
-        """
-        Return the display name for the entity referenced by this cursor.
-
-        The display name contains extra information that helps identify the cursor,
-        such as the parameters of a function or template or the arguments of a
-        class template specialization.
-        """
-        if not hasattr(self, '_displayname'):
-            self._displayname = Cursor_displayname(self)
-        return self._displayname
-
-    @property
-    def location(self):
-        """
-        Return the source location (the starting character) of the entity
-        pointed at by the cursor.
-        """
-        if not hasattr(self, '_loc'):
-            self._loc = Cursor_loc(self)
-        return self._loc
-
-    @property
-    def extent(self):
-        """
-        Return the source range (the range of text) occupied by the entity
-        pointed at by the cursor.
-        """
-        if not hasattr(self, '_extent'):
-            self._extent = Cursor_extent(self)
-        return self._extent
-
-    @property
-    def type(self):
-        """
-        Retrieve the Type (if any) of the entity pointed at by the cursor.
-        """
-        if not hasattr(self, '_type'):
-            self._type = Cursor_type(self)
-        return self._type
-
-    @property
-    def underlying_typedef_type(self):
-        """Return the underlying type of a typedef declaration.
-
-        Returns a Type for the typedef this cursor is a declaration for. If
-        the current cursor is not a typedef, this raises.
-        """
-        if not hasattr(self, '_underlying_type'):
-            assert self.kind.is_declaration()
-            self._underlying_type = Cursor_underlying_type(self)
-
-        return self._underlying_type
-
-    @property
-    def enum_type(self):
-        """Return the integer type of an enum declaration.
-
-        Returns a Type corresponding to an integer. If the cursor is not for an
-        enum, this raises.
-        """
-        if not hasattr(self, '_enum_type'):
-            assert self.kind == CursorKind.ENUM_DECL
-            self._enum_type = Cursor_enum_type(self)
-
-        return self._enum_type
-
-    @property
-    def objc_type_encoding(self):
-        """Return the Objective-C type encoding as a str."""
-        if not hasattr(self, '_objc_type_encoding'):
-            self._objc_type_encoding = Cursor_objc_type_encoding(self)
-
-        return self._objc_type_encoding
-
-    @property
-    def hash(self):
-        """Returns a hash of the cursor as an int."""
-        if not hasattr(self, '_hash'):
-            self._hash = Cursor_hash(self)
-
-        return self._hash
-
-    def get_children(self):
-        """Return an iterator for accessing the children of this cursor."""
-
-        # FIXME: Expose iteration from CIndex, PR6125.
-        def visitor(child, parent, children):
-            # FIXME: Document this assertion in API.
-            # FIXME: There should just be an isNull method.
-            assert child != Cursor_null()
-            children.append(child)
-            return 1 # continue
-        children = []
-        Cursor_visit(self, Cursor_visit_callback(visitor), children)
-        return iter(children)
-
-    @staticmethod
-    def from_result(res, fn, args):
-        assert isinstance(res, Cursor)
-        # FIXME: There should just be an isNull method.
-        if res == Cursor_null():
-            return None
-        return res
-
-
-### Type Kinds ###
-
-class TypeKind(object):
-    """
-    Describes the kind of type.
-    """
-
-    # The unique kind objects, indexed by id.
-    _kinds = []
-    _name_map = None
-
-    def __init__(self, value):
-        if value >= len(TypeKind._kinds):
-            TypeKind._kinds += [None] * (value - len(TypeKind._kinds) + 1)
-        if TypeKind._kinds[value] is not None:
-            raise ValueError,'TypeKind already loaded'
-        self.value = value
-        TypeKind._kinds[value] = self
-        TypeKind._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 TypeKind.__dict__.items():
-                if isinstance(value,TypeKind):
-                    self._name_map[value] = key
-        return self._name_map[self]
-
-    @property
-    def spelling(self):
-        """Retrieve the spelling of this TypeKind."""
-        return TypeKind_spelling(self.value)
-
-    @staticmethod
-    def from_id(id):
-        if id >= len(TypeKind._kinds) or TypeKind._kinds[id] is None:
-            raise ValueError,'Unknown type kind %d' % id
-        return TypeKind._kinds[id]
-
-    def __repr__(self):
-        return 'TypeKind.%s' % (self.name,)
-
-TypeKind_spelling = lib.clang_getTypeKindSpelling
-TypeKind_spelling.argtypes = [c_uint]
-TypeKind_spelling.restype = _CXString
-TypeKind_spelling.errcheck = _CXString.from_result
-
-
-TypeKind.INVALID = TypeKind(0)
-TypeKind.UNEXPOSED = TypeKind(1)
-TypeKind.VOID = TypeKind(2)
-TypeKind.BOOL = TypeKind(3)
-TypeKind.CHAR_U = TypeKind(4)
-TypeKind.UCHAR = TypeKind(5)
-TypeKind.CHAR16 = TypeKind(6)
-TypeKind.CHAR32 = TypeKind(7)
-TypeKind.USHORT = TypeKind(8)
-TypeKind.UINT = TypeKind(9)
-TypeKind.ULONG = TypeKind(10)
-TypeKind.ULONGLONG = TypeKind(11)
-TypeKind.UINT128 = TypeKind(12)
-TypeKind.CHAR_S = TypeKind(13)
-TypeKind.SCHAR = TypeKind(14)
-TypeKind.WCHAR = TypeKind(15)
-TypeKind.SHORT = TypeKind(16)
-TypeKind.INT = TypeKind(17)
-TypeKind.LONG = TypeKind(18)
-TypeKind.LONGLONG = TypeKind(19)
-TypeKind.INT128 = TypeKind(20)
-TypeKind.FLOAT = TypeKind(21)
-TypeKind.DOUBLE = TypeKind(22)
-TypeKind.LONGDOUBLE = TypeKind(23)
-TypeKind.NULLPTR = TypeKind(24)
-TypeKind.OVERLOAD = TypeKind(25)
-TypeKind.DEPENDENT = TypeKind(26)
-TypeKind.OBJCID = TypeKind(27)
-TypeKind.OBJCCLASS = TypeKind(28)
-TypeKind.OBJCSEL = TypeKind(29)
-TypeKind.COMPLEX = TypeKind(100)
-TypeKind.POINTER = TypeKind(101)
-TypeKind.BLOCKPOINTER = TypeKind(102)
-TypeKind.LVALUEREFERENCE = TypeKind(103)
-TypeKind.RVALUEREFERENCE = TypeKind(104)
-TypeKind.RECORD = TypeKind(105)
-TypeKind.ENUM = TypeKind(106)
-TypeKind.TYPEDEF = TypeKind(107)
-TypeKind.OBJCINTERFACE = TypeKind(108)
-TypeKind.OBJCOBJECTPOINTER = TypeKind(109)
-TypeKind.FUNCTIONNOPROTO = TypeKind(110)
-TypeKind.FUNCTIONPROTO = TypeKind(111)
-TypeKind.CONSTANTARRAY = TypeKind(112)
-TypeKind.VECTOR = TypeKind(113)
-
-class Type(Structure):
-    """
-    The type of an element in the abstract syntax tree.
-    """
-    _fields_ = [("_kind_id", c_int), ("data", c_void_p * 2)]
-
-    @property
-    def kind(self):
-        """Return the kind of this type."""
-        return TypeKind.from_id(self._kind_id)
-
-    def argument_types(self):
-        """Retrieve a container for the non-variadic arguments for this type.
-
-        The returned object is iterable and indexable. Each item in the
-        container is a Type instance.
-        """
-        class ArgumentsIterator(collections.Sequence):
-            def __init__(self, parent):
-                self.parent = parent
-                self.length = None
-
-            def __len__(self):
-                if self.length is None:
-                    self.length = Type_get_num_arg_types(self.parent)
-
-                return self.length
-
-            def __getitem__(self, key):
-                # FIXME Support slice objects.
-                if not isinstance(key, int):
-                    raise TypeError("Must supply a non-negative int.")
-
-                if key < 0:
-                    raise IndexError("Only non-negative indexes are accepted.")
-
-                if key >= len(self):
-                    raise IndexError("Index greater than container length: "
-                                     "%d > %d" % ( key, len(self) ))
-
-                result = Type_get_arg_type(self.parent, key)
-                if result.kind == TypeKind.INVALID:
-                    raise IndexError("Argument could not be retrieved.")
-
-                return result
-
-        assert self.kind == TypeKind.FUNCTIONPROTO
-        return ArgumentsIterator(self)
-
-    @property
-    def element_type(self):
-        """Retrieve the Type of elements within this Type.
-
-        If accessed on a type that is not an array, complex, or vector type, an
-        exception will be raised.
-        """
-        result = Type_get_element_type(self)
-        if result.kind == TypeKind.INVALID:
-            raise Exception('Element type not available on this type.')
-
-        return result
-
-    @property
-    def element_count(self):
-        """Retrieve the number of elements in this type.
-
-        Returns an int.
-
-        If the Type is not an array or vector, this raises.
-        """
-        result = Type_get_num_elements(self)
-        if result < 0:
-            raise Exception('Type does not have elements.')
-
-        return result
-
-    @staticmethod
-    def from_result(res, fn, args):
-        assert isinstance(res, Type)
-        return res
-
-    def get_canonical(self):
-        """
-        Return the canonical type for a Type.
-
-        Clang's type system explicitly models typedefs and all the
-        ways a specific type can be represented.  The canonical type
-        is the underlying type with all the "sugar" removed.  For
-        example, if 'T' is a typedef for 'int', the canonical type for
-        'T' would be 'int'.
-        """
-        return Type_get_canonical(self)
-
-    def is_const_qualified(self):
-        """Determine whether a Type has the "const" qualifier set.
-
-        This does not look through typedefs that may have added "const"
-        at a different level.
-        """
-        return Type_is_const_qualified(self)
-
-    def is_volatile_qualified(self):
-        """Determine whether a Type has the "volatile" qualifier set.
-
-        This does not look through typedefs that may have added "volatile"
-        at a different level.
-        """
-        return Type_is_volatile_qualified(self)
-
-    def is_restrict_qualified(self):
-        """Determine whether a Type has the "restrict" qualifier set.
-
-        This does not look through typedefs that may have added "restrict" at
-        a different level.
-        """
-        return Type_is_restrict_qualified(self)
-
-    def is_function_variadic(self):
-        """Determine whether this function Type is a variadic function type."""
-        assert self.kind == TypeKind.FUNCTIONPROTO
-
-        return Type_is_variadic(self)
-
-    def is_pod(self):
-        """Determine whether this Type represents plain old data (POD)."""
-        return Type_is_pod(self)
-
-    def get_pointee(self):
-        """
-        For pointer types, returns the type of the pointee.
-        """
-        return Type_get_pointee(self)
-
-    def get_declaration(self):
-        """
-        Return the cursor for the declaration of the given type.
-        """
-        return Type_get_declaration(self)
-
-    def get_result(self):
-        """
-        Retrieve the result type associated with a function type.
-        """
-        return Type_get_result(self)
-
-    def get_array_element_type(self):
-        """
-        Retrieve the type of the elements of the array type.
-        """
-        return Type_get_array_element(self)
-
-    def get_array_size(self):
-        """
-        Retrieve the size of the constant array.
-        """
-        return Type_get_array_size(self)
-
-    def __eq__(self, other):
-        if type(other) != type(self):
-            return False
-
-        return Type_equal(self, other)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-## CIndex Objects ##
-
-# CIndex objects (derived from ClangObject) are essentially lightweight
-# wrappers attached to some underlying object, which is exposed via CIndex as
-# a void*.
-
-class ClangObject(object):
-    """
-    A helper for Clang objects. This class helps act as an intermediary for
-    the ctypes library and the Clang CIndex library.
-    """
-    def __init__(self, obj):
-        assert isinstance(obj, c_object_p) and obj
-        self.obj = self._as_parameter_ = obj
-
-    def from_param(self):
-        return self._as_parameter_
-
-
-class _CXUnsavedFile(Structure):
-    """Helper for passing unsaved file arguments."""
-    _fields_ = [("name", c_char_p), ("contents", c_char_p), ('length', c_ulong)]
-
-## Diagnostic Conversion ##
-
-_clang_getNumDiagnostics = lib.clang_getNumDiagnostics
-_clang_getNumDiagnostics.argtypes = [c_object_p]
-_clang_getNumDiagnostics.restype = c_uint
-
-_clang_getDiagnostic = lib.clang_getDiagnostic
-_clang_getDiagnostic.argtypes = [c_object_p, c_uint]
-_clang_getDiagnostic.restype = c_object_p
-
-_clang_disposeDiagnostic = lib.clang_disposeDiagnostic
-_clang_disposeDiagnostic.argtypes = [Diagnostic]
-
-_clang_getDiagnosticSeverity = lib.clang_getDiagnosticSeverity
-_clang_getDiagnosticSeverity.argtypes = [Diagnostic]
-_clang_getDiagnosticSeverity.restype = c_int
-
-_clang_getDiagnosticLocation = lib.clang_getDiagnosticLocation
-_clang_getDiagnosticLocation.argtypes = [Diagnostic]
-_clang_getDiagnosticLocation.restype = SourceLocation
-
-_clang_getDiagnosticSpelling = lib.clang_getDiagnosticSpelling
-_clang_getDiagnosticSpelling.argtypes = [Diagnostic]
-_clang_getDiagnosticSpelling.restype = _CXString
-_clang_getDiagnosticSpelling.errcheck = _CXString.from_result
-
-_clang_getDiagnosticNumRanges = lib.clang_getDiagnosticNumRanges
-_clang_getDiagnosticNumRanges.argtypes = [Diagnostic]
-_clang_getDiagnosticNumRanges.restype = c_uint
-
-_clang_getDiagnosticRange = lib.clang_getDiagnosticRange
-_clang_getDiagnosticRange.argtypes = [Diagnostic, c_uint]
-_clang_getDiagnosticRange.restype = SourceRange
-
-_clang_getDiagnosticNumFixIts = lib.clang_getDiagnosticNumFixIts
-_clang_getDiagnosticNumFixIts.argtypes = [Diagnostic]
-_clang_getDiagnosticNumFixIts.restype = c_uint
-
-_clang_getDiagnosticFixIt = lib.clang_getDiagnosticFixIt
-_clang_getDiagnosticFixIt.argtypes = [Diagnostic, c_uint, POINTER(SourceRange)]
-_clang_getDiagnosticFixIt.restype = _CXString
-_clang_getDiagnosticFixIt.errcheck = _CXString.from_result
-
-_clang_getDiagnosticCategory = lib.clang_getDiagnosticCategory
-_clang_getDiagnosticCategory.argtypes = [Diagnostic]
-_clang_getDiagnosticCategory.restype = c_uint
-
-_clang_getDiagnosticCategoryName = lib.clang_getDiagnosticCategoryName
-_clang_getDiagnosticCategoryName.argtypes = [c_uint]
-_clang_getDiagnosticCategoryName.restype = _CXString
-_clang_getDiagnosticCategoryName.errcheck = _CXString.from_result
-
-_clang_getDiagnosticOption = lib.clang_getDiagnosticOption
-_clang_getDiagnosticOption.argtypes = [Diagnostic, POINTER(_CXString)]
-_clang_getDiagnosticOption.restype = _CXString
-_clang_getDiagnosticOption.errcheck = _CXString.from_result
-
-###
-
-class CompletionChunk:
-    class Kind:
-        def __init__(self, name):
-            self.name = name
-
-        def __str__(self):
-            return self.name
-
-        def __repr__(self):
-            return "<ChunkKind: %s>" % self
-
-    def __init__(self, completionString, key):
-        self.cs = completionString
-        self.key = key
-
-    def __repr__(self):
-        return "{'" + self.spelling + "', " + str(self.kind) + "}"
-
-    @property
-    def spelling(self):
-        return _clang_getCompletionChunkText(self.cs, self.key).spelling
-
-    @property
-    def kind(self):
-        res = _clang_getCompletionChunkKind(self.cs, self.key)
-        return completionChunkKindMap[res]
-
-    @property
-    def string(self):
-        res = _clang_getCompletionChunkCompletionString(self.cs, self.key)
-
-        if (res):
-          return CompletionString(res)
-        else:
-          None
-
-    def isKindOptional(self):
-      return self.kind == completionChunkKindMap[0]
-
-    def isKindTypedText(self):
-      return self.kind == completionChunkKindMap[1]
-
-    def isKindPlaceHolder(self):
-      return self.kind == completionChunkKindMap[3]
-
-    def isKindInformative(self):
-      return self.kind == completionChunkKindMap[4]
-
-    def isKindResultType(self):
-      return self.kind == completionChunkKindMap[15]
-
-completionChunkKindMap = {
-            0: CompletionChunk.Kind("Optional"),
-            1: CompletionChunk.Kind("TypedText"),
-            2: CompletionChunk.Kind("Text"),
-            3: CompletionChunk.Kind("Placeholder"),
-            4: CompletionChunk.Kind("Informative"),
-            5: CompletionChunk.Kind("CurrentParameter"),
-            6: CompletionChunk.Kind("LeftParen"),
-            7: CompletionChunk.Kind("RightParen"),
-            8: CompletionChunk.Kind("LeftBracket"),
-            9: CompletionChunk.Kind("RightBracket"),
-            10: CompletionChunk.Kind("LeftBrace"),
-            11: CompletionChunk.Kind("RightBrace"),
-            12: CompletionChunk.Kind("LeftAngle"),
-            13: CompletionChunk.Kind("RightAngle"),
-            14: CompletionChunk.Kind("Comma"),
-            15: CompletionChunk.Kind("ResultType"),
-            16: CompletionChunk.Kind("Colon"),
-            17: CompletionChunk.Kind("SemiColon"),
-            18: CompletionChunk.Kind("Equal"),
-            19: CompletionChunk.Kind("HorizontalSpace"),
-            20: CompletionChunk.Kind("VerticalSpace")}
-
-class CompletionString(ClangObject):
-    class Availability:
-        def __init__(self, name):
-            self.name = name
-
-        def __str__(self):
-            return self.name
-
-        def __repr__(self):
-            return "<Availability: %s>" % self
-
-    def __len__(self):
-        return _clang_getNumCompletionChunks(self.obj)
-
-    def __getitem__(self, key):
-        if len(self) <= key:
-            raise IndexError
-        return CompletionChunk(self.obj, key)
-
-    @property
-    def priority(self):
-        return _clang_getCompletionPriority(self.obj)
-
-    @property
-    def availability(self):
-        res = _clang_getCompletionAvailability(self.obj)
-        return availabilityKinds[res]
-
-    def __repr__(self):
-        return " | ".join([str(a) for a in self]) \
-               + " || Priority: " + str(self.priority) \
-               + " || Availability: " + str(self.availability)
-
-availabilityKinds = {
-            0: CompletionChunk.Kind("Available"),
-            1: CompletionChunk.Kind("Deprecated"),
-            2: CompletionChunk.Kind("NotAvailable")}
-
-class CodeCompletionResult(Structure):
-    _fields_ = [('cursorKind', c_int), ('completionString', c_object_p)]
-
-    def __repr__(self):
-        return str(CompletionString(self.completionString))
-
-    @property
-    def kind(self):
-        return CursorKind.from_id(self.cursorKind)
-
-    @property
-    def string(self):
-        return CompletionString(self.completionString)
-
-class CCRStructure(Structure):
-    _fields_ = [('results', POINTER(CodeCompletionResult)),
-                ('numResults', c_int)]
-
-    def __len__(self):
-        return self.numResults
-
-    def __getitem__(self, key):
-        if len(self) <= key:
-            raise IndexError
-
-        return self.results[key]
-
-class CodeCompletionResults(ClangObject):
-    def __init__(self, ptr):
-        assert isinstance(ptr, POINTER(CCRStructure)) and ptr
-        self.ptr = self._as_parameter_ = ptr
-
-    def from_param(self):
-        return self._as_parameter_
-
-    def __del__(self):
-        CodeCompletionResults_dispose(self)
-
-    @property
-    def results(self):
-        return self.ptr.contents
-
-    @property
-    def diagnostics(self):
-        class DiagnosticsItr:
-            def __init__(self, ccr):
-                self.ccr= ccr
-
-            def __len__(self):
-                return int(_clang_codeCompleteGetNumDiagnostics(self.ccr))
-
-            def __getitem__(self, key):
-                return _clang_codeCompleteGetDiagnostic(self.ccr, key)
-
-        return DiagnosticsItr(self)
-
-
-class Index(ClangObject):
-    """
-    The Index type provides the primary interface to the Clang CIndex library,
-    primarily by providing an interface for reading and parsing translation
-    units.
-    """
-
-    @staticmethod
-    def create(excludeDecls=False):
-        """
-        Create a new Index.
-        Parameters:
-        excludeDecls -- Exclude local declarations from translation units.
-        """
-        return Index(Index_create(excludeDecls, 0))
-
-    def __del__(self):
-        Index_dispose(self)
-
-    def read(self, path):
-        """Load the translation unit from the given AST file."""
-        ptr = TranslationUnit_read(self, path)
-        if ptr:
-            return TranslationUnit(ptr)
-        return None
-
-    def parse(self, path, args = [], unsaved_files = [], options = 0):
-        """
-        Load the translation unit from the given source code file by running
-        clang and generating the AST before loading. Additional command line
-        parameters can be passed to clang via the args parameter.
-
-        In-memory contents for files can be provided by passing a list of pairs
-        to as unsaved_files, the first item should be the filenames to be mapped
-        and the second should be the contents to be substituted for the
-        file. The contents may be passed as strings or file objects.
-        """
-        arg_array = 0
-        if len(args):
-            arg_array = (c_char_p * len(args))(* args)
-        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
-                if not isinstance(value, str):
-                    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 = TranslationUnit_parse(self, path, arg_array, len(args),
-                                    unsaved_files_array, len(unsaved_files),
-                                    options)
-        if ptr:
-            return TranslationUnit(ptr)
-        return None
-
-
-class TranslationUnit(ClangObject):
-    """
-    The TranslationUnit class represents a source code translation unit and
-    provides read-only access to its top-level declarations.
-    """
-
-    def __init__(self, ptr):
-        ClangObject.__init__(self, ptr)
-
-    def __del__(self):
-        TranslationUnit_dispose(self)
-
-    @property
-    def cursor(self):
-        """Retrieve the cursor that represents the given translation unit."""
-        return TranslationUnit_cursor(self)
-
-    @property
-    def spelling(self):
-        """Get the original translation unit source file name."""
-        return TranslationUnit_spelling(self)
-
-    def get_includes(self):
-        """
-        Return an iterable sequence of FileInclusion objects that describe the
-        sequence of inclusions in a translation unit. The first object in
-        this sequence is always the input file. Note that this method will not
-        recursively iterate over header files included through precompiled
-        headers.
-        """
-        def visitor(fobj, lptr, depth, includes):
-            if depth > 0:
-                loc = lptr.contents
-                includes.append(FileInclusion(loc.file, File(fobj), loc, depth))
-
-        # Automatically adapt CIndex/ctype pointers to python objects
-        includes = []
-        TranslationUnit_includes(self,
-                                 TranslationUnit_includes_callback(visitor),
-                                 includes)
-        return iter(includes)
-
-    @property
-    def diagnostics(self):
-        """
-        Return an iterable (and indexable) object containing the diagnostics.
-        """
-        class DiagIterator:
-            def __init__(self, tu):
-                self.tu = tu
-
-            def __len__(self):
-                return int(_clang_getNumDiagnostics(self.tu))
-
-            def __getitem__(self, key):
-                diag = _clang_getDiagnostic(self.tu, key)
-                if not diag:
-                    raise IndexError
-                return Diagnostic(diag)
-
-        return DiagIterator(self)
-
-    def reparse(self, unsaved_files = [], options = 0):
-        """
-        Reparse an already parsed translation unit.
-
-        In-memory contents for files can be provided by passing a list of pairs
-        as unsaved_files, the first items should be the filenames to be mapped
-        and the second should be the contents to be substituted for the
-        file. The contents may be passed as strings or file objects.
-        """
-        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
-                if not isinstance(value, str):
-                    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 = TranslationUnit_reparse(self, len(unsaved_files),
-                                      unsaved_files_array,
-                                      options)
-    def codeComplete(self, path, line, column, unsaved_files = [], options = 0):
-        """
-        Code complete in this translation unit.
-
-        In-memory contents for files can be provided by passing a list of pairs
-        as unsaved_files, the first items should be the filenames to be mapped
-        and the second should be the contents to be substituted for the
-        file. The contents may be passed as strings or file objects.
-        """
-        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
-                if not isinstance(value, str):
-                    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 = TranslationUnit_codeComplete(self, path,
-                                           line, column,
-                                           unsaved_files_array,
-                                           len(unsaved_files),
-                                           options)
-        if ptr:
-            return CodeCompletionResults(ptr)
-        return None
-
-class File(ClangObject):
-    """
-    The File class represents a particular source file that is part of a
-    translation unit.
-    """
-
-    @staticmethod
-    def from_name(translation_unit, file_name):
-        """Retrieve a file handle within the given translation unit."""
-        return File(File_getFile(translation_unit, file_name))
-
-    @property
-    def name(self):
-        """Return the complete file and path name of the file."""
-        return _CXString_getCString(File_name(self))
-
-    @property
-    def time(self):
-        """Return the last modification time of the file."""
-        return File_time(self)
-
-    def __str__(self):
-        return self.name
-
-    def __repr__(self):
-        return "<File: %s>" % (self.name)
-
-class FileInclusion(object):
-    """
-    The FileInclusion class represents the inclusion of one source file by
-    another via a '#include' directive or as the input file for the translation
-    unit. This class provides information about the included file, the including
-    file, the location of the '#include' directive and the depth of the included
-    file in the stack. Note that the input file has depth 0.
-    """
-
-    def __init__(self, src, tgt, loc, depth):
-        self.source = src
-        self.include = tgt
-        self.location = loc
-        self.depth = depth
-
-    @property
-    def is_input_file(self):
-        """True if the included file is the input file."""
-        return self.depth == 0
-
-# Additional Functions and Types
-
-# String Functions
-_CXString_dispose = lib.clang_disposeString
-_CXString_dispose.argtypes = [_CXString]
-
-_CXString_getCString = lib.clang_getCString
-_CXString_getCString.argtypes = [_CXString]
-_CXString_getCString.restype = c_char_p
-
-# Source Location Functions
-SourceLocation_loc = lib.clang_getInstantiationLocation
-SourceLocation_loc.argtypes = [SourceLocation, POINTER(c_object_p),
-                               POINTER(c_uint), POINTER(c_uint),
-                               POINTER(c_uint)]
-
-SourceLocation_getLocation = lib.clang_getLocation
-SourceLocation_getLocation.argtypes = [TranslationUnit, File, c_uint, c_uint]
-SourceLocation_getLocation.restype = SourceLocation
-
-SourceLocation_equalLocations = lib.clang_equalLocations
-SourceLocation_equalLocations.argtypes = [SourceLocation, SourceLocation]
-SourceLocation_equalLocations.restype = bool
-
-# Source Range Functions
-SourceRange_getRange = lib.clang_getRange
-SourceRange_getRange.argtypes = [SourceLocation, SourceLocation]
-SourceRange_getRange.restype = SourceRange
-
-SourceRange_start = lib.clang_getRangeStart
-SourceRange_start.argtypes = [SourceRange]
-SourceRange_start.restype = SourceLocation
-
-SourceRange_end = lib.clang_getRangeEnd
-SourceRange_end.argtypes = [SourceRange]
-SourceRange_end.restype = SourceLocation
-
-SourceRange_equalRanges = lib.clang_equalRanges
-SourceRange_equalRanges.argtypes = [SourceRange, SourceRange]
-SourceRange_equalRanges.restype = bool
-
-# CursorKind Functions
-CursorKind_is_decl = lib.clang_isDeclaration
-CursorKind_is_decl.argtypes = [CursorKind]
-CursorKind_is_decl.restype = bool
-
-CursorKind_is_ref = lib.clang_isReference
-CursorKind_is_ref.argtypes = [CursorKind]
-CursorKind_is_ref.restype = bool
-
-CursorKind_is_expr = lib.clang_isExpression
-CursorKind_is_expr.argtypes = [CursorKind]
-CursorKind_is_expr.restype = bool
-
-CursorKind_is_stmt = lib.clang_isStatement
-CursorKind_is_stmt.argtypes = [CursorKind]
-CursorKind_is_stmt.restype = bool
-
-CursorKind_is_attribute = lib.clang_isAttribute
-CursorKind_is_attribute.argtypes = [CursorKind]
-CursorKind_is_attribute.restype = bool
-
-CursorKind_is_inv = lib.clang_isInvalid
-CursorKind_is_inv.argtypes = [CursorKind]
-CursorKind_is_inv.restype = bool
-
-CursorKind_is_translation_unit = lib.clang_isTranslationUnit
-CursorKind_is_translation_unit.argtypes = [CursorKind]
-CursorKind_is_translation_unit.restype = bool
-
-CursorKind_is_preprocessing = lib.clang_isPreprocessing
-CursorKind_is_preprocessing.argtypes = [CursorKind]
-CursorKind_is_preprocessing.restype = bool
-
-CursorKind_is_unexposed = lib.clang_isUnexposed
-CursorKind_is_unexposed.argtypes = [CursorKind]
-CursorKind_is_unexposed.restype = bool
-
-# Cursor Functions
-# TODO: Implement this function
-Cursor_get = lib.clang_getCursor
-Cursor_get.argtypes = [TranslationUnit, SourceLocation]
-Cursor_get.restype = Cursor
-
-Cursor_null = lib.clang_getNullCursor
-Cursor_null.restype = Cursor
-
-Cursor_usr = lib.clang_getCursorUSR
-Cursor_usr.argtypes = [Cursor]
-Cursor_usr.restype = _CXString
-Cursor_usr.errcheck = _CXString.from_result
-
-Cursor_is_def = lib.clang_isCursorDefinition
-Cursor_is_def.argtypes = [Cursor]
-Cursor_is_def.restype = bool
-
-Cursor_def = lib.clang_getCursorDefinition
-Cursor_def.argtypes = [Cursor]
-Cursor_def.restype = Cursor
-Cursor_def.errcheck = Cursor.from_result
-
-Cursor_eq = lib.clang_equalCursors
-Cursor_eq.argtypes = [Cursor, Cursor]
-Cursor_eq.restype = bool
-
-Cursor_hash = lib.clang_hashCursor
-Cursor_hash.argtypes = [Cursor]
-Cursor_hash.restype = c_uint
-
-Cursor_spelling = lib.clang_getCursorSpelling