4773564691

Build Type

push

github

Committed by Loic Jaquemet

Commit Message

try without baipp

Run Details

1601 of 1912 relevant lines covered (83.73%)

50.0 hits per line

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

88.48

/ctypeslib/codegen/typedesc.py

# typedesc.py - classes representing C type descriptions


class T(object):
    name = None
    location = None
    comment = None

    def __repr__(self):
        kv = self.__dict__
        s = []
        for k, v in kv.items():
            if isinstance(v, T):
                s.append('%s=%s(...)' % (k, v.__class__.__name__))
            else:
                s.append('%s=%s' % (k, v))
        return "%s(%s)" % (self.__class__.__name__, ','.join(s))


class Argument(T):

    "a Parameter in the argument list of a callable (Function, Method, ...)"

    def __init__(self, name, _type):
        self.typ = _type
        self.name = name


class _HasArgs(T):

    """Any C type with arguments"""

    def __init__(self):
        self.arguments = []

    def add_argument(self, arg):
        if not isinstance(arg, Argument):
            raise TypeError('Argument expected, %s instead' % (type(arg)))
        self.arguments.append(arg)

    def iterArgTypes(self):
        for a in self.arguments:
            yield a.typ

    def iterArgNames(self):
        for a in self.arguments:
            yield a.name

    def fixup_argtypes(self, cb):
        # for a in self.arguments:
        #    getattr(cb, a.a.atype = typemap[a.atype]
        #import code
        # code.interact(local=locals())
        pass


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

class Alias(T):

    """a C preprocessor alias, like #define A B"""

    def __init__(self, name, alias, typ=None):
        self.name = name
        self.alias = alias
        self.typ = typ


class Macro(T):

    """a C preprocessor definition with arguments"""

    def __init__(self, name, args, body):
        """all arguments are strings, args is the literal argument list
        *with* the parens around it:
        Example: Macro("CD_INDRIVE", "(status)", "((int)status > 0)")"""
        self.name = name
        self.args = args
        self.body = body


class File(T):

    def __init__(self, name):
        self.name = name


class Function(_HasArgs):

    def __init__(self, name, returns, attributes, extern):
        _HasArgs.__init__(self)
        self.name = name
        self.returns = returns
        self.attributes = attributes  # dllimport, __stdcall__, __cdecl__
        self.extern = extern


class Ignored(_HasArgs):

    def __init__(self, name):
        _HasArgs.__init__(self)
        self.name = name


class OperatorFunction(_HasArgs):

    def __init__(self, name, returns):
        _HasArgs.__init__(self)
        self.name = name
        self.returns = returns


class FunctionType(_HasArgs):

    def __init__(self, returns, attributes, name=''):
        _HasArgs.__init__(self)
        self.returns = returns
        self.attributes = attributes
        self.name = "FP_%s" % (name)


class Method(_HasArgs):

    def __init__(self, name, returns):
        _HasArgs.__init__(self)
        self.name = name
        self.returns = returns


class FundamentalType(T):

    def __init__(self, name, size, align):
        self.name = name
        if name != "void":
            self.size = int(size)
            self.align = int(align)


class PointerType(T):

    def __init__(self, typ, size, align):
        self.typ = typ
        self.size = int(size)
        self.align = int(align)
        self.name = "LP_%s" % (self.typ.name)


class Typedef(T):

    def __init__(self, name, typ):
        self.name = name
        self.typ = typ


class ArrayType(T):

    def __init__(self, typ, size):
        self.typ = typ
        self.size = size
        self.name = "array_%s" % typ.name


class StructureHead(T):

    def __init__(self, struct):
        self.struct = struct

    @property
    def name(self):
        return self.struct.name


class StructureBody(T):

    def __init__(self, struct):
        self.struct = struct

    @property
    def name(self):
        return self.struct.name


class _Struct_Union_Base(T):

    def get_body(self):
        return self.struct_body

    def get_head(self):
        return self.struct_head


class Structure(_Struct_Union_Base):

    def __init__(self, name, align, members, bases, size, artificial=None,
                 packed=False):
        self.name = name
        self.align = int(align)
        self.members = members
        self.bases = bases
        self.artificial = artificial
        self.size = size
        self.packed = packed
        self.struct_body = StructureBody(self)
        self.struct_head = StructureHead(self)


class Union(_Struct_Union_Base):

    def __init__(self, name, align, members, bases, size, artificial=None,
                 packed=False):
        self.name = name
        self.align = int(align)
        self.members = members
        self.bases = bases
        self.artificial = artificial
        if size is not None:
            self.size = int(size)
        else:
            self.size = None
        self.packed = packed
        self.struct_body = StructureBody(self)
        self.struct_head = StructureHead(self)


class Field(T):

    ''' Change bits if its a bitfield'''

    def __init__(self, name, typ, offset, bits, is_bitfield=False,
                 is_anonymous=False, is_padding=False):
        self.name = name
        self.type = typ
        self.offset = offset
        self.bits = bits
        self.is_bitfield = is_bitfield
        self.is_anonymous = is_anonymous
        self.is_padding = is_padding


class CvQualifiedType(T):

    def __init__(self, typ, const, volatile):
        self.typ = typ
        self.const = const
        self.volatile = volatile
        self.name = 'CV_QUAL_%s' % (self.typ.name)


class Enumeration(T):

    def __init__(self, name, size, align):
        self.name = name
        self.size = int(size)
        self.align = int(align)
        self.values = []

    def add_value(self, v):
        self.values.append(v)


class EnumValue(T):

    def __init__(self, name, value, enumeration):
        self.name = name
        self.value = value
        self.enumeration = enumeration


class Variable(T):

    def __init__(self, name, typ, init=None, extern=False):
        self.name = name
        self.typ = typ
        self.init = init
        self.extern = extern

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


class UndefinedIdentifier(T):
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name


def is_record(t):
    return isinstance(t, Structure) or isinstance(t, Union)

1	# typedesc.py - classes representing C type descriptions
2
3
4	class T(object):	60✔
5	name = None	60✔
6	location = None	60✔
7	comment = None	60✔
8
9	def __repr__(self):	60✔
10	kv = self.__dict__	60✔
11	s = []	60✔
12	for k, v in kv.items():	60✔
13	if isinstance(v, T):	60✔
14	s.append('%s=%s(...)' % (k, v.__class__.__name__))	60✔
15	else:	×
16	s.append('%s=%s' % (k, v))	60✔
17	return "%s(%s)" % (self.__class__.__name__, ','.join(s))	60✔
18
19
20	class Argument(T):	60✔
21
22	"a Parameter in the argument list of a callable (Function, Method, ...)"	60✔
23
24	def __init__(self, name, _type):	60✔
25	self.typ = _type	60✔
26	self.name = name	60✔
27
28
29	class _HasArgs(T):	60✔
30
31	"""Any C type with arguments"""
32
33	def __init__(self):
34	self.arguments = []
35
36	def add_argument(self, arg):
37	if not isinstance(arg, Argument):
38	raise TypeError('Argument expected, %s instead' % (type(arg)))
39	self.arguments.append(arg)
40
41	def iterArgTypes(self):
42	for a in self.arguments:
43	yield a.typ
44
45	def iterArgNames(self):
46	for a in self.arguments:
47	yield a.name
48
49	def fixup_argtypes(self, cb):
50	# for a in self.arguments:
51	# getattr(cb, a.a.atype = typemap[a.atype]
52	#import code
53	# code.interact(local=locals())
54	pass
55
56
57	################
58
59	class Alias(T):
60
61	"""a C preprocessor alias, like #define A B"""
62
63	def __init__(self, name, alias, typ=None):	60✔
64	self.name = name	×
65	self.alias = alias	×
66	self.typ = typ	×
67
68
69	class Macro(T):	60✔
70
71	"""a C preprocessor definition with arguments"""
72
73	def __init__(self, name, args, body):
74	"""all arguments are strings, args is the literal argument list
75	with the parens around it:
76	Example: Macro("CD_INDRIVE", "(status)", "((int)status > 0)")"""
77	self.name = name	60✔
78	self.args = args	60✔
79	self.body = body	60✔
80
81
82	class File(T):	60✔
83
84	def __init__(self, name):	60✔
85	self.name = name	×
86
87
88	class Function(_HasArgs):	60✔
89
90	def __init__(self, name, returns, attributes, extern):	60✔
91	_HasArgs.__init__(self)	60✔
92	self.name = name	60✔
93	self.returns = returns	60✔
94	self.attributes = attributes # dllimport, __stdcall__, __cdecl__	60✔
95	self.extern = extern	60✔
96
97
98	class Ignored(_HasArgs):	60✔
99
100	def __init__(self, name):	60✔
101	_HasArgs.__init__(self)	×
102	self.name = name	×
103
104
105	class OperatorFunction(_HasArgs):	60✔
106
107	def __init__(self, name, returns):	60✔
108	_HasArgs.__init__(self)	×
109	self.name = name	×
110	self.returns = returns	×
111
112
113	class FunctionType(_HasArgs):	60✔
114
115	def __init__(self, returns, attributes, name=''):	60✔
116	_HasArgs.__init__(self)	60✔
117	self.returns = returns	60✔
118	self.attributes = attributes	60✔
119	self.name = "FP_%s" % (name)	60✔
120
121
122	class Method(_HasArgs):	60✔
123
124	def __init__(self, name, returns):	60✔
125	_HasArgs.__init__(self)	×
126	self.name = name	×
127	self.returns = returns	×
128
129
130	class FundamentalType(T):	60✔
131
132	def __init__(self, name, size, align):	60✔
133	self.name = name	60✔
134	if name != "void":	60✔
135	self.size = int(size)	60✔
136	self.align = int(align)	60✔
137
138
139	class PointerType(T):	60✔
140
141	def __init__(self, typ, size, align):	60✔
142	self.typ = typ	60✔
143	self.size = int(size)	60✔
144	self.align = int(align)	60✔
145	self.name = "LP_%s" % (self.typ.name)	60✔
146
147
148	class Typedef(T):	60✔
149
150	def __init__(self, name, typ):	60✔
151	self.name = name	60✔
152	self.typ = typ	60✔
153
154
155	class ArrayType(T):	60✔
156
157	def __init__(self, typ, size):	60✔
158	self.typ = typ	60✔
159	self.size = size	60✔
160	self.name = "array_%s" % typ.name	60✔
161
162
163	class StructureHead(T):	60✔
164
165	def __init__(self, struct):	60✔
166	self.struct = struct	60✔
167
168	@property	60✔
169	def name(self):	48✔
170	return self.struct.name	60✔
171
172
173	class StructureBody(T):	60✔
174
175	def __init__(self, struct):	60✔
176	self.struct = struct	60✔
177
178	@property	60✔
179	def name(self):	48✔
180	return self.struct.name	60✔
181
182
183	class _Struct_Union_Base(T):	60✔
184
185	def get_body(self):	60✔
186	return self.struct_body	60✔
187
188	def get_head(self):	60✔
189	return self.struct_head	60✔
190
191
192	class Structure(_Struct_Union_Base):	60✔
193
194	def __init__(self, name, align, members, bases, size, artificial=None,	48✔
195	packed=False):	36✔
196	self.name = name	60✔
197	self.align = int(align)	60✔
198	self.members = members	60✔
199	self.bases = bases	60✔
200	self.artificial = artificial	60✔
201	self.size = size	60✔
202	self.packed = packed	60✔
203	self.struct_body = StructureBody(self)	60✔
204	self.struct_head = StructureHead(self)	60✔
205
206
207	class Union(_Struct_Union_Base):	60✔
208
209	def __init__(self, name, align, members, bases, size, artificial=None,	48✔
210	packed=False):	36✔
211	self.name = name	60✔
212	self.align = int(align)	60✔
213	self.members = members	60✔
214	self.bases = bases	60✔
215	self.artificial = artificial	60✔
216	if size is not None:	60✔
217	self.size = int(size)	60✔
218	else:	×
219	self.size = None	×
220	self.packed = packed	60✔
221	self.struct_body = StructureBody(self)	60✔
222	self.struct_head = StructureHead(self)	60✔
223
224
225	class Field(T):	60✔
226
227	''' Change bits if its a bitfield'''	60✔
228
229	def __init__(self, name, typ, offset, bits, is_bitfield=False,	48✔
230	is_anonymous=False, is_padding=False):	36✔
231	self.name = name	60✔
232	self.type = typ	60✔
233	self.offset = offset	60✔
234	self.bits = bits	60✔
235	self.is_bitfield = is_bitfield	60✔
236	self.is_anonymous = is_anonymous	60✔
237	self.is_padding = is_padding	60✔
238
239
240	class CvQualifiedType(T):	60✔
241
242	def __init__(self, typ, const, volatile):	60✔
243	self.typ = typ	×
244	self.const = const	×
245	self.volatile = volatile	×
246	self.name = 'CV_QUAL_%s' % (self.typ.name)	×
247
248
249	class Enumeration(T):	60✔
250
251	def __init__(self, name, size, align):	60✔
252	self.name = name	60✔
253	self.size = int(size)	60✔
254	self.align = int(align)	60✔
255	self.values = []	60✔
256
257	def add_value(self, v):	60✔
258	self.values.append(v)	60✔
259
260
261	class EnumValue(T):	60✔
262
263	def __init__(self, name, value, enumeration):	60✔
264	self.name = name	60✔
265	self.value = value	60✔
266	self.enumeration = enumeration	60✔
267
268
269	class Variable(T):	60✔
270
271	def __init__(self, name, typ, init=None, extern=False):	60✔
272	self.name = name	60✔
273	self.typ = typ	60✔
274	self.init = init	60✔
275	self.extern = extern	60✔
276
277	################################################################
278
279
280	class UndefinedIdentifier(T):	60✔
281	def __init__(self, name):	60✔
282	self.name = name	60✔
283
284	def __str__(self):	60✔
285	return self.name	60✔
286
287
288	def is_record(t):	60✔
289	return isinstance(t, Structure) or isinstance(t, Union)	60✔

trolldbois / ctypeslib / 4773564691

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