return visitor.visitIntPointer(self, *args, **kwargs)
+class ObjPointer(Type):
+ '''Pointer to an object.'''
+
+ def __init__(self, type):
+ Type.__init__(self, type.expr + " *", 'P' + type.tag)
+ self.type = type
+
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visitObjPointer(self, *args, **kwargs)
+
+
class LinearPointer(Type):
- '''Integer encoded as a pointer.'''
+ '''Pointer to a linear range of memory.'''
def __init__(self, type, size = None):
Type.__init__(self, type.expr + " *", 'P' + type.tag)
return visitor.visitLinearPointer(self, *args, **kwargs)
+class Reference(Type):
+ '''C++ references.'''
+
+ def __init__(self, type):
+ Type.__init__(self, type.expr + " &", 'R' + type.tag)
+ self.type = type
+
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visitReference(self, *args, **kwargs)
+
+
class Handle(Type):
def __init__(self, name, type, range=None, key=None):
yield method
raise StopIteration
+ def iterBaseMethods(self):
+ if self.base is not None:
+ for iface, method in self.base.iterBaseMethods():
+ yield iface, method
+ for method in self.methods:
+ yield self, method
+ raise StopIteration
+
class Method(Function):
- def __init__(self, type, name, args):
- Function.__init__(self, type, name, args, call = '__stdcall')
+ def __init__(self, type, name, args, const=False, sideeffects=True):
+ Function.__init__(self, type, name, args, call = '__stdcall', sideeffects=sideeffects)
for index in range(len(self.args)):
self.args[index].index = index + 1
+ self.const = const
+
+ def prototype(self, name=None):
+ s = Function.prototype(self, name)
+ if self.const:
+ s += ' const'
+ return s
class String(Type):
- def __init__(self, expr = "char *", length = None):
+ def __init__(self, expr = "char *", length = None, kind = 'String'):
Type.__init__(self, expr)
self.length = length
+ self.kind = kind
def visit(self, visitor, *args, **kwargs):
return visitor.visitString(self, *args, **kwargs)
-# C string (i.e., zero terminated)
-CString = String()
-
class Opaque(Type):
'''Opaque pointer.'''
def visitIntPointer(self, pointer, *args, **kwargs):
raise NotImplementedError
+ def visitObjPointer(self, pointer, *args, **kwargs):
+ raise NotImplementedError
+
def visitLinearPointer(self, pointer, *args, **kwargs):
raise NotImplementedError
+ def visitReference(self, reference, *args, **kwargs):
+ raise NotImplementedError
+
def visitHandle(self, handle, *args, **kwargs):
raise NotImplementedError
return string
def visitConst(self, const):
- return Const(const.type)
+ const_type = self.visit(const.type)
+ if const_type is const.type:
+ return const
+ else:
+ return Const(const_type)
def visitStruct(self, struct):
members = [(self.visit(type), name) for type, name in struct.members]
return Bitmask(type, bitmask.values)
def visitPointer(self, pointer):
- type = self.visit(pointer.type)
- return Pointer(type)
+ pointer_type = self.visit(pointer.type)
+ if pointer_type is pointer.type:
+ return pointer
+ else:
+ return Pointer(pointer_type)
def visitIntPointer(self, pointer):
return pointer
+ def visitObjPointer(self, pointer):
+ pointer_type = self.visit(pointer.type)
+ if pointer_type is pointer.type:
+ return pointer
+ else:
+ return ObjPointer(pointer_type)
+
def visitLinearPointer(self, pointer):
- type = self.visit(pointer.type)
- return LinearPointer(type, pointer.size)
+ pointer_type = self.visit(pointer.type)
+ if pointer_type is pointer.type:
+ return pointer
+ else:
+ return LinearPointer(pointer_type)
+
+ def visitReference(self, reference):
+ reference_type = self.visit(reference.type)
+ if reference_type is reference.type:
+ return reference
+ else:
+ return Reference(reference_type)
def visitHandle(self, handle):
- type = self.visit(handle.type)
- return Handle(handle.name, type, range=handle.range, key=handle.key)
+ handle_type = self.visit(handle.type)
+ if handle_type is handle.type:
+ return handle
+ else:
+ return Handle(handle.name, handle_type, range=handle.range, key=handle.key)
def visitAlias(self, alias):
- type = self.visit(alias.type)
- return Alias(alias.expr, type)
+ alias_type = self.visit(alias.type)
+ if alias_type is alias.type:
+ return alias
+ else:
+ return Alias(alias.expr, alias_type)
def visitOpaque(self, opaque):
return opaque
def visitIntPointer(self, pointer):
pass
+ def visitObjPointer(self, pointer):
+ self.visit(pointer.type)
+
def visitLinearPointer(self, pointer):
self.visit(pointer.type)
+ def visitReference(self, reference):
+ self.visit(reference.type)
+
def visitHandle(self, handle):
self.visit(handle.type)
collector.visit(method.type)
return collector.types
+ def getAllInterfaces(self):
+ types = self.getAllTypes()
+ interfaces = [type for type in types if isinstance(type, Interface)]
+ for interface in self.interfaces:
+ if interface not in interfaces:
+ interfaces.append(interface)
+ return interfaces
+
def addFunction(self, function):
self.functions.append(function)
Float = Literal("float", "Float")
Double = Literal("double", "Double")
SizeT = Literal("size_t", "UInt")
-WString = Literal("wchar_t *", "WString")
+
+# C string (i.e., zero terminated)
+CString = String()
+WString = String("wchar_t *", kind="WString")
Int8 = Literal("int8_t", "SInt")
UInt8 = Literal("uint8_t", "UInt")