all_types = {}
+
+class Visitor:
+
+ def visit(self, type, *args, **kwargs):
+ return type.visit(self, *args, **kwargs)
+
+ def visit_void(self, void, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_literal(self, literal, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_string(self, string, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_const(self, const, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_struct(self, struct, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_array(self, array, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_blob(self, blob, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_enum(self, enum, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_bitmask(self, bitmask, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_pointer(self, pointer, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_handle(self, handle, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_alias(self, alias, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_opaque(self, opaque, *args, **kwargs):
+ raise NotImplementedError
+
+ def visit_interface(self, interface, *args, **kwargs):
+ raise NotImplementedError
+
+
+class OnceVisitor(Visitor):
+
+ def __init__(self):
+ self.__visited = set()
+
+ def visit(self, type, *args, **kwargs):
+ if type not in self.__visited:
+ self.__visited.add(type)
+ return type.visit(self, *args, **kwargs)
+ return None
+
+
+class Rebuilder(Visitor):
+
+ def visit_void(self, void):
+ return void
+
+ def visit_literal(self, literal):
+ return literal
+
+ def visit_string(self, string):
+ return string
+
+ def visit_const(self, const):
+ return Const(const.type)
+
+ def visit_struct(self, struct):
+ members = [self.visit(member) for member in struct.members]
+ return Struct(struct.name, members)
+
+ def visit_array(self, array):
+ type = self.visit(array.type)
+ return Array(type, array.length)
+
+ def visit_blob(self, blob):
+ type = self.visit(blob.type)
+ return Blob(type, blob.size)
+
+ def visit_enum(self, enum):
+ return enum
+
+ def visit_bitmask(self, bitmask):
+ type = self.visit(bitmask.type)
+ return Bitmask(type, bitmask.values)
+
+ def visit_pointer(self, pointer):
+ type = self.visit(pointer.type)
+ return Pointer(type)
+
+ def visit_handle(self, handle):
+ type = self.visit(handle.type)
+ return Handle(handle.name, type)
+
+ def visit_alias(self, alias):
+ type = self.visit(alias.type)
+ return Alias(alias.expr, type)
+
+ def visit_opaque(self, opaque):
+ return opaque
+
+
class Type:
__seq = 0
def __str__(self):
return self.expr
- def isoutput(self):
- return False
-
- def decl(self):
- pass
-
- def impl(self):
- pass
-
- def dump(self, instance):
+ def visit(self, visitor, *args, **kwargs):
raise NotImplementedError
-
- def wrap_instance(self, instance):
- pass
- def unwrap_instance(self, instance):
- pass
class _Void(Type):
def __init__(self):
Type.__init__(self, "void")
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_void(self, *args, **kwargs)
+
Void = _Void()
print ' Dump%s(%s);' % (self.id, instance)
-class Intrinsic(Concrete):
+class Literal(Type):
- def __init__(self, expr, format):
- Concrete.__init__(self, expr)
+ def __init__(self, expr, format, base=10):
+ Type.__init__(self, expr)
self.format = format
- def _dump(self, instance):
- print ' Log::TextF("%s", %s);' % (self.format, instance)
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_literal(self, *args, **kwargs)
class Const(Type):
def __init__(self, type):
- if isinstance(type, Pointer):
+ if type.expr.startswith("const "):
expr = type.expr + " const"
else:
expr = "const " + type.expr
self.type = type
- def dump(self, instance):
- self.type.dump(instance)
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_const(self, *args, **kwargs)
class Pointer(Type):
Type.__init__(self, type.expr + " *", 'P' + type.id)
self.type = type
- def dump(self, instance):
- print ' if(%s) {' % instance
- print ' Log::BeginReference("%s", %s);' % (self.type, instance)
- try:
- self.type.dump("*" + instance)
- except NotImplementedError:
- pass
- print ' Log::EndReference();'
- print ' }'
- print ' else'
- print ' Log::Text("NULL");'
-
- def wrap_instance(self, instance):
- self.type.wrap_instance("*" + instance)
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_pointer(self, *args, **kwargs)
- def unwrap_instance(self, instance):
- self.type.wrap_instance("*" + instance)
+class Handle(Type):
-def ConstPointer(type):
- return Pointer(Const(type))
+ def __init__(self, name, type):
+ Type.__init__(self, type.expr, 'P' + type.id)
+ self.name = name
+ self.type = type
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_handle(self, *args, **kwargs)
-class OutPointer(Pointer):
- def isoutput(self):
- return True
+def ConstPointer(type):
+ return Pointer(Const(type))
class Enum(Concrete):
Concrete.__init__(self, name)
self.values = values
- def _dump(self, instance):
- print ' switch(%s) {' % instance
- for value in self.values:
- print ' case %s:' % value
- print ' Log::Text("%s");' % value
- print ' break;'
- print ' default:'
- print ' Log::TextF("%%i", %s);' % instance
- print ' break;'
- print ' }'
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_enum(self, *args, **kwargs)
-class FakeEnum(Enum):
+def FakeEnum(type, values):
+ return Enum(type.expr, values)
- def __init__(self, type, values):
- Enum.__init__(self, type.expr, values)
- self.type = type
-
-class Flags(Concrete):
+class Bitmask(Concrete):
def __init__(self, type, values):
Concrete.__init__(self, type.expr)
self.type = type
self.values = values
- def _dump(self, instance):
- print ' bool l_First = true;'
- print ' %s l_Value = %s;' % (self.type, instance)
- for value in self.values:
- print ' if((l_Value & %s) == %s) {' % (value, value)
- print ' if(!l_First)'
- print ' Log::Text(" | ");'
- print ' Log::Text("%s");' % value
- print ' l_Value &= ~%s;' % value
- print ' l_First = false;'
- print ' }'
- print ' if(l_Value || l_First) {'
- print ' if(!l_First)'
- print ' Log::Text(" | ");'
- self.type.dump("l_Value");
- print ' }'
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_bitmask(self, *args, **kwargs)
+
+Flags = Bitmask
class Array(Type):
def __init__(self, type, length):
- Type.__init__(self, type.expr + " *", 'P' + type.id)
+ Type.__init__(self, type.expr + " *")
self.type = type
self.length = length
- def dump(self, instance):
- index = '__i' + self.type.id
- print ' for (int %s = 0; %s < %s; ++%s) {' % (index, index, self.length, index)
- print ' Log::BeginElement("%s");' % (self.type,)
- self.type.dump('(%s)[%s]' % (instance, index))
- print ' Log::EndElement();'
- print ' }'
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_array(self, *args, **kwargs)
- def wrap_instance(self, instance):
- self.type.wrap_instance("*" + instance)
- def unwrap_instance(self, instance):
- self.type.wrap_instance("*" + instance)
+class Blob(Type):
+ def __init__(self, type, size):
+ Type.__init__(self, type.expr + ' *')
+ self.type = type
+ self.size = size
-class OutArray(Array):
-
- def isoutput(self):
- return True
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_blob(self, *args, **kwargs)
class Struct(Concrete):
def __init__(self, name, members):
Concrete.__init__(self, name)
+ self.name = name
self.members = members
- def _dump(self, instance):
- for type, name in self.members:
- print ' Log::BeginElement("%s", "%s");' % (type, name)
- type.dump('(%s).%s' % (instance, name))
- print ' Log::EndElement();'
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_struct(self, *args, **kwargs)
class Alias(Type):
- def __init__(self, name, type):
- Type.__init__(self, name)
+ def __init__(self, expr, type):
+ Type.__init__(self, expr)
self.type = type
- def dump(self, instance):
- self.type.dump(instance)
-
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_alias(self, *args, **kwargs)
-class Out(Type):
- def __init__(self, type):
- Type.__init__(self, type.expr)
- self.type = type
+def Out(type, name):
+ arg = Arg(type, name, output=True)
+ return arg
- def isoutput(self):
- return True
-
- def decl(self):
- self.type.decl()
- def impl(self):
- self.type.impl()
+class Arg:
- def dump(self, instance):
- self.type.dump(instance)
-
- def wrap_instance(self, instance):
- self.type.wrap_instance(instance)
+ def __init__(self, type, name, output=False):
+ self.type = type
+ self.name = name
+ self.output = output
+ self.index = None
- def unwrap_instance(self, instance):
- self.type.unwrap_instance(instance)
+ def __str__(self):
+ return '%s %s' % (self.type, self.name)
class Function:
- def __init__(self, type, name, args, call = '__stdcall', fail = None):
+ def __init__(self, type, name, args, call = '', fail = None, sideeffects=True, hidden=False):
self.type = type
self.name = name
- self.args = args
+
+ self.args = []
+ index = 0
+ for arg in args:
+ if isinstance(arg, tuple):
+ arg_type, arg_name = arg
+ arg = Arg(arg_type, arg_name)
+ arg.index = index
+ index += 1
+ self.args.append(arg)
+
self.call = call
self.fail = fail
+ self.sideeffects = sideeffects
+ self.hidden = False
def prototype(self, name=None):
if name is not None:
s = self.type.expr + ' ' + s
s += "("
if self.args:
- s += ", ".join(["%s %s" % (type, name) for type, name in self.args])
+ s += ", ".join(["%s %s" % (arg.type, arg.name) for arg in self.args])
else:
s += "void"
s += ")"
return s
- def pointer_type(self):
- return 'P' + self.name
-
- def pointer_value(self):
- return 'p' + self.name
-
- def wrap_decl(self):
- ptype = self.pointer_type()
- pvalue = self.pointer_value()
- print 'typedef ' + self.prototype('* %s' % ptype) + ';'
- print 'static %s %s = NULL;' % (ptype, pvalue)
- print
- def get_true_pointer(self):
- raise NotImplementedError
+def StdFunction(*args, **kwargs):
+ kwargs.setdefault('call', 'GLAPIENTRY')
+ return Function(*args, **kwargs)
- def fail_impl(self):
- if self.fail is not None:
- if self.type is Void:
- assert self.fail == ''
- print ' return;'
- else:
- assert self.fail != ''
- print ' return %s;' % self.fail
- else:
- print ' ExitProcess(0);'
-
- def wrap_impl(self):
- pvalue = self.pointer_value()
- print self.prototype() + ' {'
- if self.type is Void:
- result = ''
- else:
- print ' %s result;' % self.type
- result = 'result = '
- self.get_true_pointer()
- print ' Log::BeginCall("%s");' % (self.name)
- for type, name in self.args:
- if not type.isoutput():
- type.unwrap_instance(name)
- print ' Log::BeginArg("%s", "%s");' % (type, name)
- type.dump(name)
- print ' Log::EndArg();'
- print ' %s%s(%s);' % (result, pvalue, ', '.join([str(name) for type, name in self.args]))
- for type, name in self.args:
- if type.isoutput():
- print ' Log::BeginArg("%s", "%s");' % (type, name)
- type.dump(name)
- print ' Log::EndArg();'
- type.wrap_instance(name)
- if self.type is not Void:
- print ' Log::BeginReturn("%s");' % self.type
- self.type.dump("result")
- print ' Log::EndReturn();'
- self.type.wrap_instance('result')
- print ' Log::EndCall();'
- self.post_call_impl()
- if self.type is not Void:
- print ' return result;'
- print '}'
- print
- def post_call_impl(self):
- pass
+def FunctionPointer(type, name, args, **kwargs):
+ # XXX
+ return Opaque(name)
class Interface(Type):
yield method
raise StopIteration
- def wrap_name(self):
- return "Wrap" + self.expr
- def wrap_pre_decl(self):
- print "class %s;" % self.wrap_name()
+class Method(Function):
- def wrap_decl(self):
- print "class %s : public %s " % (self.wrap_name(), self.name)
- print "{"
- print "public:"
- print " %s(%s * pInstance);" % (self.wrap_name(), self.name)
- print " virtual ~%s();" % self.wrap_name()
- print
- for method in self.itermethods():
- print " " + method.prototype() + ";"
- print
- #print "private:"
- print " %s * m_pInstance;" % (self.name,)
- print "};"
- print
+ def __init__(self, type, name, args):
+ Function.__init__(self, type, name, args, call = '__stdcall')
- def wrap_impl(self):
- print '%s::%s(%s * pInstance) {' % (self.wrap_name(), self.wrap_name(), self.name)
- print ' m_pInstance = pInstance;'
- print '}'
- print
- print '%s::~%s() {' % (self.wrap_name(), self.wrap_name())
- print '}'
- print
- for method in self.itermethods():
- print method.prototype(self.wrap_name() + '::' + method.name) + ' {'
- if method.type is Void:
- result = ''
- else:
- print ' %s result;' % method.type
- result = 'result = '
- print ' Log::BeginCall("%s");' % (self.name + '::' + method.name)
- print ' Log::BeginArg("%s *", "this");' % self.name
- print ' Log::BeginReference("%s", m_pInstance);' % self.name
- print ' Log::EndReference();'
- print ' Log::EndArg();'
- for type, name in method.args:
- if not type.isoutput():
- type.unwrap_instance(name)
- print ' Log::BeginArg("%s", "%s");' % (type, name)
- type.dump(name)
- print ' Log::EndArg();'
- print ' %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(name) for type, name in method.args]))
- for type, name in method.args:
- if type.isoutput():
- print ' Log::BeginArg("%s", "%s");' % (type, name)
- type.dump(name)
- print ' Log::EndArg();'
- type.wrap_instance(name)
- if method.type is not Void:
- print ' Log::BeginReturn("%s");' % method.type
- method.type.dump("result")
- print ' Log::EndReturn();'
- method.type.wrap_instance('result')
- print ' Log::EndCall();'
- if method.name == 'QueryInterface':
- print ' if(*ppvObj == m_pInstance)'
- print ' *ppvObj = this;'
- if method.name == 'Release':
- assert method.type is not Void
- print ' if(!result)'
- print ' delete this;'
- if method.type is not Void:
- print ' return result;'
- print '}'
- print
- print
+towrap = []
-class Method(Function):
- def __init__(self, type, name, args):
- Function.__init__(self, type, name, args)
+def WrapPointer(type):
+ return Pointer(type)
-towrap = []
+class String(Type):
-class WrapPointer(Pointer):
+ def __init__(self, expr = "char *", length = None):
+ Type.__init__(self, expr)
+ self.length = length
- def __init__(self, type):
- Pointer.__init__(self, type)
- if type not in towrap:
- towrap.append(type)
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_string(self, *args, **kwargs)
- def wrap_instance(self, instance):
- print " if(%s)" % instance
- print " %s = new %s(%s);" % (instance, self.type.wrap_name(), instance)
+CString = String()
- def unwrap_instance(self, instance):
- print " if(%s)" % instance
- print " %s = static_cast<%s *>(%s)->m_pInstance;" % (instance, self.type.wrap_name(), instance)
+class Opaque(Type):
+ '''Opaque pointer.'''
-class _String(Type):
+ def __init__(self, expr):
+ Type.__init__(self, expr)
- def __init__(self):
- Type.__init__(self, "char *")
+ def visit(self, visitor, *args, **kwargs):
+ return visitor.visit_opaque(self, *args, **kwargs)
- def dump(self, instance):
- print ' Log::DumpString((const char *)%s);' % instance
-String = _String()
+def OpaquePointer(type):
+ return Opaque(type.expr + ' *')
+
-class _WString(Type):
+class Collector(Visitor):
+ '''Collect.'''
def __init__(self):
- Type.__init__(self, "wchar_t *")
+ self.__visited = set()
+ self.types = []
+
+ def visit(self, type):
+ if type in self.__visited:
+ return
+ self.__visited.add(type)
+ Visitor.visit(self, type)
+ self.types.append(type)
+
+ def visit_void(self, literal):
+ pass
+
+ def visit_literal(self, literal):
+ pass
+
+ def visit_string(self, string):
+ pass
+
+ def visit_const(self, const):
+ self.visit(const.type)
+
+ def visit_struct(self, struct):
+ for type, name in struct.members:
+ self.visit(type)
+
+ def visit_array(self, array):
+ self.visit(array.type)
+
+ def visit_blob(self, array):
+ pass
+
+ def visit_enum(self, enum):
+ pass
+
+ def visit_bitmask(self, bitmask):
+ self.visit(bitmask.type)
+
+ def visit_pointer(self, pointer):
+ self.visit(pointer.type)
+
+ def visit_handle(self, handle):
+ self.visit(handle.type)
+
+ def visit_alias(self, alias):
+ self.visit(alias.type)
+
+ def visit_opaque(self, opaque):
+ pass
+
+ def visit_interface(self, interface):
+ pass
+
+
+class API:
+
+ def __init__(self, name):
+ self.name = name
+ self.headers = []
+ self.functions = []
+ self.interfaces = []
+
+ def all_types(self):
+ collector = Collector()
+ for function in self.functions:
+ for arg in function.args:
+ collector.visit(arg.type)
+ collector.visit(function.type)
+ for interface in self.interfaces:
+ collector.visit(interface)
+ for method in interface.methods:
+ for arg in method.args:
+ collector.visit(arg.type)
+ collector.visit(method.type)
+ return collector.types
+
+ def add_function(self, function):
+ self.functions.append(function)
+
+ def add_functions(self, functions):
+ for function in functions:
+ self.add_function(function)
+
+ def add_interface(self, interface):
+ self.interfaces.append(interface)
+
+ def add_interfaces(self, interfaces):
+ self.interfaces.extend(interfaces)
+
+
+Bool = Literal("bool", "Bool")
+SChar = Literal("signed char", "SInt")
+UChar = Literal("unsigned char", "UInt")
+Short = Literal("short", "SInt")
+Int = Literal("int", "SInt")
+Long = Literal("long", "SInt")
+LongLong = Literal("long long", "SInt")
+UShort = Literal("unsigned short", "UInt")
+UInt = Literal("unsigned int", "UInt")
+ULong = Literal("unsigned long", "UInt")
+ULongLong = Literal("unsigned long long", "UInt")
+Float = Literal("float", "Float")
+Double = Literal("double", "Float")
+SizeT = Literal("size_t", "UInt")
+WString = Literal("wchar_t *", "WString")
- def dump(self, instance):
- print ' Log::DumpWString(%s);' % instance
-
-WString = _WString()
-
-
-SChar = Intrinsic("signed char", "%i")
-UChar = Intrinsic("unsigned char", "%u")
-Short = Intrinsic("short", "%i")
-Int = Intrinsic("int", "%i")
-Long = Intrinsic("long", "%li")
-UShort = Intrinsic("unsigned short", "%u")
-UInt = Intrinsic("unsigned int", "%u")
-ULong = Intrinsic("unsigned long", "%lu")
-Float = Intrinsic("float", "%f")
-Double = Intrinsic("double", "%f")
-SizeT = Intrinsic("size_t", "%lu")
-
-
-def wrap():
- for type in all_types.itervalues():
- type.decl()
- print
- for type in all_types.itervalues():
- type.impl()
- print
- for type in towrap:
- type.wrap_pre_decl()
- print
- for type in towrap:
- type.wrap_decl()
- print
- for type in towrap:
- type.wrap_impl()
- print
projects / apitrace / blobdiff