import sys, os, string import getopt, traceback, keyword import defsparser, argtypes, override import definitions import reversewrapper class Coverage(object): def __init__(self, name): self.name = name self.wrapped = 0 self.not_wrapped = 0 def declare_wrapped(self): self.wrapped += 1 def declare_not_wrapped(self): self.not_wrapped += 1 def printstats(self): total = (self.wrapped + self.not_wrapped) if total: print >> sys.stderr, "***INFO*** The coverage of %s is %.2f%% (%i/%i)" %\ (self.name, float(self.wrapped*100)/total, self.wrapped, total) else: print >> sys.stderr, "***INFO*** There are no declared %s." %\ (self.name, ) functions_coverage = Coverage("global functions") methods_coverage = Coverage("methods") vproxies_coverage = Coverage("virtual proxies") vaccessors_coverage = Coverage("virtual accessors") iproxies_coverage = Coverage("interface proxies") def exc_info(): #traceback.print_exc() etype, value, tb = sys.exc_info() ret = "" try: sval = str(value) if etype == KeyError: ret = "No ArgType for %s" % (sval,) else: ret = sval finally: del etype, value, tb return ret def fixname(name): if keyword.iskeyword(name): return name + '_' return name class FileOutput: '''Simple wrapper for file object, that makes writing #line statements easier.''' # " def __init__(self, fp, filename=None): self.fp = fp self.lineno = 1 if filename: self.filename = filename else: self.filename = self.fp.name # handle writing to the file, and keep track of the line number ... def write(self, str): self.fp.write(str) self.lineno = self.lineno + string.count(str, '\n') def writelines(self, sequence): for line in sequence: self.write(line) def close(self): self.fp.close() def flush(self): self.fp.flush() def setline(self, linenum, filename): '''writes out a #line statement, for use by the C preprocessor.''' # " self.write('#line %d "%s"\n' % (linenum, filename)) def resetline(self): '''resets line numbering to the original file''' self.setline(self.lineno + 1, self.filename) class Wrapper: type_tmpl = \ 'PyTypeObject Py%(typename)s_Type = {\n' \ ' PyObject_HEAD_INIT(NULL)\n' \ ' 0, /* ob_size */\n' \ ' "%(classname)s", /* tp_name */\n' \ ' sizeof(%(tp_basicsize)s), /* tp_basicsize */\n' \ ' 0, /* tp_itemsize */\n' \ ' /* methods */\n' \ ' (destructor)%(tp_dealloc)s, /* tp_dealloc */\n' \ ' (printfunc)0, /* tp_print */\n' \ ' (getattrfunc)%(tp_getattr)s, /* tp_getattr */\n' \ ' (setattrfunc)%(tp_setattr)s, /* tp_setattr */\n' \ ' (cmpfunc)%(tp_compare)s, /* tp_compare */\n' \ ' (reprfunc)%(tp_repr)s, /* tp_repr */\n' \ ' (PyNumberMethods*)%(tp_as_number)s, /* tp_as_number */\n' \ ' (PySequenceMethods*)%(tp_as_sequence)s, /* tp_as_sequence */\n' \ ' (PyMappingMethods*)%(tp_as_mapping)s, /* tp_as_mapping */\n' \ ' (hashfunc)%(tp_hash)s, /* tp_hash */\n' \ ' (ternaryfunc)%(tp_call)s, /* tp_call */\n' \ ' (reprfunc)%(tp_str)s, /* tp_str */\n' \ ' (getattrofunc)%(tp_getattro)s, /* tp_getattro */\n' \ ' (setattrofunc)%(tp_setattro)s, /* tp_setattro */\n' \ ' (PyBufferProcs*)%(tp_as_buffer)s, /* tp_as_buffer */\n' \ ' %(tp_flags)s, /* tp_flags */\n' \ ' NULL, /* Documentation string */\n' \ ' (traverseproc)%(tp_traverse)s, /* tp_traverse */\n' \ ' (inquiry)%(tp_clear)s, /* tp_clear */\n' \ ' (richcmpfunc)%(tp_richcompare)s, /* tp_richcompare */\n' \ ' %(tp_weaklistoffset)s, /* tp_weaklistoffset */\n' \ ' (getiterfunc)%(tp_iter)s, /* tp_iter */\n' \ ' (iternextfunc)%(tp_iternext)s, /* tp_iternext */\n' \ ' %(tp_methods)s, /* tp_methods */\n' \ ' 0, /* tp_members */\n' \ ' %(tp_getset)s, /* tp_getset */\n' \ ' NULL, /* tp_base */\n' \ ' NULL, /* tp_dict */\n' \ ' (descrgetfunc)%(tp_descr_get)s, /* tp_descr_get */\n' \ ' (descrsetfunc)%(tp_descr_set)s, /* tp_descr_set */\n' \ ' %(tp_dictoffset)s, /* tp_dictoffset */\n' \ ' (initproc)%(tp_init)s, /* tp_init */\n' \ ' (allocfunc)%(tp_alloc)s, /* tp_alloc */\n' \ ' (newfunc)%(tp_new)s, /* tp_new */\n' \ ' (freefunc)%(tp_free)s, /* tp_free */\n' \ ' (inquiry)%(tp_is_gc)s /* tp_is_gc */\n' \ '};\n\n' slots_list = ['tp_getattr', 'tp_setattr', 'tp_getattro', 'tp_setattro', 'tp_compare', 'tp_repr', 'tp_as_number', 'tp_as_sequence', 'tp_as_mapping', 'tp_hash', 'tp_call', 'tp_str', 'tp_as_buffer', 'tp_richcompare', 'tp_iter', 'tp_iternext', 'tp_descr_get', 'tp_descr_set', 'tp_init', 'tp_alloc', 'tp_new', 'tp_free', 'tp_is_gc', 'tp_traverse', 'tp_clear', 'tp_dealloc', 'tp_flags'] getter_tmpl = \ 'static PyObject *\n' \ '%(funcname)s(PyObject *self, void *closure)\n' \ '{\n' \ '%(varlist)s' \ ' ret = %(field)s;\n' \ '%(codeafter)s\n' \ '}\n\n' parse_tmpl = \ ' if (!PyArg_ParseTupleAndKeywords(args, kwargs, "%(typecodes)s:%(name)s"%(parselist)s))\n' \ ' return %(errorreturn)s;\n' deprecated_tmpl = \ ' if (PyErr_Warn(PyExc_DeprecationWarning, "%(deprecationmsg)s") < 0)\n' \ ' return %(errorreturn)s;\n' methdef_tmpl = ' { "%(name)s", (PyCFunction)%(cname)s, %(flags)s },\n' noconstructor = \ 'static int\n' \ 'pygobject_no_constructor(PyObject *self, PyObject *args, PyObject *kwargs)\n' \ '{\n' \ ' gchar buf[512];\n' \ '\n' \ ' g_snprintf(buf, sizeof(buf), "%s is an abstract widget", self->ob_type->tp_name);\n' \ ' PyErr_SetString(PyExc_NotImplementedError, buf);\n' \ ' return -1;\n' \ '}\n\n' function_tmpl = \ 'static PyObject *\n' \ '_wrap_%(cname)s(PyObject *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' %(setreturn)s%(cname)s(%(arglist)s);\n' \ '%(codeafter)s\n' \ '}\n\n' virtual_accessor_tmpl = \ 'static PyObject *\n' \ '_wrap_%(cname)s(PyObject *cls%(extraparams)s)\n' \ '{\n' \ ' gpointer klass;\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' klass = g_type_class_ref(pyg_type_from_object(cls));\n' \ ' if (%(class_cast_macro)s(klass)->%(virtual)s)\n' \ ' %(setreturn)s%(class_cast_macro)s(klass)->%(virtual)s(%(arglist)s);\n' \ ' else {\n' \ ' PyErr_SetString(PyExc_NotImplementedError, ' \ '"virtual method %(name)s not implemented");\n' \ ' g_type_class_unref(klass);\n' \ ' return NULL;\n' \ ' }\n' \ ' g_type_class_unref(klass);\n' \ '%(codeafter)s\n' \ '}\n\n' # template for method calls constructor_tmpl = None method_tmpl = None def __init__(self, parser, objinfo, overrides, fp=FileOutput(sys.stdout)): self.parser = parser self.objinfo = objinfo self.overrides = overrides self.fp = fp def get_lower_name(self): return string.lower(string.replace(self.objinfo.typecode, '_TYPE_', '_', 1)) def get_field_accessor(self, fieldname): raise NotImplementedError def get_initial_class_substdict(self): return {} def get_initial_constructor_substdict(self, constructor): return { 'name': '%s.__init__' % self.objinfo.c_name, 'errorreturn': '-1' } def get_initial_method_substdict(self, method): return { 'name': '%s.%s' % (self.objinfo.c_name, method.name) } def write_class(self): self.fp.write('\n/* ----------- ' + self.objinfo.c_name + ' ----------- */\n\n') substdict = self.get_initial_class_substdict() if not substdict.has_key('tp_flags'): substdict['tp_flags'] = 'Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE' substdict['typename'] = self.objinfo.c_name if self.overrides.modulename: substdict['classname'] = '%s.%s' % (self.overrides.modulename, self.objinfo.name) else: substdict['classname'] = self.objinfo.name # Maybe this could be done in a nicer way, but I'll leave it as it is # for now: -- Johan if not self.overrides.slot_is_overriden('%s.tp_init' % self.objinfo.c_name): substdict['tp_init'] = self.write_constructor() substdict['tp_methods'] = self.write_methods() substdict['tp_getset'] = self.write_getsets() # handle slots ... for slot in self.slots_list: slotname = '%s.%s' % (self.objinfo.c_name, slot) slotfunc = '_wrap_%s_%s' % (self.get_lower_name(), slot) if slot[:6] == 'tp_as_': slotfunc = '&' + slotfunc if self.overrides.slot_is_overriden(slotname): data = self.overrides.slot_override(slotname) self.write_function(slotname, data) substdict[slot] = slotfunc else: if not substdict.has_key(slot): substdict[slot] = '0' self.fp.write(self.type_tmpl % substdict) self.write_virtuals() def write_function_wrapper(self, function_obj, template, handle_return=0, is_method=0, kwargs_needed=0, substdict=None): '''This function is the guts of all functions that generate wrappers for functions, methods and constructors.''' if not substdict: substdict = {} info = argtypes.WrapperInfo() substdict.setdefault('errorreturn', 'NULL') # for methods, we want the leading comma if is_method: info.arglist.append('') if function_obj.varargs: raise ValueError, "varargs functions not supported" for param in function_obj.params: if param.pdflt and '|' not in info.parsestr: info.add_parselist('|', [], []) handler = argtypes.matcher.get(param.ptype) handler.write_param(param.ptype, param.pname, param.pdflt, param.pnull, info) substdict['setreturn'] = '' if handle_return: if function_obj.ret not in ('none', None): substdict['setreturn'] = 'ret = ' handler = argtypes.matcher.get(function_obj.ret) handler.write_return(function_obj.ret, function_obj.caller_owns_return, info) if function_obj.deprecated != None: deprecated = self.deprecated_tmpl % { 'deprecationmsg': function_obj.deprecated, 'errorreturn': substdict['errorreturn'] } else: deprecated = '' # if name isn't set, set it to function_obj.name substdict.setdefault('name', function_obj.name) if self.objinfo: substdict['typename'] = self.objinfo.c_name substdict.setdefault('cname', function_obj.c_name) substdict['varlist'] = info.get_varlist() substdict['typecodes'] = info.parsestr substdict['parselist'] = info.get_parselist() substdict['arglist'] = info.get_arglist() substdict['codebefore'] = deprecated + \ string.replace(info.get_codebefore(), 'return NULL', 'return ' + substdict['errorreturn']) substdict['codeafter'] = string.replace(info.get_codeafter(), 'return NULL', 'return ' + substdict['errorreturn']) if info.parsestr or kwargs_needed: substdict['parseargs'] = self.parse_tmpl % substdict substdict['extraparams'] = ', PyObject *args, PyObject *kwargs' flags = 'METH_VARARGS|METH_KEYWORDS' # prepend the keyword list to the variable list substdict['varlist'] = info.get_kwlist() + substdict['varlist'] else: substdict['parseargs'] = '' substdict['extraparams'] = '' flags = 'METH_NOARGS' return template % substdict, flags def write_constructor(self): initfunc = '0' constructor = self.parser.find_constructor(self.objinfo,self.overrides) if constructor: funcname = constructor.c_name try: if self.overrides.is_overriden(funcname): data = self.overrides.override(funcname) self.write_function(funcname, data) else: # ok, a hack to determine if we should use new-style constructores :P if getattr(self, 'write_property_based_constructor', None) is not None: if (len(constructor.params) == 0 or isinstance(constructor.params[0], definitions.Property)): # write_property_based_constructor is only # implemented in GObjectWrapper return self.write_property_based_constructor(constructor) else: print >> sys.stderr, "Warning: generating old-style constructor for",\ constructor.c_name # write constructor from template ... code = self.write_function_wrapper(constructor, self.constructor_tmpl, handle_return=0, is_method=0, kwargs_needed=1, substdict=self.get_initial_constructor_substdict(constructor))[0] self.fp.write(code) initfunc = '_wrap_' + funcname except: sys.stderr.write('Could not write constructor for %s: %s\n' % (self.objinfo.c_name, exc_info())) initfunc = self.write_noconstructor() else: initfunc = self.write_default_constructor() return initfunc def write_noconstructor(self): # this is a hack ... if not hasattr(self.overrides, 'no_constructor_written'): self.fp.write(self.noconstructor) self.overrides.no_constructor_written = 1 initfunc = 'pygobject_no_constructor' return initfunc def write_default_constructor(self): return self.write_noconstructor() def get_methflags(self, funcname): if self.overrides.wants_kwargs(funcname): return 'METH_VARARGS|METH_KEYWORDS' elif self.overrides.wants_noargs(funcname): return 'METH_NOARGS' else: return 'METH_VARARGS' def write_function(self, funcname, data): lineno, filename = self.overrides.getstartline(funcname) self.fp.setline(lineno, filename) self.fp.write(data) self.fp.resetline() self.fp.write('\n\n') def _get_class_virtual_substdict(self, meth, cname, parent): substdict = self.get_initial_method_substdict(meth) substdict['virtual'] = substdict['name'].split('.')[1] substdict['cname'] = cname substdict['class_cast_macro'] = parent.typecode.replace('_TYPE_', '_', 1) + "_CLASS" substdict['typecode'] = self.objinfo.typecode substdict['cast'] = string.replace(parent.typecode, '_TYPE_', '_', 1) return substdict def write_methods(self): methods = [] klass = self.objinfo.c_name # First, get methods from the defs files for meth in self.parser.find_methods(self.objinfo): method_name = meth.c_name if self.overrides.is_ignored(method_name): continue try: if self.overrides.is_overriden(method_name): if not self.overrides.is_already_included(method_name): data = self.overrides.override(method_name) self.write_function(method_name, data) methflags = self.get_methflags(method_name) else: # write constructor from template ... code, methflags = self.write_function_wrapper(meth, self.method_tmpl, handle_return=1, is_method=1, substdict=self.get_initial_method_substdict(meth)) self.fp.write(code) methods.append(self.methdef_tmpl % { 'name': fixname(meth.name), 'cname': '_wrap_' + method_name, 'flags': methflags}) methods_coverage.declare_wrapped() except: methods_coverage.declare_not_wrapped() sys.stderr.write('Could not write method %s.%s: %s\n' % (klass, meth.name, exc_info())) # Now try to see if there are any defined in the override for method_name in self.overrides.get_defines_for(klass): c_name = override.class2cname(klass, method_name) if self.overrides.is_already_included(method_name): continue try: data = self.overrides.define(klass, method_name) self.write_function(method_name, data) methflags = self.get_methflags(method_name) methods.append(self.methdef_tmpl % { 'name': method_name, 'cname': '_wrap_' + c_name, 'flags': methflags}) methods_coverage.declare_wrapped() except: methods_coverage.declare_not_wrapped() sys.stderr.write('Could not write method %s.%s: %s\n' % (klass, meth.name, exc_info())) # Add GObject virtual method accessors, for chaining to parent # virtuals from subclasses methods += self.write_virtual_accessors() if methods: methoddefs = '_Py%s_methods' % self.objinfo.c_name # write the PyMethodDef structure methods.append(' { NULL, NULL, 0 }\n') self.fp.write('static PyMethodDef %s[] = {\n' % methoddefs) self.fp.write(string.join(methods, '')) self.fp.write('};\n\n') else: methoddefs = 'NULL' return methoddefs def write_virtual_accessors(self): klass = self.objinfo.c_name methods = [] for meth in self.parser.find_virtuals(self.objinfo): method_name = self.objinfo.c_name + "__do_" + meth.name if self.overrides.is_ignored(method_name): continue try: if self.overrides.is_overriden(method_name): if not self.overrides.is_already_included(method_name): data = self.overrides.override(method_name) self.write_function(method_name, data) methflags = self.get_methflags(method_name) else: # temporarily add a 'self' parameter as first argument meth.params.insert(0, definitions.Parameter( ptype=(self.objinfo.c_name + '*'), pname='self', pdflt=None, pnull=None)) try: # write method from template ... code, methflags = self.write_function_wrapper(meth, self.virtual_accessor_tmpl, handle_return=True, is_method=False, substdict=self._get_class_virtual_substdict(meth, method_name, self.objinfo)) self.fp.write(code) finally: del meth.params[0] methods.append(self.methdef_tmpl % { 'name': "do_" + fixname(meth.name), 'cname': '_wrap_' + method_name, 'flags': methflags + '|METH_CLASS'}) vaccessors_coverage.declare_wrapped() except: vaccessors_coverage.declare_not_wrapped() sys.stderr.write('Could not write virtual accessor method %s.%s: %s\n' % (klass, meth.name, exc_info())) return methods def write_virtuals(self): '''Write _wrap_FooBar__proxy_do_zbr() reverse wrapers for GObject virtuals''' klass = self.objinfo.c_name virtuals = [] for meth in self.parser.find_virtuals(self.objinfo): method_name = self.objinfo.c_name + "__proxy_do_" + meth.name if self.overrides.is_ignored(method_name): continue try: if self.overrides.is_overriden(method_name): if not self.overrides.is_already_included(method_name): data = self.overrides.override(method_name) self.write_function(method_name, data) else: # write virtual proxy ... ret, props = argtypes.matcher.get_reverse_ret(meth.ret) wrapper = reversewrapper.ReverseWrapper( '_wrap_' + method_name, is_static=True) wrapper.set_return_type(ret(wrapper, **props)) wrapper.add_parameter(reversewrapper.PyGObjectMethodParam( wrapper, "self", method_name="do_" + meth.name, c_type=(klass + ' *'))) for param in meth.params: handler, props = argtypes.matcher.get_reverse(param.ptype) wrapper.add_parameter(handler(wrapper, param.pname, **props)) buf = reversewrapper.MemoryCodeSink() wrapper.generate(buf) self.fp.write(buf.flush()) virtuals.append((fixname(meth.name), '_wrap_' + method_name)) vproxies_coverage.declare_wrapped() except KeyError: vproxies_coverage.declare_not_wrapped() virtuals.append((fixname(meth.name), None)) sys.stderr.write('Could not write virtual proxy %s.%s: %s\n' % (klass, meth.name, exc_info())) if virtuals: # Write a 'pygtk class init' function for this object, # except when the object type is explicitly ignored (like # GtkPlug and GtkSocket on win32). if self.overrides.is_ignored(self.objinfo.typecode): return class_cast_macro = self.objinfo.typecode.replace('_TYPE_', '_', 1) + "_CLASS" cast_macro = self.objinfo.typecode.replace('_TYPE_', '_', 1) funcname = "__%s_class_init" % klass self.objinfo.class_init_func = funcname have_implemented_virtuals = not not [True for name, cname in virtuals if cname is not None] self.fp.write(('\nstatic int\n' '%(funcname)s(gpointer gclass, PyTypeObject *pyclass)\n' '{\n') % vars()) if have_implemented_virtuals: self.fp.write(' PyObject *o;\n') self.fp.write( ' %(klass)sClass *klass = %(class_cast_macro)s(gclass);\n' % vars()) for name, cname in virtuals: do_name = 'do_' + name if cname is None: self.fp.write('\n /* overriding %(do_name)s ' 'is currently not supported */\n' % vars()) else: self.fp.write(''' if ((o = PyDict_GetItemString(pyclass->tp_dict, "%(do_name)s")) && !PyObject_TypeCheck(o, &PyCFunction_Type)) klass->%(name)s = %(cname)s;\n''' % vars()) self.fp.write(' return 0;\n}\n') def write_getsets(self): lower_name = self.get_lower_name() getsets_name = lower_name + '_getsets' getterprefix = '_wrap_' + lower_name + '__get_' setterprefix = '_wrap_' + lower_name + '__set_' # no overrides for the whole function. If no fields, don't write a func if not self.objinfo.fields: return '0' getsets = [] for ftype, fname in self.objinfo.fields: gettername = '0' settername = '0' attrname = self.objinfo.c_name + '.' + fname if self.overrides.attr_is_overriden(attrname): code = self.overrides.attr_override(attrname) self.write_function(attrname, code) if string.find(code, getterprefix + fname) >= 0: gettername = getterprefix + fname if string.find(code, setterprefix + fname) >= 0: settername = setterprefix + fname if gettername == '0': try: funcname = getterprefix + fname info = argtypes.WrapperInfo() handler = argtypes.matcher.get(ftype) # for attributes, we don't own the "return value" handler.write_return(ftype, 0, info) self.fp.write(self.getter_tmpl % { 'funcname': funcname, 'varlist': info.varlist, 'field': self.get_field_accessor(fname), 'codeafter': info.get_codeafter() }) gettername = funcname except: sys.stderr.write("Could not write getter for %s.%s: %s\n" % (self.objinfo.c_name, fname, exc_info())) if gettername != '0' or settername != '0': getsets.append(' { "%s", (getter)%s, (setter)%s },\n' % (fixname(fname), gettername, settername)) if not getsets: return '0' self.fp.write('static PyGetSetDef %s[] = {\n' % getsets_name) for getset in getsets: self.fp.write(getset) self.fp.write(' { NULL, (getter)0, (setter)0 },\n') self.fp.write('};\n\n') return getsets_name def write_functions(self, prefix): self.fp.write('\n/* ----------- functions ----------- */\n\n') functions = [] # First, get methods from the defs files for func in self.parser.find_functions(): funcname = func.c_name if self.overrides.is_ignored(funcname): continue try: if self.overrides.is_overriden(funcname): data = self.overrides.override(funcname) self.write_function(funcname, data) methflags = self.get_methflags(funcname) else: # write constructor from template ... code, methflags = self.write_function_wrapper(func, self.function_tmpl, handle_return=1, is_method=0) self.fp.write(code) functions.append(self.methdef_tmpl % { 'name': func.name, 'cname': '_wrap_' + funcname, 'flags': methflags }) functions_coverage.declare_wrapped() except: functions_coverage.declare_not_wrapped() sys.stderr.write('Could not write function %s: %s\n' % (func.name, exc_info())) # Now try to see if there are any defined in the override for funcname in self.overrides.get_functions(): try: data = self.overrides.function(funcname) self.write_function(funcname) methflags = self.get_methflags(funcname) functions.append(self.methdef_tmpl % { 'name': funcname, 'cname': '_wrap_' + funcname, 'flags': methflags }) functions_coverage.declare_wrapped() except: functions_coverage.declare_not_wrapped() sys.stderr.write('Could not write function %s: %s\n' % (funcname, exc_info())) # write the PyMethodDef structure functions.append(' { NULL, NULL, 0 }\n') self.fp.write('PyMethodDef ' + prefix + '_functions[] = {\n') self.fp.write(string.join(functions, '')) self.fp.write('};\n\n') class GObjectWrapper(Wrapper): constructor_tmpl = \ 'static int\n' \ '_wrap_%(cname)s(PyGObject *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' self->obj = (GObject *)%(cname)s(%(arglist)s);\n' \ '%(codeafter)s\n' \ ' if (!self->obj) {\n' \ ' PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n' \ ' return -1;\n' \ ' }\n' \ '%(aftercreate)s' \ ' pygobject_register_wrapper((PyObject *)self);\n' \ ' return 0;\n' \ '}\n\n' method_tmpl = \ 'static PyObject *\n' \ '_wrap_%(cname)s(PyGObject *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' pyg_begin_allow_threads;\n' \ ' %(setreturn)s%(cname)s(%(cast)s(self->obj)%(arglist)s);\n' \ ' pyg_end_allow_threads;\n' \ '%(codeafter)s\n' \ '}\n\n' def __init__(self, parser, objinfo, overrides, fp=FileOutput(sys.stdout)): Wrapper.__init__(self, parser, objinfo, overrides, fp) if self.objinfo: self.castmacro = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1) def get_initial_class_substdict(self): return { 'tp_basicsize' : 'PyGObject', 'tp_weaklistoffset' : 'offsetof(PyGObject, weakreflist)', 'tp_dictoffset' : 'offsetof(PyGObject, inst_dict)' } def get_field_accessor(self, fieldname): castmacro = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1) return '%s(pygobject_get(self))->%s' % (castmacro, fieldname) def get_initial_constructor_substdict(self, constructor): substdict = Wrapper.get_initial_constructor_substdict(self, constructor) if not constructor.caller_owns_return: substdict['aftercreate'] = " g_object_ref(self->obj);\n" else: substdict['aftercreate'] = '' return substdict def get_initial_method_substdict(self, method): substdict = Wrapper.get_initial_method_substdict(self, method) substdict['cast'] = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1) return substdict def write_default_constructor(self): return '0' def write_property_based_constructor(self, constructor): out = self.fp print >> out, "static int" print >> out, '_wrap_%s(PyGObject *self, PyObject *args,'\ ' PyObject *kwargs)\n{' % constructor.c_name print >> out, " GType obj_type = pyg_type_from_object((PyObject *) self);" def py_str_list_to_c(arg): if arg: return "{" + ", ".join(map(lambda s: '"' + s + '"', arg)) + ", NULL }" else: return "{ NULL }" classname = '%s.%s' % (self.overrides.modulename, self.objinfo.name) if constructor.params: mandatory_arguments = [param for param in constructor.params if not param.optional] optional_arguments = [param for param in constructor.params if param.optional] arg_names = py_str_list_to_c([param.argname for param in mandatory_arguments + optional_arguments]) prop_names = py_str_list_to_c([param.pname for param in mandatory_arguments + optional_arguments]) print >> out, " GParameter params[%i];" % len(constructor.params) print >> out, " PyObject *parsed_args[%i] = {NULL, };" % len(constructor.params) print >> out, " char *arg_names[] = %s;" % arg_names print >> out, " char *prop_names[] = %s;" % prop_names print >> out, " guint nparams, i;" print >> out if constructor.deprecated is not None: print >> out, ' if (PyErr_Warn(PyExc_DeprecationWarning, "%s") < 0)' %\ constructor.deprecated print >> out, ' return -1;' print >> out print >> out, " if (!PyArg_ParseTupleAndKeywords(args, kwargs, ", template = '"' if mandatory_arguments: template += "O"*len(mandatory_arguments) if optional_arguments: template += "|" + "O"*len(optional_arguments) template += ':%s.__init__"' % classname print >> out, template, ", arg_names", for i in range(len(constructor.params)): print >> out, ", &parsed_args[%i]" % i, print >> out, "))" print >> out, " return -1;" print >> out print >> out, " memset(params, 0, sizeof(GParameter)*%i);" % len(constructor.params) print >> out, " if (!pyg_parse_constructor_args(obj_type, arg_names, prop_names," print >> out, " params, &nparams, parsed_args))" print >> out, " return -1;" print >> out, " self->obj = g_object_newv(obj_type, nparams, params);" print >> out, " for (i = 0; i < nparams; ++i)" print >> out, " g_value_unset(¶ms[i].value);" else: print >> out, " static char* kwlist[] = { NULL };"; print >> out if constructor.deprecated is not None: print >> out, ' if (PyErr_Warn(PyExc_DeprecationWarning, "%s") < 0)' %\ constructor.deprecated print >> out, ' return -1;' print >> out print >> out, ' if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":%s.__init__", kwlist))' % classname print >> out, " return -1;" print >> out print >> out, " self->obj = g_object_newv(obj_type, 0, NULL);" print >> out, \ ' if (!self->obj) {\n' \ ' PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n' \ ' return -1;\n' \ ' }\n' if not constructor.caller_owns_return: print >> out, " g_object_ref(self->obj);\n" print >> out, \ ' pygobject_register_wrapper((PyObject *)self);\n' \ ' return 0;\n' \ '}\n\n' % { 'typename': classname } return "_wrap_%s" % constructor.c_name ## TODO : Add GstMiniObjectWrapper(Wrapper) class GstMiniObjectWrapper(Wrapper): constructor_tmpl = \ 'static int\n' \ '_wrap_%(cname)s(PyGstMiniObject *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' self->obj = (GstMiniObject *)%(cname)s(%(arglist)s);\n' \ '%(codeafter)s\n' \ ' if (!self->obj) {\n' \ ' PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s miniobject");\n' \ ' return -1;\n' \ ' }\n' \ '%(aftercreate)s' \ ' pygstminiobject_register_wrapper((PyObject *)self);\n' \ ' return 0;\n' \ '}\n\n' method_tmpl = \ 'static PyObject *\n' \ '_wrap_%(cname)s(PyGstMiniObject *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' pyg_begin_allow_threads;\n' \ ' %(setreturn)s%(cname)s(%(cast)s(self->obj)%(arglist)s);\n' \ ' pyg_end_allow_threads;\n' \ '%(codeafter)s\n' \ '}\n\n' def __init__(self, parser, objinfo, overrides, fp=FileOutput(sys.stdout)): Wrapper.__init__(self, parser, objinfo, overrides, fp) if self.objinfo: self.castmacro = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1) def get_initial_class_substdict(self): return { 'tp_basicsize' : 'PyGstMiniObject', 'tp_weaklistoffset' : 'offsetof(PyGstMiniObject, weakreflist)', 'tp_dictoffset' : 'offsetof(PyGstMiniObject, inst_dict)' } def get_field_accessor(self, fieldname): castmacro = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1) return '%s(pygstminiobject_get(self))->%s' % (castmacro, fieldname) def get_initial_constructor_substdict(self, constructor): substdict = Wrapper.get_initial_constructor_substdict(self, constructor) if not constructor.caller_owns_return: substdict['aftercreate'] = " gst_mini_object_ref(self->obj);\n" else: substdict['aftercreate'] = '' return substdict def get_initial_method_substdict(self, method): substdict = Wrapper.get_initial_method_substdict(self, method) substdict['cast'] = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1) return substdict class GInterfaceWrapper(GObjectWrapper): def get_initial_class_substdict(self): return { 'tp_basicsize' : 'PyObject', 'tp_weaklistoffset' : '0', 'tp_dictoffset' : '0'} def write_constructor(self): # interfaces have no constructors ... return '0' def write_getsets(self): # interfaces have no fields ... return '0' def write_virtual_accessors(self): ## we don't want the 'chaining' functions for interfaces return [] def write_virtuals(self): ## Now write reverse method wrappers, which let python code ## implement interface methods. # First, get methods from the defs files klass = self.objinfo.c_name proxies = [] for meth in self.parser.find_virtuals(self.objinfo): method_name = self.objinfo.c_name + "__proxy_do_" + meth.name if self.overrides.is_ignored(method_name): continue try: if self.overrides.is_overriden(method_name): if not self.overrides.is_already_included(method_name): data = self.overrides.override(method_name) self.write_function(method_name, data) else: # write proxy ... ret, props = argtypes.matcher.get_reverse_ret(meth.ret) wrapper = reversewrapper.ReverseWrapper( '_wrap_' + method_name, is_static=True) wrapper.set_return_type(ret(wrapper, **props)) wrapper.add_parameter(reversewrapper.PyGObjectMethodParam( wrapper, "self", method_name="do_" + meth.name, c_type=(klass + ' *'))) for param in meth.params: handler, props = argtypes.matcher.get_reverse(param.ptype) wrapper.add_parameter(handler(wrapper, param.pname, **props)) buf = reversewrapper.MemoryCodeSink() wrapper.generate(buf) self.fp.write(buf.flush()) proxies.append((fixname(meth.name), '_wrap_' + method_name)) iproxies_coverage.declare_wrapped() except KeyError: iproxies_coverage.declare_not_wrapped() proxies.append((fixname(meth.name), None)) sys.stderr.write('Could not write interface proxy %s.%s: %s\n' % (klass, meth.name, exc_info())) if proxies: ## Write an interface init function for this object funcname = "__%s__interface_init" % klass vtable = self.objinfo.vtable self.fp.write(('\nstatic void\n' '%(funcname)s(%(vtable)s *iface)\n' '{\n') % vars()) for name, cname in proxies: do_name = 'do_' + name if cname is not None: self.fp.write(' iface->%s = %s;\n' % (name, cname)) self.fp.write('}\n\n') interface_info = "__%s__iinfo" % klass self.fp.write(''' static const GInterfaceInfo %s = { (GInterfaceInitFunc) %s, NULL, NULL }; ''' % (interface_info, funcname)) self.objinfo.interface_info = interface_info class GBoxedWrapper(Wrapper): constructor_tmpl = \ 'static int\n' \ '_wrap_%(cname)s(PyGBoxed *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' self->gtype = %(typecode)s;\n' \ ' self->free_on_dealloc = FALSE;\n' \ ' self->boxed = %(cname)s(%(arglist)s);\n' \ '%(codeafter)s\n' \ ' if (!self->boxed) {\n' \ ' PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n' \ ' return -1;\n' \ ' }\n' \ ' self->free_on_dealloc = TRUE;\n' \ ' return 0;\n' \ '}\n\n' method_tmpl = \ 'static PyObject *\n' \ '_wrap_%(cname)s(PyObject *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' %(setreturn)s%(cname)s(pyg_boxed_get(self, %(typename)s)%(arglist)s);\n' \ '%(codeafter)s\n' \ '}\n\n' def get_initial_class_substdict(self): return { 'tp_basicsize' : 'PyGBoxed', 'tp_weaklistoffset' : '0', 'tp_dictoffset' : '0' } def get_field_accessor(self, fieldname): return 'pyg_boxed_get(self, %s)->%s' % (self.objinfo.c_name, fieldname) def get_initial_constructor_substdict(self, constructor): substdict = Wrapper.get_initial_constructor_substdict(self, constructor) substdict['typecode'] = self.objinfo.typecode return substdict class GPointerWrapper(GBoxedWrapper): constructor_tmpl = \ 'static int\n' \ '_wrap_%(cname)s(PyGPointer *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' self->gtype = %(typecode)s;\n' \ ' self->pointer = %(cname)s(%(arglist)s);\n' \ '%(codeafter)s\n' \ ' if (!self->pointer) {\n' \ ' PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");\n' \ ' return -1;\n' \ ' }\n' \ ' return 0;\n' \ '}\n\n' method_tmpl = \ 'static PyObject *\n' \ '_wrap_%(cname)s(PyObject *self%(extraparams)s)\n' \ '{\n' \ '%(varlist)s' \ '%(parseargs)s' \ '%(codebefore)s' \ ' %(setreturn)s%(cname)s(pyg_pointer_get(self, %(typename)s)%(arglist)s);\n' \ '%(codeafter)s\n' \ '}\n\n' def get_initial_class_substdict(self): return { 'tp_basicsize' : 'PyGPointer', 'tp_weaklistoffset' : '0', 'tp_dictoffset' : '0' } def get_field_accessor(self, fieldname): return 'pyg_pointer_get(self, %s)->%s' % (self.objinfo.c_name, fieldname) def get_initial_constructor_substdict(self, constructor): substdict = Wrapper.get_initial_constructor_substdict(self, constructor) substdict['typecode'] = self.objinfo.typecode return substdict def write_headers(data, fp): fp.write('/* -- THIS FILE IS GENERATED - DO NOT EDIT */') fp.write('/* -*- Mode: C; c-basic-offset: 4 -*- */\n\n') fp.write('#include \n\n\n') fp.write(data) fp.resetline() fp.write('\n\n') def write_imports(overrides, fp): fp.write('/* ---------- types from other modules ---------- */\n') for module, pyname, cname in overrides.get_imports(): fp.write('static PyTypeObject *_%s;\n' % cname) fp.write('#define %s (*_%s)\n' % (cname, cname)) fp.write('\n\n') def write_type_declarations(parser, fp): fp.write('/* ---------- forward type declarations ---------- */\n') for obj in parser.boxes: fp.write('PyTypeObject Py' + obj.c_name + '_Type;\n') for obj in parser.objects: fp.write('PyTypeObject Py' + obj.c_name + '_Type;\n') for obj in parser.miniobjects: fp.write('PyTypeObject Py' + obj.c_name + '_Type;\n') for interface in parser.interfaces: fp.write('PyTypeObject Py' + interface.c_name + '_Type;\n') fp.write('\n') def write_classes(parser, overrides, fp): for klass, items in ((GBoxedWrapper, parser.boxes), (GPointerWrapper, parser.pointers), (GObjectWrapper, parser.objects), (GstMiniObjectWrapper, parser.miniobjects), (GInterfaceWrapper, parser.interfaces)): for item in items: instance = klass(parser, item, overrides, fp) instance.write_class() fp.write('\n') def write_enums(parser, prefix, fp=sys.stdout): if not parser.enums: return fp.write('\n/* ----------- enums and flags ----------- */\n\n') fp.write('void\n' + prefix + '_add_constants(PyObject *module, const gchar *strip_prefix)\n{\n') for enum in parser.enums: if enum.typecode is None: for nick, value in enum.values: fp.write(' PyModule_AddIntConstant(module, pyg_constant_strip_prefix("%s", strip_prefix), %s);\n' % (value, value)) else: if enum.deftype == 'enum': fp.write(' pyg_enum_add(module, "%s", strip_prefix, %s);\n' % (enum.name, enum.typecode)) else: fp.write(' pyg_flags_add(module, "%s", strip_prefix, %s);\n' % (enum.name, enum.typecode)) fp.write('\n') fp.write(' if (PyErr_Occurred())\n') fp.write(' PyErr_Print();\n') fp.write('}\n\n') def write_extension_init(overrides, prefix, fp): fp.write('/* initialise stuff extension classes */\n') fp.write('void\n' + prefix + '_register_classes(PyObject *d)\n{\n') imports = overrides.get_imports()[:] if imports: bymod = {} for module, pyname, cname in imports: bymod.setdefault(module, []).append((pyname, cname)) fp.write(' PyObject *module;\n\n') for module in bymod: fp.write(' if ((module = PyImport_ImportModule("%s")) != NULL) {\n' % module) fp.write(' PyObject *moddict = PyModule_GetDict(module);\n\n') for pyname, cname in bymod[module]: fp.write(' _%s = (PyTypeObject *)PyDict_GetItemString(moddict, "%s");\n' % (cname, pyname)) fp.write(' if (_%s == NULL) {\n' % cname) fp.write(' PyErr_SetString(PyExc_ImportError,\n') fp.write(' "cannot import name %s from %s");\n' % (pyname, module)) fp.write(' return;\n') fp.write(' }\n') fp.write(' } else {\n') fp.write(' PyErr_SetString(PyExc_ImportError,\n') fp.write(' "could not import %s");\n' % module) fp.write(' return;\n') fp.write(' }\n') fp.write('\n') fp.write(overrides.get_init() + '\n') fp.resetline() def write_registers(parser, fp): for boxed in parser.boxes: fp.write(' pyg_register_boxed(d, "' + boxed.name + '", ' + boxed.typecode + ', &Py' + boxed.c_name + '_Type);\n') for pointer in parser.pointers: fp.write(' pyg_register_pointer(d, "' + pointer.name + '", ' + pointer.typecode + ', &Py' + pointer.c_name + '_Type);\n') for interface in parser.interfaces: fp.write(' pyg_register_interface(d, "' + interface.name + '", '+ interface.typecode + ', &Py' + interface.c_name + '_Type);\n') if interface.interface_info is not None: fp.write(' pyg_register_interface_info(%s, &%s);\n' % (interface.typecode, interface.interface_info)) objects = parser.objects[:] pos = 0 while pos < len(objects): parent = objects[pos].parent for i in range(pos+1, len(objects)): if objects[i].c_name == parent: objects.insert(i+1, objects[pos]) del objects[pos] break else: pos = pos + 1 for obj in objects: bases = [] if obj.parent != None: bases.append(obj.parent) bases = bases + obj.implements if bases: fp.write(' pygobject_register_class(d, "' + obj.c_name + '", ' + obj.typecode + ', &Py' + obj.c_name + '_Type, Py_BuildValue("(' + 'O' * len(bases) + ')", ' + string.join(map(lambda s: '&Py'+s+'_Type', bases), ', ') + '));\n') else: fp.write(' pygobject_register_class(d, "' + obj.c_name + '", ' + obj.typecode + ', &Py' + obj.c_name + '_Type, NULL);\n') if obj.class_init_func is not None: fp.write(' pyg_register_class_init(%s, %s);\n' % (obj.typecode, obj.class_init_func)) #TODO: register mini-objects miniobjects = parser.miniobjects[:] for obj in miniobjects: bases = [] if obj.parent != None: bases.append(obj.parent) bases = bases + obj.implements if bases: fp.write(' pygstminiobject_register_class(d, "' + obj.c_name + '", ' + obj.typecode + ', &Py' + obj.c_name + '_Type, Py_BuildValue("(' + 'O' * len(bases) + ')", ' + string.join(map(lambda s: '&Py'+s+'_Type', bases), ', ') + '));\n') else: fp.write(' pygstminiobject_register_class(d, "' + obj.c_name + '", ' + obj.typecode + ', &Py' + obj.c_name + '_Type, NULL);\n') fp.write('}\n') def write_source(parser, overrides, prefix, fp=FileOutput(sys.stdout)): write_headers(overrides.get_headers(), fp) write_imports(overrides, fp) write_type_declarations(parser, fp) write_classes(parser, overrides, fp) wrapper = Wrapper(parser, None, overrides, fp) wrapper.write_functions(prefix) write_enums(parser, prefix, fp) write_extension_init(overrides, prefix, fp) write_registers(parser, fp) def register_types(parser): for boxed in parser.boxes: argtypes.matcher.register_boxed(boxed.c_name, boxed.typecode) for pointer in parser.pointers: argtypes.matcher.register_pointer(pointer.c_name, pointer.typecode) for obj in parser.objects: argtypes.matcher.register_object(obj.c_name, obj.parent, obj.typecode) for obj in parser.miniobjects: argtypes.matcher.register_miniobject(obj.c_name, obj.parent, obj.typecode) for obj in parser.interfaces: argtypes.matcher.register_object(obj.c_name, None, obj.typecode) for enum in parser.enums: if enum.deftype == 'flags': argtypes.matcher.register_flag(enum.c_name, enum.typecode) else: argtypes.matcher.register_enum(enum.c_name, enum.typecode) usage = 'usage: codegen.py [-o overridesfile] [-p prefix] defsfile' def main(argv): o = override.Overrides() prefix = 'pygtk' outfilename = None errorfilename = None opts, args = getopt.getopt(argv[1:], "o:p:r:t:D:", ["override=", "prefix=", "register=", "outfilename=", "load-types=", "errorfilename="]) defines = {} # -Dkey[=val] options for opt, arg in opts: if opt in ('-o', '--override'): o = override.Overrides(arg) elif opt in ('-p', '--prefix'): prefix = arg elif opt in ('-r', '--register'): # Warning: user has to make sure all -D options appear before -r p = defsparser.DefsParser(arg, defines) p.startParsing() register_types(p) del p elif opt == '--outfilename': outfilename = arg elif opt == '--errorfilename': errorfilename = arg elif opt in ('-t', '--load-types'): globals = {} execfile(arg, globals) elif opt == '-D': nameval = arg.split('=') try: defines[nameval[0]] = nameval[1] except IndexError: defines[nameval[0]] = None if len(args) < 1: print >> sys.stderr, usage return 1 if errorfilename: sys.stderr = open(errorfilename, "w") p = defsparser.DefsParser(args[0], defines) if not outfilename: outfilename = os.path.splitext(args[0])[0] + '.c' p.startParsing() register_types(p) write_source(p, o, prefix, FileOutput(sys.stdout, outfilename)) functions_coverage.printstats() methods_coverage.printstats() vproxies_coverage.printstats() vaccessors_coverage.printstats() iproxies_coverage.printstats() if __name__ == '__main__': sys.exit(main(sys.argv))