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

89.08

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