mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-10-03 17:22:29 +00:00
1722 lines
68 KiB
Python
Executable file
1722 lines
68 KiB
Python
Executable file
#! /usr/bin/env python
|
|
|
|
import getopt
|
|
import keyword
|
|
import os
|
|
import string
|
|
import sys
|
|
|
|
import argtypes
|
|
import definitions
|
|
import defsparser
|
|
import override
|
|
import reversewrapper
|
|
import warnings
|
|
|
|
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
|
|
fd = sys.stderr
|
|
if total:
|
|
fd.write("***INFO*** The coverage of %s is %.2f%% (%i/%i)\n" %
|
|
(self.name,
|
|
float(self.wrapped*100)/total,
|
|
self.wrapped,
|
|
total))
|
|
else:
|
|
fd.write("***INFO*** There are no declared %s.\n" % 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():
|
|
warnings.warn("deprecated", DeprecationWarning, stacklevel=2)
|
|
#traceback.print_exc()
|
|
etype, value, tb = sys.exc_info()
|
|
ret = ""
|
|
try:
|
|
sval = str(value)
|
|
if etype == argtypes.ArgTypeError:
|
|
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 G_GNUC_INTERNAL 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'
|
|
' %(tp_doc)s, /* 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'
|
|
' (struct PyMethodDef*)%(tp_methods)s, /* tp_methods */\n'
|
|
' (struct PyMemberDef*)0, /* tp_members */\n'
|
|
' (struct PyGetSetDef*)%(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', 'tp_doc'
|
|
]
|
|
|
|
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'
|
|
' %(docstring)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'
|
|
' %(begin_allow_threads)s\n'
|
|
' %(setreturn)s%(cname)s(%(arglist)s);\n'
|
|
' %(end_allow_threads)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.py_name,
|
|
'errorreturn': '-1' }
|
|
|
|
def get_initial_method_substdict(self, method):
|
|
substdict = { 'name': '%s.%s' % (self.objinfo.py_name, method.name) }
|
|
if method.unblock_threads:
|
|
substdict['begin_allow_threads'] = 'pyg_begin_allow_threads;'
|
|
substdict['end_allow_threads'] = 'pyg_end_allow_threads;'
|
|
else:
|
|
substdict['begin_allow_threads'] = ''
|
|
substdict['end_allow_threads'] = ''
|
|
return substdict
|
|
|
|
def write_class(self):
|
|
if self.overrides.is_type_ignored(self.objinfo.c_name):
|
|
return
|
|
self.fp.write('\n/* ----------- %s ----------- */\n\n' %
|
|
self.objinfo.c_name)
|
|
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
|
|
substdict['tp_doc'] = self.objinfo.docstring
|
|
|
|
# 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 argtypes.ArgTypeNotFoundError("varargs functions not supported")
|
|
|
|
for param in function_obj.params:
|
|
if param.pdflt != None 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 function_obj.unblock_threads:
|
|
substdict['begin_allow_threads'] = 'pyg_begin_allow_threads;'
|
|
substdict['end_allow_threads'] = 'pyg_end_allow_threads;'
|
|
else:
|
|
substdict['begin_allow_threads'] = ''
|
|
substdict['end_allow_threads'] = ''
|
|
|
|
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 not constructor:
|
|
return self.write_default_constructor()
|
|
|
|
funcname = constructor.c_name
|
|
try:
|
|
if self.overrides.is_overriden(funcname):
|
|
data = self.overrides.override(funcname)
|
|
self.write_function(funcname, data)
|
|
self.objinfo.has_new_constructor_api = (
|
|
self.objinfo.typecode in
|
|
self.overrides.newstyle_constructors)
|
|
else:
|
|
# ok, a hack to determine if we should use
|
|
# new-style constructores :P
|
|
property_based = getattr(self,
|
|
'write_property_based_constructor',
|
|
None)
|
|
if property_based:
|
|
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:
|
|
sys.stderr.write(
|
|
"Warning: generating old-style constructor for:" +
|
|
constructor.c_name + '\n')
|
|
|
|
# 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 argtypes.ArgTypeError, ex:
|
|
sys.stderr.write('Could not write constructor for %s: %s\n'
|
|
% (self.objinfo.c_name, str(ex)))
|
|
|
|
initfunc = self.write_noconstructor()
|
|
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):
|
|
flags = 'METH_VARARGS|METH_KEYWORDS'
|
|
elif self.overrides.wants_noargs(funcname):
|
|
flags = 'METH_NOARGS'
|
|
elif self.overrides.wants_onearg(funcname):
|
|
flags = 'METH_O'
|
|
else:
|
|
flags = 'METH_VARARGS'
|
|
if self.overrides.is_staticmethod(funcname):
|
|
flags += '|METH_STATIC'
|
|
elif self.overrides.is_classmethod(funcname):
|
|
flags += '|METH_CLASS'
|
|
return flags
|
|
|
|
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'] = meth.name
|
|
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,
|
|
'docstring': meth.docstring })
|
|
methods_coverage.declare_wrapped()
|
|
except argtypes.ArgTypeError, ex:
|
|
methods_coverage.declare_not_wrapped()
|
|
sys.stderr.write('Could not write method %s.%s: %s\n'
|
|
% (klass, meth.name, str(ex)))
|
|
|
|
# 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,
|
|
'docstring': 'NULL' })
|
|
methods_coverage.declare_wrapped()
|
|
except argtypes.ArgTypeError, ex:
|
|
methods_coverage.declare_not_wrapped()
|
|
sys.stderr.write('Could not write method %s.%s: %s\n'
|
|
% (klass, method_name, str(ex)))
|
|
|
|
# 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, NULL }\n')
|
|
self.fp.write('static const 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',
|
|
'docstring': 'NULL'})
|
|
vaccessors_coverage.declare_wrapped()
|
|
except argtypes.ArgTypeError, ex:
|
|
vaccessors_coverage.declare_not_wrapped()
|
|
sys.stderr.write(
|
|
'Could not write virtual accessor method %s.%s: %s\n'
|
|
% (klass, meth.name, str(ex)))
|
|
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)
|
|
props["direction"] = param.pdir
|
|
props["nullok"] = param.pnull
|
|
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 argtypes.ArgTypeError, ex:
|
|
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, str(ex)))
|
|
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'
|
|
' PyObject *gsignals = '
|
|
'PyDict_GetItemString(pyclass->tp_dict, "__gsignals__");\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('''
|
|
o = PyObject_GetAttrString((PyObject *) pyclass, "%(do_name)s");
|
|
if (o == NULL)
|
|
PyErr_Clear();
|
|
else {
|
|
if (!PyObject_TypeCheck(o, &PyCFunction_Type)
|
|
&& !(gsignals && PyDict_GetItemString(gsignals, "%(name)s")))
|
|
klass->%(name)s = %(cname)s;
|
|
Py_DECREF(o);
|
|
}
|
|
''' % 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, cfname in self.objinfo.fields:
|
|
fname = cfname.replace('.', '_')
|
|
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(cfname),
|
|
'codeafter': info.get_codeafter() })
|
|
gettername = funcname
|
|
except argtypes.ArgTypeError, ex:
|
|
sys.stderr.write(
|
|
"Could not write getter for %s.%s: %s\n"
|
|
% (self.objinfo.c_name, fname, str(ex)))
|
|
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 const 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_get_symbol_names(self, writer, functions):
|
|
self.fp.write("""static PyObject *
|
|
_wrap__get_symbol_names(PyObject *self)
|
|
{
|
|
PyObject *pylist = PyList_New(0);
|
|
|
|
""")
|
|
for obj, bases in writer.get_classes():
|
|
self.fp.write(' PyList_Append(pylist, '
|
|
'PyString_FromString("%s"));\n' % (obj.name))
|
|
|
|
for name, cname, flags, docstring in functions:
|
|
self.fp.write(' PyList_Append(pylist, '
|
|
'PyString_FromString("%s"));\n' % (name))
|
|
|
|
for enum in writer.get_enums():
|
|
self.fp.write(' PyList_Append(pylist, '
|
|
'PyString_FromString("%s"));\n' % (enum.name))
|
|
for nick, value in enum.values:
|
|
name = value[len(self.overrides.modulename)+1:]
|
|
self.fp.write(' PyList_Append(pylist, '
|
|
'PyString_FromString("%s"));\n' % (name))
|
|
|
|
self.fp.write(" return pylist;\n}\n\n");
|
|
|
|
def _write_get_symbol(self, writer, functions):
|
|
self.fp.write("""static PyObject *
|
|
_wrap__get_symbol(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *d;
|
|
char *name;
|
|
static PyObject *modulename = NULL;
|
|
static PyObject *module = NULL;
|
|
static char *strip_prefix = "%s";
|
|
|
|
if (!PyArg_ParseTuple(args, "Os", &d, &name))
|
|
return NULL;
|
|
|
|
if (!modulename)
|
|
modulename = PyString_FromString("%s");
|
|
|
|
if (!module)
|
|
module = PyDict_GetItemString(d, "__module__");
|
|
|
|
""" % (self.overrides.modulename.upper() + '_',
|
|
self.overrides.modulename))
|
|
|
|
first = True
|
|
# Classes / GObjects
|
|
for obj, bases in writer.get_classes():
|
|
if first:
|
|
self.fp.write(' if (!strcmp(name, "%s")) {\n' % obj.name)
|
|
first = False
|
|
else:
|
|
self.fp.write(' } else if (!strcmp(name, "%s")) {\n' % obj.name)
|
|
self.fp.write(
|
|
' return (PyObject*)pygobject_lookup_class(%s);\n' %
|
|
obj.typecode)
|
|
self.fp.write(' }\n')
|
|
|
|
# Functions
|
|
for name, cname, flags, docstring in functions:
|
|
self.fp.write(' else if (!strcmp(name, "%s")) {\n' % name)
|
|
self.fp.write(' static PyMethodDef ml = { '
|
|
'"%s", (PyCFunction)%s, %s, "%s"};\n' % (
|
|
name, cname, flags, docstring))
|
|
self.fp.write(' return PyCFunction_NewEx(&ml, NULL, modulename);\n')
|
|
self.fp.write(' }\n')
|
|
|
|
# Enums
|
|
def write_enum(enum, returnobj=False):
|
|
if returnobj:
|
|
ret = 'return '
|
|
else:
|
|
ret = ''
|
|
if enum.deftype == 'enum':
|
|
self.fp.write(
|
|
' %spyg_enum_add(module, "%s", strip_prefix, %s);\n'
|
|
% (ret, enum.name, enum.typecode))
|
|
else:
|
|
self.fp.write(
|
|
' %spyg_flags_add(module, "%s", strip_prefix, %s);\n'
|
|
% (ret, enum.name, enum.typecode))
|
|
|
|
strip_len = len(self.overrides.modulename)+1 # GTK_
|
|
for enum in writer.get_enums():
|
|
# XXX: Implement without typecodes
|
|
self.fp.write(' else if (!strcmp(name, "%s")) {\n' % enum.name)
|
|
write_enum(enum, returnobj=True)
|
|
self.fp.write(' }\n')
|
|
|
|
for nick, value in enum.values:
|
|
value = value[strip_len:]
|
|
self.fp.write(' else if (!strcmp(name, "%s")) {\n' % value)
|
|
write_enum(enum)
|
|
self.fp.write(' return PyObject_GetAttrString(module, "%s");\n' %
|
|
value)
|
|
self.fp.write(' }\n')
|
|
|
|
self.fp.write(' return Py_None;\n}\n\n');
|
|
|
|
def _write_function_bodies(self):
|
|
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((func.name, '_wrap_' + funcname,
|
|
methflags, func.docstring))
|
|
functions_coverage.declare_wrapped()
|
|
except argtypes.ArgTypeError, ex:
|
|
functions_coverage.declare_not_wrapped()
|
|
sys.stderr.write('Could not write function %s: %s\n'
|
|
% (func.name, str(ex)))
|
|
|
|
# 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, data)
|
|
methflags = self.get_methflags(funcname)
|
|
functions.append((funcname, '_wrap_' + funcname,
|
|
methflags, 'NULL'))
|
|
functions_coverage.declare_wrapped()
|
|
except argtypes.ArgTypeError, ex:
|
|
functions_coverage.declare_not_wrapped()
|
|
sys.stderr.write('Could not write function %s: %s\n'
|
|
% (funcname, str(ex)))
|
|
return functions
|
|
|
|
def write_functions(self, writer, prefix):
|
|
self.fp.write('\n/* ----------- functions ----------- */\n\n')
|
|
functions = []
|
|
func_infos = self._write_function_bodies()
|
|
|
|
# If we have a dynamic namespace, write symbol and attribute getter
|
|
if self.overrides.dynamicnamespace:
|
|
self._write_get_symbol_names(writer, func_infos)
|
|
self._write_get_symbol(writer, func_infos)
|
|
for obj, bases in writer.get_classes():
|
|
self.fp.write("""static PyTypeObject *
|
|
%s_register_type(const gchar *name, PyObject *unused)
|
|
{
|
|
PyObject *m = PyImport_ImportModule("gtk");
|
|
PyObject *d = PyModule_GetDict(m);
|
|
""" % obj.c_name)
|
|
writer.write_class(obj, bases, indent=1)
|
|
self.fp.write(
|
|
' return (%s)PyDict_GetItemString(d, "%s");\n' % (
|
|
'PyTypeObject*', obj.name))
|
|
self.fp.write("}\n")
|
|
|
|
functions.append(' { "_get_symbol_names", '
|
|
'(PyCFunction)_wrap__get_symbol_names, '
|
|
'METH_NOARGS, NULL },\n')
|
|
functions.append(' { "_get_symbol", '
|
|
'(PyCFunction)_wrap__get_symbol, '
|
|
'METH_VARARGS, NULL },\n')
|
|
else:
|
|
for name, cname, flags, docstring in func_infos:
|
|
functions.append(self.methdef_tmpl % dict(name=name,
|
|
cname=cname,
|
|
flags=flags,
|
|
docstring=docstring))
|
|
|
|
# write the PyMethodDef structure
|
|
functions.append(' { NULL, NULL, 0, NULL }\n')
|
|
|
|
self.fp.write('const 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'
|
|
' %(begin_allow_threads)s\n'
|
|
' %(setreturn)s%(cname)s(%(cast)s(self->obj)%(arglist)s);\n'
|
|
' %(end_allow_threads)s\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):
|
|
try:
|
|
parent = self.parser.find_object(self.objinfo.parent)
|
|
except ValueError:
|
|
parent = None
|
|
if parent is not None:
|
|
## just like the constructor is inheritted, we should
|
|
# inherit the new API compatibility flag
|
|
self.objinfo.has_new_constructor_api = (
|
|
parent.has_new_constructor_api)
|
|
elif self.objinfo.parent == 'GObject':
|
|
self.objinfo.has_new_constructor_api = True
|
|
return '0'
|
|
|
|
def write_property_based_constructor(self, constructor):
|
|
self.objinfo.has_new_constructor_api = True
|
|
out = self.fp
|
|
print >> out, "static int"
|
|
print >> out, '_wrap_%s(PyGObject *self, PyObject *args,' \
|
|
' PyObject *kwargs)\n{' % constructor.c_name
|
|
if constructor.params:
|
|
s = " GType obj_type = pyg_type_from_object((PyObject *) self);"
|
|
print >> out, s
|
|
|
|
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:
|
|
out.write(
|
|
' if (PyErr_Warn(PyExc_DeprecationWarning, '
|
|
'"%s") < 0)\n' %
|
|
constructor.deprecated)
|
|
print >> out, ' return -1;'
|
|
print >> out
|
|
out.write(" 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,
|
|
|
|
out.write(
|
|
"))\n"
|
|
" return -1;\n"
|
|
"\n"
|
|
" memset(params, 0, sizeof(GParameter)*%i);\n"
|
|
" if (!pyg_parse_constructor_args(obj_type, arg_names,\n"
|
|
" prop_names, params, \n"
|
|
" &nparams, parsed_args))\n"
|
|
" return -1;\n"
|
|
" pygobject_constructv(self, nparams, params);\n"
|
|
" for (i = 0; i < nparams; ++i)\n"
|
|
" g_value_unset(¶ms[i].value);\n"
|
|
% len(constructor.params))
|
|
else:
|
|
out.write(
|
|
" static char* kwlist[] = { NULL };\n"
|
|
"\n")
|
|
|
|
if constructor.deprecated is not None:
|
|
out.write(
|
|
' if (PyErr_Warn(PyExc_DeprecationWarning, "%s") < 0)\n'
|
|
' return -1;\n'
|
|
'\n' % constructor.deprecated)
|
|
|
|
out.write(
|
|
' if (!PyArg_ParseTupleAndKeywords(args, kwargs,\n'
|
|
' ":%s.__init__",\n'
|
|
' kwlist))\n'
|
|
' return -1;\n'
|
|
'\n'
|
|
' pygobject_constructv(self, 0, NULL);\n' % classname)
|
|
out.write(
|
|
' if (!self->obj) {\n'
|
|
' PyErr_SetString(\n'
|
|
' PyExc_RuntimeError, \n'
|
|
' "could not create %s object");\n'
|
|
' return -1;\n'
|
|
' }\n' % classname)
|
|
|
|
if not constructor.caller_owns_return:
|
|
print >> out, " g_object_ref(self->obj);\n"
|
|
|
|
out.write(
|
|
' return 0;\n'
|
|
'}\n\n')
|
|
|
|
return "_wrap_%s" % constructor.c_name
|
|
|
|
|
|
class GInterfaceWrapper(GObjectWrapper):
|
|
virtual_accessor_tmpl = (
|
|
'static PyObject *\n'
|
|
'_wrap_%(cname)s(PyObject *cls%(extraparams)s)\n'
|
|
'{\n'
|
|
' %(vtable)s *iface;\n'
|
|
'%(varlist)s'
|
|
'%(parseargs)s'
|
|
'%(codebefore)s'
|
|
' iface = g_type_interface_peek('
|
|
'g_type_class_peek(pyg_type_from_object(cls)), %(typecode)s);\n'
|
|
' if (iface->%(virtual)s)\n'
|
|
' %(setreturn)siface->%(virtual)s(%(arglist)s);\n'
|
|
' else {\n'
|
|
' PyErr_SetString(PyExc_NotImplementedError, '
|
|
'"interface method %(name)s not implemented");\n'
|
|
' return NULL;\n'
|
|
' }\n'
|
|
'%(codeafter)s\n'
|
|
'}\n\n'
|
|
)
|
|
|
|
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 _get_class_virtual_substdict(self, meth, cname, parent):
|
|
substdict = self.get_initial_method_substdict(meth)
|
|
substdict['virtual'] = meth.name
|
|
substdict['cname'] = cname
|
|
substdict['typecode'] = self.objinfo.typecode
|
|
substdict['vtable'] = self.objinfo.vtable
|
|
return substdict
|
|
|
|
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)
|
|
props["direction"] = param.pdir
|
|
props["nullok"] = param.pnull
|
|
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 argtypes.ArgTypeError, ex:
|
|
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, str(ex)))
|
|
|
|
if not proxies or not [cname for name, cname in proxies if cname]:
|
|
return
|
|
|
|
## 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, PyTypeObject *pytype)\n'
|
|
'{\n'
|
|
' %(vtable)s *parent_iface = '
|
|
'g_type_interface_peek_parent(iface);\n'
|
|
' PyObject *py_method;\n'
|
|
'\n'
|
|
% vars())
|
|
|
|
for name, cname in proxies:
|
|
do_name = 'do_' + name
|
|
if cname is None:
|
|
continue
|
|
|
|
self.fp.write((
|
|
' py_method = pytype? PyObject_GetAttrString('
|
|
'(PyObject *) pytype, "%(do_name)s") : NULL;\n'
|
|
' if (py_method && !PyObject_TypeCheck(py_method, '
|
|
'&PyCFunction_Type)) {\n'
|
|
' iface->%(name)s = %(cname)s;\n'
|
|
' } else {\n'
|
|
' PyErr_Clear();\n'
|
|
' if (parent_iface) {\n'
|
|
' iface->%(name)s = parent_iface->%(name)s;\n'
|
|
' }\n'
|
|
' Py_XDECREF(py_method);\n'
|
|
' }\n'
|
|
) % vars())
|
|
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'
|
|
' %(begin_allow_threads)s\n'
|
|
' %(setreturn)s%(cname)s(pyg_boxed_get(self, '
|
|
'%(typename)s)%(arglist)s);\n'
|
|
' %(end_allow_threads)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
|
|
|
|
class SourceWriter:
|
|
def __init__(self, parser, overrides, prefix, fp=FileOutput(sys.stdout)):
|
|
self.parser = parser
|
|
self.overrides = overrides
|
|
self.prefix = prefix
|
|
self.fp = fp
|
|
|
|
def write(self, py_ssize_t_clean=False):
|
|
argtypes.py_ssize_t_clean = py_ssize_t_clean
|
|
|
|
self.write_headers(py_ssize_t_clean)
|
|
self.write_imports()
|
|
self.write_type_declarations()
|
|
self.write_body()
|
|
self.write_classes()
|
|
|
|
wrapper = Wrapper(self.parser, None, self.overrides, self.fp)
|
|
wrapper.write_functions(self, self.prefix)
|
|
|
|
if not self.overrides.dynamicnamespace:
|
|
self.write_enums()
|
|
self.write_extension_init()
|
|
self.write_registers()
|
|
|
|
argtypes.py_ssize_t_clean = False
|
|
|
|
def write_headers(self, py_ssize_t_clean):
|
|
self.fp.write('/* -- THIS FILE IS GENERATED - DO NOT EDIT */')
|
|
self.fp.write('/* -*- Mode: C; c-basic-offset: 4 -*- */\n\n')
|
|
if py_ssize_t_clean:
|
|
self.fp.write('#define PY_SSIZE_T_CLEAN\n')
|
|
self.fp.write('#include <Python.h>\n\n\n')
|
|
if py_ssize_t_clean:
|
|
self.fp.write('''
|
|
|
|
#if PY_VERSION_HEX < 0x02050000
|
|
typedef int Py_ssize_t;
|
|
#define PY_SSIZE_T_MAX INT_MAX
|
|
#define PY_SSIZE_T_MIN INT_MIN
|
|
typedef inquiry lenfunc;
|
|
typedef intargfunc ssizeargfunc;
|
|
typedef intobjargproc ssizeobjargproc;
|
|
#endif
|
|
|
|
''')
|
|
self.fp.write(self.overrides.get_headers())
|
|
self.fp.resetline()
|
|
self.fp.write('\n\n')
|
|
|
|
def write_imports(self):
|
|
self.fp.write('/* ---------- types from other modules ---------- */\n')
|
|
for module, pyname, cname, importing_for in self.overrides.get_imports():
|
|
if importing_for is None or is_registered_object(importing_for):
|
|
self.fp.write('static PyTypeObject *_%s;\n' % cname)
|
|
self.fp.write('#define %s (*_%s)\n' % (cname, cname))
|
|
self.fp.write('\n\n')
|
|
|
|
def write_type_declarations(self):
|
|
#todo use 'static' if used only in one file
|
|
self.fp.write('/* ---------- forward type declarations ---------- */\n')
|
|
for obj in self.parser.boxes:
|
|
if not self.overrides.is_type_ignored(obj.c_name):
|
|
self.fp.write('PyTypeObject G_GNUC_INTERNAL Py' + obj.c_name + '_Type;\n')
|
|
for obj in self.parser.objects:
|
|
if not self.overrides.is_type_ignored(obj.c_name):
|
|
self.fp.write('PyTypeObject G_GNUC_INTERNAL Py' + obj.c_name + '_Type;\n')
|
|
for interface in self.parser.interfaces:
|
|
if not self.overrides.is_type_ignored(interface.c_name):
|
|
self.fp.write('PyTypeObject G_GNUC_INTERNAL Py' + interface.c_name + '_Type;\n')
|
|
self.fp.write('\n')
|
|
|
|
def write_body(self):
|
|
self.fp.write(self.overrides.get_body())
|
|
self.fp.resetline()
|
|
self.fp.write('\n\n')
|
|
|
|
def _sort_parent_children(self, objects):
|
|
objects = list(objects)
|
|
modified = True
|
|
while modified:
|
|
modified = False
|
|
parent_index = None
|
|
child_index = None
|
|
for i, obj in enumerate(objects):
|
|
if obj.parent == 'GObject':
|
|
continue
|
|
if obj.parent not in [info.c_name for info in objects[:i]]:
|
|
for j, info in enumerate(objects[i+1:]):
|
|
if info.c_name == obj.parent:
|
|
parent_index = i + 1 + j
|
|
child_index = i
|
|
break
|
|
else:
|
|
continue
|
|
break
|
|
if child_index is not None and parent_index is not None:
|
|
if child_index != parent_index:
|
|
objects.insert(child_index, objects.pop(parent_index))
|
|
modified = True
|
|
return objects
|
|
|
|
def write_classes(self):
|
|
## Sort the objects, so that we generate code for the parent types
|
|
## before their children.
|
|
objects = self._sort_parent_children(self.parser.objects)
|
|
|
|
for klass, items in ((GBoxedWrapper, self.parser.boxes),
|
|
(GPointerWrapper, self.parser.pointers),
|
|
(GObjectWrapper, objects),
|
|
(GInterfaceWrapper, self.parser.interfaces)):
|
|
for item in items:
|
|
instance = klass(self.parser, item, self.overrides, self.fp)
|
|
instance.write_class()
|
|
self.fp.write('\n')
|
|
|
|
def get_enums(self):
|
|
enums = []
|
|
for enum in self.parser.enums:
|
|
if self.overrides.is_type_ignored(enum.c_name):
|
|
continue
|
|
enums.append(enum)
|
|
return enums
|
|
|
|
def write_enums(self):
|
|
if not self.parser.enums:
|
|
return
|
|
|
|
self.fp.write('\n/* ----------- enums and flags ----------- */\n\n')
|
|
self.fp.write(
|
|
'void\n' + self.prefix +
|
|
'_add_constants(PyObject *module, const gchar *strip_prefix)\n{\n')
|
|
|
|
self.fp.write(
|
|
'#ifdef VERSION\n'
|
|
' PyModule_AddStringConstant(module, "__version__", VERSION);\n'
|
|
'#endif\n')
|
|
|
|
for enum in self.get_enums():
|
|
if enum.typecode is None:
|
|
for nick, value in enum.values:
|
|
self.fp.write(
|
|
' PyModule_AddIntConstant(module, '
|
|
'(char *) pyg_constant_strip_prefix("%s", strip_prefix), %s);\n'
|
|
% (value, value))
|
|
else:
|
|
if enum.deftype == 'enum':
|
|
self.fp.write(' pyg_enum_add(module, "%s", strip_prefix, %s);\n'
|
|
% (enum.name, enum.typecode))
|
|
else:
|
|
self.fp.write(' pyg_flags_add(module, "%s", strip_prefix, %s);\n'
|
|
% (enum.name, enum.typecode))
|
|
|
|
self.fp.write('\n')
|
|
self.fp.write(' if (PyErr_Occurred())\n')
|
|
self.fp.write(' PyErr_Print();\n')
|
|
self.fp.write('}\n\n')
|
|
|
|
def write_object_imports(self, retval=''):
|
|
imports = self.overrides.get_imports()[:]
|
|
if not imports:
|
|
return
|
|
|
|
bymod = {}
|
|
for module, pyname, cname, importing_for in imports:
|
|
if importing_for is None or is_registered_object(importing_for):
|
|
bymod.setdefault(module, []).append((pyname, cname))
|
|
self.fp.write(' PyObject *module;\n\n')
|
|
for module in bymod:
|
|
self.fp.write(
|
|
' if ((module = PyImport_ImportModule("%s")) != NULL) {\n'
|
|
% module)
|
|
#self.fp.write(
|
|
# ' PyObject *moddict = PyModule_GetDict(module);\n\n')
|
|
for pyname, cname in bymod[module]:
|
|
#self.fp.write(
|
|
# ' _%s = (PyTypeObject *)PyDict_GetItemString('
|
|
# 'moddict, "%s");\n' % (cname, pyname))
|
|
self.fp.write(
|
|
' _%s = (PyTypeObject *)PyObject_GetAttrString('
|
|
'module, "%s");\n' % (cname, pyname))
|
|
self.fp.write(' if (_%s == NULL) {\n' % cname)
|
|
self.fp.write(' PyErr_SetString(PyExc_ImportError,\n')
|
|
self.fp.write(' "cannot import name %s from %s");\n'
|
|
% (pyname, module))
|
|
self.fp.write(' return %s;\n' % retval)
|
|
self.fp.write(' }\n')
|
|
self.fp.write(' } else {\n')
|
|
self.fp.write(' PyErr_SetString(PyExc_ImportError,\n')
|
|
self.fp.write(' "could not import %s");\n' % module)
|
|
self.fp.write(' return %s;\n' % retval)
|
|
self.fp.write(' }\n')
|
|
self.fp.write('\n')
|
|
|
|
def write_extension_init(self):
|
|
self.fp.write('/* initialise stuff extension classes */\n')
|
|
self.fp.write('void\n' + self.prefix + '_register_classes(PyObject *d)\n{\n')
|
|
self.write_object_imports()
|
|
self.fp.write(self.overrides.get_init() + '\n')
|
|
self.fp.resetline()
|
|
|
|
def get_classes(self):
|
|
objects = self.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
|
|
|
|
retval = []
|
|
for obj in objects:
|
|
if self.overrides.is_type_ignored(obj.c_name):
|
|
continue
|
|
bases = []
|
|
if obj.parent != None:
|
|
bases.append(obj.parent)
|
|
bases = bases + obj.implements
|
|
retval.append((obj, bases))
|
|
|
|
return retval
|
|
|
|
def write_registers(self):
|
|
for boxed in self.parser.boxes:
|
|
if not self.overrides.is_type_ignored(boxed.c_name):
|
|
self.fp.write(' pyg_register_boxed(d, "' + boxed.name +
|
|
'", ' + boxed.typecode +
|
|
', &Py' + boxed.c_name +
|
|
'_Type);\n')
|
|
for pointer in self.parser.pointers:
|
|
if not self.overrides.is_type_ignored(pointer.c_name):
|
|
self.fp.write(' pyg_register_pointer(d, "' + pointer.name +
|
|
'", ' + pointer.typecode +
|
|
', &Py' + pointer.c_name + '_Type);\n')
|
|
for interface in self.parser.interfaces:
|
|
if not self.overrides.is_type_ignored(interface.c_name):
|
|
self.fp.write(' pyg_register_interface(d, "'
|
|
+ interface.name + '", '+ interface.typecode
|
|
+ ', &Py' + interface.c_name + '_Type);\n')
|
|
if interface.interface_info is not None:
|
|
self.fp.write(' pyg_register_interface_info(%s, &%s);\n' %
|
|
(interface.typecode, interface.interface_info))
|
|
|
|
if not self.overrides.dynamicnamespace:
|
|
for obj, bases in self.get_classes():
|
|
self.write_class(obj, bases)
|
|
else:
|
|
for obj, bases in self.get_classes():
|
|
self.fp.write(
|
|
' pyg_type_register_custom_callback("%s", '
|
|
'(PyGTypeRegistrationFunction)%s_register_type, d);\n' %
|
|
(obj.c_name, obj.c_name))
|
|
|
|
self.fp.write('}\n')
|
|
|
|
def _can_direct_ref(self, base):
|
|
if not self.overrides.dynamicnamespace:
|
|
return True
|
|
if base == 'GObject':
|
|
return True
|
|
obj = get_object_by_name(base)
|
|
if obj.module.lower() != self.overrides.modulename:
|
|
return True
|
|
return False
|
|
|
|
def write_class(self, obj, bases, indent=1):
|
|
indent_str = ' ' * (indent * 4)
|
|
if bases:
|
|
bases_str = 'Py_BuildValue("(%s)"' % (len(bases) * 'O')
|
|
|
|
for base in bases:
|
|
if self._can_direct_ref(base):
|
|
bases_str += ', &Py%s_Type' % base
|
|
else:
|
|
baseobj = get_object_by_name(base)
|
|
bases_str += ', PyObject_GetAttrString(m, "%s")' % baseobj.name
|
|
bases_str += ')'
|
|
else:
|
|
bases_str = 'NULL'
|
|
|
|
self.fp.write(
|
|
'%(indent)spygobject_register_class(d, "%(c_name)s", %(typecode)s, &Py%(c_name)s_Type, %(bases)s);\n'
|
|
% dict(indent=indent_str, c_name=obj.c_name, typecode=obj.typecode, bases=bases_str))
|
|
|
|
if obj.has_new_constructor_api:
|
|
self.fp.write(
|
|
indent_str + 'pyg_set_object_has_new_constructor(%s);\n' %
|
|
obj.typecode)
|
|
else:
|
|
print >> sys.stderr, (
|
|
"Warning: Constructor for %s needs to be updated to new API\n"
|
|
" See http://live.gnome.org/PyGTK_2fWhatsNew28"
|
|
"#update-constructors") % obj.c_name
|
|
|
|
if obj.class_init_func is not None:
|
|
self.fp.write(
|
|
indent_str + 'pyg_register_class_init(%s, %s);\n' %
|
|
(obj.typecode, obj.class_init_func))
|
|
|
|
_objects = {}
|
|
|
|
def is_registered_object(c_name):
|
|
return c_name in _objects
|
|
|
|
def get_object_by_name(c_name):
|
|
global _objects
|
|
return _objects[c_name]
|
|
|
|
def register_types(parser):
|
|
global _objects
|
|
for boxed in parser.boxes:
|
|
argtypes.matcher.register_boxed(boxed.c_name, boxed.typecode)
|
|
_objects[boxed.c_name] = boxed
|
|
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)
|
|
_objects[obj.c_name] = obj
|
|
for iface in parser.interfaces:
|
|
argtypes.matcher.register_object(iface.c_name, None, iface.typecode)
|
|
_objects[iface.c_name] = iface
|
|
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:I:",
|
|
["override=", "prefix=", "register=", "outfilename=",
|
|
"load-types=", "errorfilename=", "py_ssize_t-clean"])
|
|
defines = {} # -Dkey[=val] options
|
|
py_ssize_t_clean = False
|
|
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
|
|
elif opt == '-I':
|
|
defsparser.include_path.insert(0, arg)
|
|
elif opt == '--py_ssize_t-clean':
|
|
py_ssize_t_clean = True
|
|
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)
|
|
sw = SourceWriter(p, o, prefix, FileOutput(sys.stdout, outfilename))
|
|
sw.write(py_ssize_t_clean)
|
|
|
|
functions_coverage.printstats()
|
|
methods_coverage.printstats()
|
|
vproxies_coverage.printstats()
|
|
vaccessors_coverage.printstats()
|
|
iproxies_coverage.printstats()
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(main(sys.argv))
|