13391439098

Committed 18 Feb 2025 01:15PM UTC coverage: 83.553% (-2.0%) from 85.503%

Build # 13391439098

Build Type

push

github

Committed by

trolldbois

Commit Message

update some doc

Run Details

2032 of 2432 relevant lines covered (83.55%)

0.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.51

/ctypeslib/codegen/clangparser.py

"""clangparser - use clang to get preprocess a source code."""

import logging
import os
import collections

from clang.cindex import Index, TranslationUnit
from clang.cindex import TypeKind

from ctypeslib.codegen import cursorhandler
from ctypeslib.codegen import typedesc
from ctypeslib.codegen import typehandler
from ctypeslib.codegen import util
from ctypeslib.codegen.handler import DuplicateDefinitionException
from ctypeslib.codegen.handler import InvalidDefinitionError
from ctypeslib.codegen.handler import InvalidTranslationUnitException

log = logging.getLogger("clangparser")


class Clang_Parser:
    """
    Will parse libclang AST tree to create a representation of Types and
    different others source code objects objets as described in Typedesc.

    For each Declaration a declaration will be saved, and the type of that
    declaration will be cached and saved.
    """

    has_values = {
        "Enumeration",
        "Function",
        "FunctionType",
        "OperatorFunction",
        "Method",
        "Constructor",
        "Destructor",
        "OperatorMethod",
        "Converter",
    }

    # FIXME, macro definition __SIZEOF_DOUBLE__
    ctypes_typename = {
        TypeKind.VOID: "None",  # because ctypes.POINTER(None) == c_void_p
        TypeKind.BOOL: "c_bool",
        TypeKind.CHAR_U: "c_ubyte",  # ?? used for PADDING
        TypeKind.UCHAR: "c_ubyte",  # unsigned char
        TypeKind.CHAR16: "c_wchar",  # char16_t
        TypeKind.CHAR32: "c_wchar",  # char32_t
        TypeKind.USHORT: "c_ushort",
        TypeKind.UINT: "c_uint",
        TypeKind.ULONG: "TBD",
        TypeKind.ULONGLONG: "c_ulonglong",
        TypeKind.UINT128: "c_uint128",  # FIXME
        TypeKind.CHAR_S: "c_char",  # char
        TypeKind.SCHAR: "c_byte",  # signed char
        TypeKind.WCHAR: "c_wchar",
        TypeKind.SHORT: "c_short",
        TypeKind.INT: "c_int",
        TypeKind.LONG: "TBD",
        TypeKind.LONGLONG: "c_longlong",
        TypeKind.INT128: "c_int128",  # FIXME
        TypeKind.FLOAT: "c_float",
        TypeKind.DOUBLE: "c_double",
        TypeKind.LONGDOUBLE: "c_longdouble",
        TypeKind.POINTER: "POINTER_T",
        TypeKind.NULLPTR: "c_void_p",
    }

    def __init__(self, flags):
        self.all = collections.OrderedDict()
        # a shortcut to identify registered decl in cases of records
        self.all_set = set()
        self.cpp_data = {}
        self._unhandled = []
        self.fields = {}
        self.tu = None
        self.tu_options = None
        self.flags = flags
        self.ctypes_sizes = {}
        self.init_parsing_options()
        self.make_ctypes_convertor(flags)
        self.cursorkind_handler = cursorhandler.CursorHandler(self)
        self.typekind_handler = typehandler.TypeHandler(self)
        self.__filter_location = None
        self.__processed_location = set()

    def init_parsing_options(self):
        """Set the Translation Unit to skip functions bodies per default."""
        self.tu_options = TranslationUnit.PARSE_SKIP_FUNCTION_BODIES

    def activate_macros_parsing(self):
        """Activates the detailled code parsing options in the Translation
        Unit."""
        self.tu_options |= TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD

    def activate_comment_parsing(self):
        """Activates the comment parsing options in the Translation Unit."""
        self.tu_options |= TranslationUnit.PARSE_INCLUDE_BRIEF_COMMENTS_IN_CODE_COMPLETION

    def deactivate_function_body_parsing(self):
        self.tu_options |= TranslationUnit.PARSE_SKIP_FUNCTION_BODIES

    def filter_location(self, src_files):
        self.__filter_location = [os.path.abspath(f) for f in src_files]

    def parse(self, filename):
        """
        . reads 1 file
        . if there is a compilation error, print a warning
        . get root cursor and recurse
        . for each STRUCT_DECL, register a new struct type
        . for each UNION_DECL, register a new union type
        . for each TYPEDEF_DECL, register a new alias/typdef to the underlying type
            - underlying type is cursor.type.get_declaration() for Record
        . for each VAR_DECL, register a Variable
        . for each TYPEREF ??
        """
        if os.path.abspath(filename) in self.__processed_location:
            return
        index = Index.create()
        translation_unit = index.parse(filename, self.flags, options=self.tu_options)
        if not translation_unit:
            log.warning("unable to load input")
            return
        self._parse_tu_diagnostics(translation_unit, filename)
        self.tu = translation_unit
        root = self.tu.cursor
        for node in root.get_children():
            self.start_element(node)
        return

    def parse_string(self, input_data, lang="c", all_warnings=False, flags=None):
        """Use this parser on a memory string/file, instead of a file on disk"""
        translation_unit = util.get_tu(input_data, lang, all_warnings, flags)
        self._parse_tu_diagnostics(translation_unit, "memory_input.c")
        self.tu = translation_unit
        root = self.tu.cursor
        for node in root.get_children():
            self.start_element(node)

    @staticmethod
    def _parse_tu_diagnostics(translation_unit, input_filename):
        if len(translation_unit.diagnostics) == 0:
            return
        errors = []
        for diagnostic in translation_unit.diagnostics:
            msg = (
                f"{diagnostic.spelling} ({diagnostic.location.file}:{diagnostic.location.line}:"
                f"{diagnostic.location.column}) during processing {input_filename}"
            )
            log.warning(msg)
            if diagnostic.severity > 2:
                errors.append(msg)
        if len(errors) > 0:
            log.warning("Source code has %d error. Please fix.", len(errors))
            # code.interact(local=locals())
            raise InvalidTranslationUnitException(errors[0])

    def start_element(self, node):
        """Recurses in children of this node"""
        if node is None:
            return None

        if self.__filter_location is not None:
            # dont even parse includes.
            # FIXME: go back on dependencies ?
            if node.location.file is None:
                return None
            filepath = os.path.abspath(node.location.file.name)
            if filepath not in self.__filter_location:
                if not filepath.startswith("/usr"):
                    log.debug("skipping include '%s'", filepath)
                return None
        # find and call the handler for this element
        log.debug(
            "%s:%d: Found a %s|%s|%s",
            node.location.file,
            node.location.line,
            node.kind.name,
            node.displayname,
            node.spelling,
        )
        # build stuff.
        try:
            stop_recurse = self.parse_cursor(node)
            if node.location.file is not None:
                filepath = os.path.abspath(node.location.file.name)
                self.__processed_location.add(filepath)
            # Signature of parse_cursor is:
            # if the fn returns True, do not recurse into children.
            # anything else will be ignored.
            if stop_recurse is not False:  # True:
                return None
            # if fn returns something, if this element has children, treat
            # them.
            for child in node.get_children():
                self.start_element(child)
        except InvalidDefinitionError:
            log.exception("Invalid definition")
            # if the definition is invalid
        # startElement returns None.
        return None

    def register(self, name, obj):
        """Registers an unique type description"""
        if (name, obj) in self.all_set:
            log.debug("register: %s already defined: %s", name, obj.name)
            return self.all[name]
        if name in self.all:
            if not isinstance(self.all[name], typedesc.Structure) or (self.all[name].members is not None):
                # code.interact(local=locals())
                raise DuplicateDefinitionException(
                    f"register: {name} which has a previous incompatible definition: {obj.name}"
                    f"\ndefined here: {obj.location}"
                    f"\npreviously defined here: {self.all[name].location}"
                )
            if isinstance(self.all[name], typedesc.Structure) and (self.all[name].members is None):
                return obj
        log.debug("register: %s ", name)
        self.all[name] = obj
        self.all_set.add((name, obj))
        return obj

    def get_registered(self, name):
        """Returns a registered type description"""
        return self.all[name]

    def is_registered(self, name):
        """Checks if a named type description is registered"""
        return name in self.all

    def remove_registered(self, name):
        """Removes a named type"""
        log.debug("Unregister %s", name)
        self.all_set.remove((name, self.all[name]))
        del self.all[name]

    def make_ctypes_convertor(self, _flags):
        """
        Fix clang types to ctypes conversion for this parsing instance.
        Some architecture dependent size types have to be changed if the target
        architecture is not the same as local
        """
        # NOTE: one could also use the __SIZEOF_x__ MACROs to obtain sizes.
        translation_unit = util.get_tu(
            """
typedef short short_t;
typedef int int_t;
typedef long long_t;
typedef long long longlong_t;
typedef float float_t;
typedef double double_t;
typedef long double longdouble_t;
typedef void* pointer_t;""",
            flags=_flags,
        )
        size = util.get_cursor(translation_unit, "short_t").type.get_size() * 8
        self.ctypes_typename[TypeKind.SHORT] = f"c_int{size:d}"
        self.ctypes_typename[TypeKind.USHORT] = f"c_uint{size:d}"
        self.ctypes_sizes[TypeKind.SHORT] = size
        self.ctypes_sizes[TypeKind.USHORT] = size

        size = util.get_cursor(translation_unit, "int_t").type.get_size() * 8
        self.ctypes_typename[TypeKind.INT] = f"c_int{size:d}"
        self.ctypes_typename[TypeKind.UINT] = f"c_uint{size:d}"
        self.ctypes_sizes[TypeKind.INT] = size
        self.ctypes_sizes[TypeKind.UINT] = size

        size = util.get_cursor(translation_unit, "long_t").type.get_size() * 8
        self.ctypes_typename[TypeKind.LONG] = f"c_int{size:d}"
        self.ctypes_typename[TypeKind.ULONG] = f"c_uint{size:d}"
        self.ctypes_sizes[TypeKind.LONG] = size
        self.ctypes_sizes[TypeKind.ULONG] = size

        size = util.get_cursor(translation_unit, "longlong_t").type.get_size() * 8
        self.ctypes_typename[TypeKind.LONGLONG] = f"c_int{size:d}"
        self.ctypes_typename[TypeKind.ULONGLONG] = f"c_uint{size:d}"
        self.ctypes_sizes[TypeKind.LONGLONG] = size
        self.ctypes_sizes[TypeKind.ULONGLONG] = size

        # FIXME : Float && http://en.wikipedia.org/wiki/Long_double
        size0 = util.get_cursor(translation_unit, "float_t").type.get_size() * 8
        size1 = util.get_cursor(translation_unit, "double_t").type.get_size() * 8
        size2 = util.get_cursor(translation_unit, "longdouble_t").type.get_size() * 8
        # 2014-01 stop generating crap.
        # 2015-01 reverse until better solution is found
        # the idea is that you cannot assume a c_double will be same format as a c_long_double.
        # at least this pass size TU
        if size1 != size2:
            self.ctypes_typename[TypeKind.LONGDOUBLE] = "c_long_double_t"
        else:
            self.ctypes_typename[TypeKind.LONGDOUBLE] = "c_double"

        self.ctypes_sizes[TypeKind.FLOAT] = size0
        self.ctypes_sizes[TypeKind.DOUBLE] = size1
        self.ctypes_sizes[TypeKind.LONGDOUBLE] = size2

        # save the target pointer size.
        size = util.get_cursor(translation_unit, "pointer_t").type.get_size() * 8
        self.ctypes_sizes[TypeKind.POINTER] = size
        self.ctypes_sizes[TypeKind.NULLPTR] = size

        log.debug(
            "ARCH sizes: long:%s longdouble:%s",
            self.ctypes_typename[TypeKind.LONG],
            self.ctypes_typename[TypeKind.LONGDOUBLE],
        )
        return

    def get_ctypes_name(self, typekind):
        return self.ctypes_typename[typekind]

    def get_ctypes_size(self, typekind):
        return self.ctypes_sizes[typekind]

    def parse_cursor(self, cursor):
        """Forward parsing calls to dedicated CursorKind Handlder"""
        return self.cursorkind_handler.parse_cursor(cursor)

    def parse_cursor_type(self, _cursor_type):
        """Forward parsing calls to dedicated TypeKind Handlder"""
        return self.typekind_handler.parse_cursor_type(_cursor_type)

    ###########################################################################

    ################

    def get_macros(self, text):
        if text is None:
            return
        text = "".join(text)
        # preprocessor definitions that look like macros with one or more
        # arguments
        for macro in text.splitlines():
            name, body = macro.split(None, 1)
            name, args = name.split("(", 1)
            args = f"({args}"
            self.all[name] = typedesc.Macro(name, args, body)

    def get_aliases(self, text, namespace):
        if text is None:
            return
        # preprocessor definitions that look like aliases:
        #  #define A B
        text = "".join(text)
        aliases = {}
        for alias in text.splitlines():
            name, value = alias.split(None, 1)
            alias = typedesc.Alias(name, value)
            aliases[name] = alias
            self.all[name] = alias

        for name, alias in aliases.items():
            value = alias.alias
            # the value should be either in namespace...
            if value in namespace:
                # set the type
                alias.typ = namespace[value]
            # or in aliases...
            elif value in aliases:
                alias.typ = aliases[value]
            # or unknown.
            else:
                # not known
                # print "skip %s = %s" % (name, value)
                pass

    def get_result(self):
        # all of these should register()
        interesting = (
            typedesc.Typedef,
            typedesc.Enumeration,
            typedesc.EnumValue,
            typedesc.Function,
            typedesc.Structure,
            typedesc.Union,
            typedesc.Variable,
            typedesc.Macro,
            typedesc.Alias,
            typedesc.FunctionType,
        )
        # typedesc.Field) #???

        self.get_macros(self.cpp_data.get("functions"))
        # fix all objects after that all are resolved
        remove = []
        for _id, _item in self.all.items():
            if _item is None:
                log.warning("ignoring %s", _id)
                continue
            location = getattr(_item, "location", None)
            # FIXME , why do we get different location types
            if location and hasattr(location, "file"):
                _item.location = location.file.name, location.line
                log.error("%s %s came in with a SourceLocation", _id, _item)
            elif location is None:
                # FIXME make this optional to be able to see internals
                # FIXME macro/alias are here
                log.warning("No source location in %s - ignoring", _id)
                remove.append(_id)

        for _x in remove:
            self.remove_registered(_x)

        # Now we can build the namespace.
        namespace = {}
        for i in self.all.values():
            if not isinstance(i, interesting):
                log.debug("ignoring %s", i)
                continue  # we don't want these
            name = getattr(i, "name", None)
            if name is not None:
                namespace[name] = i
        self.get_aliases(self.cpp_data.get("aliases"), namespace)

        result = []
        for i in self.all.values():
            if isinstance(i, interesting):
                result.append(i)

        log.debug("parsed items order: %s", result)
        return result

1	"""clangparser - use clang to get preprocess a source code."""
2
3	import logging	1✔
4	import os	1✔
5	import collections	1✔
6
7	from clang.cindex import Index, TranslationUnit	1✔
8	from clang.cindex import TypeKind	1✔
9
10	from ctypeslib.codegen import cursorhandler	1✔
11	from ctypeslib.codegen import typedesc	1✔
12	from ctypeslib.codegen import typehandler	1✔
13	from ctypeslib.codegen import util	1✔
14	from ctypeslib.codegen.handler import DuplicateDefinitionException	1✔
15	from ctypeslib.codegen.handler import InvalidDefinitionError	1✔
16	from ctypeslib.codegen.handler import InvalidTranslationUnitException	1✔
17
18	log = logging.getLogger("clangparser")	1✔
19
20
21	class Clang_Parser:	1✔
22	"""
23	Will parse libclang AST tree to create a representation of Types and
24	different others source code objects objets as described in Typedesc.
25
26	For each Declaration a declaration will be saved, and the type of that
27	declaration will be cached and saved.
28	"""
29
30	has_values = {	1✔
31	"Enumeration",
32	"Function",
33	"FunctionType",
34	"OperatorFunction",
35	"Method",
36	"Constructor",
37	"Destructor",
38	"OperatorMethod",
39	"Converter",
40	}
41
42	# FIXME, macro definition __SIZEOF_DOUBLE__
43	ctypes_typename = {	1✔
44	TypeKind.VOID: "None", # because ctypes.POINTER(None) == c_void_p
45	TypeKind.BOOL: "c_bool",
46	TypeKind.CHAR_U: "c_ubyte", # ?? used for PADDING
47	TypeKind.UCHAR: "c_ubyte", # unsigned char
48	TypeKind.CHAR16: "c_wchar", # char16_t
49	TypeKind.CHAR32: "c_wchar", # char32_t
50	TypeKind.USHORT: "c_ushort",
51	TypeKind.UINT: "c_uint",
52	TypeKind.ULONG: "TBD",
53	TypeKind.ULONGLONG: "c_ulonglong",
54	TypeKind.UINT128: "c_uint128", # FIXME
55	TypeKind.CHAR_S: "c_char", # char
56	TypeKind.SCHAR: "c_byte", # signed char
57	TypeKind.WCHAR: "c_wchar",
58	TypeKind.SHORT: "c_short",
59	TypeKind.INT: "c_int",
60	TypeKind.LONG: "TBD",
61	TypeKind.LONGLONG: "c_longlong",
62	TypeKind.INT128: "c_int128", # FIXME
63	TypeKind.FLOAT: "c_float",
64	TypeKind.DOUBLE: "c_double",
65	TypeKind.LONGDOUBLE: "c_longdouble",
66	TypeKind.POINTER: "POINTER_T",
67	TypeKind.NULLPTR: "c_void_p",
68	}
69
70	def __init__(self, flags):	1✔
71	self.all = collections.OrderedDict()	1✔
72	# a shortcut to identify registered decl in cases of records
73	self.all_set = set()	1✔
74	self.cpp_data = {}	1✔
75	self._unhandled = []	1✔
76	self.fields = {}	1✔
77	self.tu = None	1✔
78	self.tu_options = None	1✔
79	self.flags = flags	1✔
80	self.ctypes_sizes = {}	1✔
81	self.init_parsing_options()	1✔
82	self.make_ctypes_convertor(flags)	1✔
83	self.cursorkind_handler = cursorhandler.CursorHandler(self)	1✔
84	self.typekind_handler = typehandler.TypeHandler(self)	1✔
85	self.__filter_location = None	1✔
86	self.__processed_location = set()	1✔
87
88	def init_parsing_options(self):	1✔
89	"""Set the Translation Unit to skip functions bodies per default."""
90	self.tu_options = TranslationUnit.PARSE_SKIP_FUNCTION_BODIES	1✔
91
92	def activate_macros_parsing(self):	1✔
93	"""Activates the detailled code parsing options in the Translation
94	Unit."""
95	self.tu_options \|= TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD	1✔
96
97	def activate_comment_parsing(self):	1✔
98	"""Activates the comment parsing options in the Translation Unit."""
99	self.tu_options \|= TranslationUnit.PARSE_INCLUDE_BRIEF_COMMENTS_IN_CODE_COMPLETION	1✔
100
101	def deactivate_function_body_parsing(self):	1✔
102	self.tu_options \|= TranslationUnit.PARSE_SKIP_FUNCTION_BODIES	×
103
104	def filter_location(self, src_files):	1✔
105	self.__filter_location = [os.path.abspath(f) for f in src_files]	1✔
106
107	def parse(self, filename):	1✔
108	"""
109	. reads 1 file
110	. if there is a compilation error, print a warning
111	. get root cursor and recurse
112	. for each STRUCT_DECL, register a new struct type
113	. for each UNION_DECL, register a new union type
114	. for each TYPEDEF_DECL, register a new alias/typdef to the underlying type
115	- underlying type is cursor.type.get_declaration() for Record
116	. for each VAR_DECL, register a Variable
117	. for each TYPEREF ??
118	"""
119	if os.path.abspath(filename) in self.__processed_location:	1✔
120	return	×
121	index = Index.create()	1✔
122	translation_unit = index.parse(filename, self.flags, options=self.tu_options)	1✔
123	if not translation_unit:	1✔
124	log.warning("unable to load input")	×
125	return	×
126	self._parse_tu_diagnostics(translation_unit, filename)	1✔
127	self.tu = translation_unit	1✔
128	root = self.tu.cursor	1✔
129	for node in root.get_children():	1✔
130	self.start_element(node)	1✔
131	return	1✔
132
133	def parse_string(self, input_data, lang="c", all_warnings=False, flags=None):	1✔
134	"""Use this parser on a memory string/file, instead of a file on disk"""
135	translation_unit = util.get_tu(input_data, lang, all_warnings, flags)	1✔
136	self._parse_tu_diagnostics(translation_unit, "memory_input.c")	1✔
137	self.tu = translation_unit	1✔
138	root = self.tu.cursor	1✔
139	for node in root.get_children():	1✔
140	self.start_element(node)	1✔
141
142	@staticmethod	1✔
143	def _parse_tu_diagnostics(translation_unit, input_filename):	1✔
144	if len(translation_unit.diagnostics) == 0:	1✔
145	return	1✔
146	errors = []	1✔
147	for diagnostic in translation_unit.diagnostics:	1✔
148	msg = (	1✔
149	f"{diagnostic.spelling} ({diagnostic.location.file}:{diagnostic.location.line}:"
150	f"{diagnostic.location.column}) during processing {input_filename}"
151	)
152	log.warning(msg)	1✔
153	if diagnostic.severity > 2:	1✔
154	errors.append(msg)	1✔
155	if len(errors) > 0:	1✔
156	log.warning("Source code has %d error. Please fix.", len(errors))	1✔
157	# code.interact(local=locals())
158	raise InvalidTranslationUnitException(errors[0])	1✔
159
160	def start_element(self, node):	1✔
161	"""Recurses in children of this node"""
162	if node is None:	1✔
163	return None	×
164
165	if self.__filter_location is not None:	1✔
166	# dont even parse includes.
167	# FIXME: go back on dependencies ?
168	if node.location.file is None:	1✔
169	return None	×
170	filepath = os.path.abspath(node.location.file.name)	1✔
171	if filepath not in self.__filter_location:	1✔
172	if not filepath.startswith("/usr"):	×
173	log.debug("skipping include '%s'", filepath)	×
174	return None	×
175	# find and call the handler for this element
176	log.debug(	1✔
177	"%s:%d: Found a %s\|%s\|%s",
178	node.location.file,
179	node.location.line,
180	node.kind.name,
181	node.displayname,
182	node.spelling,
183	)
184	# build stuff.
185	try:	1✔
186	stop_recurse = self.parse_cursor(node)	1✔
187	if node.location.file is not None:	1✔
188	filepath = os.path.abspath(node.location.file.name)	1✔
189	self.__processed_location.add(filepath)	1✔
190	# Signature of parse_cursor is:
191	# if the fn returns True, do not recurse into children.
192	# anything else will be ignored.
193	if stop_recurse is not False: # True:	1✔
194	return None	1✔
195	# if fn returns something, if this element has children, treat
196	# them.
197	for child in node.get_children():	1✔
198	self.start_element(child)	×
199	except InvalidDefinitionError:	1✔
200	log.exception("Invalid definition")	×
201	# if the definition is invalid
202	# startElement returns None.
203	return None	1✔
204
205	def register(self, name, obj):	1✔
206	"""Registers an unique type description"""
207	if (name, obj) in self.all_set:	1✔
208	log.debug("register: %s already defined: %s", name, obj.name)	×
209	return self.all[name]	×
210	if name in self.all:	1✔
211	if not isinstance(self.all[name], typedesc.Structure) or (self.all[name].members is not None):	1✔
212	# code.interact(local=locals())
213	raise DuplicateDefinitionException(	1✔
214	f"register: {name} which has a previous incompatible definition: {obj.name}"
215	f"\ndefined here: {obj.location}"
216	f"\npreviously defined here: {self.all[name].location}"
217	)
218	if isinstance(self.all[name], typedesc.Structure) and (self.all[name].members is None):	1✔
219	return obj	1✔
220	log.debug("register: %s ", name)	1✔
221	self.all[name] = obj	1✔
222	self.all_set.add((name, obj))	1✔
223	return obj	1✔
224
225	def get_registered(self, name):	1✔
226	"""Returns a registered type description"""
227	return self.all[name]	1✔
228
229	def is_registered(self, name):	1✔
230	"""Checks if a named type description is registered"""
231	return name in self.all	1✔
232
233	def remove_registered(self, name):	1✔
234	"""Removes a named type"""
235	log.debug("Unregister %s", name)	1✔
236	self.all_set.remove((name, self.all[name]))	1✔
237	del self.all[name]	1✔
238
239	def make_ctypes_convertor(self, _flags):	1✔
240	"""
241	Fix clang types to ctypes conversion for this parsing instance.
242	Some architecture dependent size types have to be changed if the target
243	architecture is not the same as local
244	"""
245	# NOTE: one could also use the __SIZEOF_x__ MACROs to obtain sizes.
246	translation_unit = util.get_tu(	1✔
247	"""
248	typedef short short_t;
249	typedef int int_t;
250	typedef long long_t;
251	typedef long long longlong_t;
252	typedef float float_t;
253	typedef double double_t;
254	typedef long double longdouble_t;
255	typedef void* pointer_t;""",
256	flags=_flags,
257	)
258	size = util.get_cursor(translation_unit, "short_t").type.get_size() * 8	1✔
259	self.ctypes_typename[TypeKind.SHORT] = f"c_int{size:d}"	1✔
260	self.ctypes_typename[TypeKind.USHORT] = f"c_uint{size:d}"	1✔
261	self.ctypes_sizes[TypeKind.SHORT] = size	1✔
262	self.ctypes_sizes[TypeKind.USHORT] = size	1✔
263
264	size = util.get_cursor(translation_unit, "int_t").type.get_size() * 8	1✔
265	self.ctypes_typename[TypeKind.INT] = f"c_int{size:d}"	1✔
266	self.ctypes_typename[TypeKind.UINT] = f"c_uint{size:d}"	1✔
267	self.ctypes_sizes[TypeKind.INT] = size	1✔
268	self.ctypes_sizes[TypeKind.UINT] = size	1✔
269
270	size = util.get_cursor(translation_unit, "long_t").type.get_size() * 8	1✔
271	self.ctypes_typename[TypeKind.LONG] = f"c_int{size:d}"	1✔
272	self.ctypes_typename[TypeKind.ULONG] = f"c_uint{size:d}"	1✔
273	self.ctypes_sizes[TypeKind.LONG] = size	1✔
274	self.ctypes_sizes[TypeKind.ULONG] = size	1✔
275
276	size = util.get_cursor(translation_unit, "longlong_t").type.get_size() * 8	1✔
277	self.ctypes_typename[TypeKind.LONGLONG] = f"c_int{size:d}"	1✔
278	self.ctypes_typename[TypeKind.ULONGLONG] = f"c_uint{size:d}"	1✔
279	self.ctypes_sizes[TypeKind.LONGLONG] = size	1✔
280	self.ctypes_sizes[TypeKind.ULONGLONG] = size	1✔
281
282	# FIXME : Float && http://en.wikipedia.org/wiki/Long_double
283	size0 = util.get_cursor(translation_unit, "float_t").type.get_size() * 8	1✔
284	size1 = util.get_cursor(translation_unit, "double_t").type.get_size() * 8	1✔
285	size2 = util.get_cursor(translation_unit, "longdouble_t").type.get_size() * 8	1✔
286	# 2014-01 stop generating crap.
287	# 2015-01 reverse until better solution is found
288	# the idea is that you cannot assume a c_double will be same format as a c_long_double.
289	# at least this pass size TU
290	if size1 != size2:	1✔
291	self.ctypes_typename[TypeKind.LONGDOUBLE] = "c_long_double_t"	1✔
292	else:
293	self.ctypes_typename[TypeKind.LONGDOUBLE] = "c_double"	1✔
294
295	self.ctypes_sizes[TypeKind.FLOAT] = size0	1✔
296	self.ctypes_sizes[TypeKind.DOUBLE] = size1	1✔
297	self.ctypes_sizes[TypeKind.LONGDOUBLE] = size2	1✔
298
299	# save the target pointer size.
300	size = util.get_cursor(translation_unit, "pointer_t").type.get_size() * 8	1✔
301	self.ctypes_sizes[TypeKind.POINTER] = size	1✔
302	self.ctypes_sizes[TypeKind.NULLPTR] = size	1✔
303
304	log.debug(	1✔
305	"ARCH sizes: long:%s longdouble:%s",
306	self.ctypes_typename[TypeKind.LONG],
307	self.ctypes_typename[TypeKind.LONGDOUBLE],
308	)
309	return	1✔
310
311	def get_ctypes_name(self, typekind):	1✔
312	return self.ctypes_typename[typekind]	1✔
313
314	def get_ctypes_size(self, typekind):	1✔
315	return self.ctypes_sizes[typekind]	1✔
316
317	def parse_cursor(self, cursor):	1✔
318	"""Forward parsing calls to dedicated CursorKind Handlder"""
319	return self.cursorkind_handler.parse_cursor(cursor)	1✔
320
321	def parse_cursor_type(self, _cursor_type):	1✔
322	"""Forward parsing calls to dedicated TypeKind Handlder"""
323	return self.typekind_handler.parse_cursor_type(_cursor_type)	1✔
324
325	###########################################################################
326
327	################
328
329	def get_macros(self, text):	1✔
330	if text is None:	1✔
331	return	1✔
332	text = "".join(text)	×
333	# preprocessor definitions that look like macros with one or more
334	# arguments
335	for macro in text.splitlines():	×
336	name, body = macro.split(None, 1)	×
337	name, args = name.split("(", 1)	×
338	args = f"({args}"	×
339	self.all[name] = typedesc.Macro(name, args, body)	×
340
341	def get_aliases(self, text, namespace):	1✔
342	if text is None:	1✔
343	return	1✔
344	# preprocessor definitions that look like aliases:
345	# #define A B
346	text = "".join(text)	×
347	aliases = {}	×
348	for alias in text.splitlines():	×
349	name, value = alias.split(None, 1)	×
350	alias = typedesc.Alias(name, value)	×
351	aliases[name] = alias	×
352	self.all[name] = alias	×
353
354	for name, alias in aliases.items():	×
355	value = alias.alias	×
356	# the value should be either in namespace...
357	if value in namespace:	×
358	# set the type
359	alias.typ = namespace[value]	×
360	# or in aliases...
361	elif value in aliases:	×
362	alias.typ = aliases[value]	×
363	# or unknown.
364	else:
365	# not known
366	# print "skip %s = %s" % (name, value)
367	pass	×
368
369	def get_result(self):	1✔
370	# all of these should register()
371	interesting = (	1✔
372	typedesc.Typedef,
373	typedesc.Enumeration,
374	typedesc.EnumValue,
375	typedesc.Function,
376	typedesc.Structure,
377	typedesc.Union,
378	typedesc.Variable,
379	typedesc.Macro,
380	typedesc.Alias,
381	typedesc.FunctionType,
382	)
383	# typedesc.Field) #???
384
385	self.get_macros(self.cpp_data.get("functions"))	1✔
386	# fix all objects after that all are resolved
387	remove = []	1✔
388	for _id, _item in self.all.items():	1✔
389	if _item is None:	1✔
390	log.warning("ignoring %s", _id)	×
391	continue	×
392	location = getattr(_item, "location", None)	1✔
393	# FIXME , why do we get different location types
394	if location and hasattr(location, "file"):	1✔
395	_item.location = location.file.name, location.line	×
396	log.error("%s %s came in with a SourceLocation", _id, _item)	×
397	elif location is None:	1✔
398	# FIXME make this optional to be able to see internals
399	# FIXME macro/alias are here
400	log.warning("No source location in %s - ignoring", _id)	1✔
401	remove.append(_id)	1✔
402
403	for _x in remove:	1✔
404	self.remove_registered(_x)	1✔
405
406	# Now we can build the namespace.
407	namespace = {}	1✔
408	for i in self.all.values():	1✔
409	if not isinstance(i, interesting):	1✔
410	log.debug("ignoring %s", i)	×
411	continue # we don't want these	×
412	name = getattr(i, "name", None)	1✔
413	if name is not None:	1✔
414	namespace[name] = i	1✔
415	self.get_aliases(self.cpp_data.get("aliases"), namespace)	1✔
416
417	result = []	1✔
418	for i in self.all.values():	1✔
419	if isinstance(i, interesting):	1✔
420	result.append(i)	1✔
421
422	log.debug("parsed items order: %s", result)	1✔
423	return result	1✔

trolldbois / ctypeslib / 13391439098

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous