mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-07-04 05:35:53 +00:00
bindings: We no longer use static bindings in 0.11
This commit is contained in:
Edward Hervey
parent
c6d71ed335
commit
312942f836
|
|
@ -1,6 +1,6 @@
|
|||
DISTCHECK_CONFIGURE_FLAGS=--enable-gtk-doc
|
||||
|
||||
SUBDIRS = ges tests tools common m4 pkgconfig docs bindings
|
||||
SUBDIRS = ges tests tools common m4 pkgconfig docs
|
||||
|
||||
DIST_SUBDIRS = $(SUBDIRS)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +0,0 @@
|
|||
SUBDIRS =
|
||||
|
||||
if WITH_PYTHON
|
||||
SUBDIRS += python
|
||||
endif
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
SUBDIRS = codegen examples testsuite
|
||||
pkgpyexecdir = $(pyexecdir)
|
||||
|
||||
# we install everything in pyexecdir; otherwise you end up with a mess for
|
||||
# multilib
|
||||
pygesdir = $(pkgpyexecdir)
|
||||
pyges_PYTHON =
|
||||
|
||||
pygesexecdir = $(pkgpyexecdir)
|
||||
pygesexec_LTLIBRARIES = ges.la
|
||||
|
||||
DEFS = $(srcdir)/ges-types.defs $(srcdir)/ges.defs
|
||||
defs_DATA = $(DEFS)
|
||||
defsdir = $(pkgdatadir)/$(GST_MAJORMINOR)/defs
|
||||
OVERRIDES = ges.override
|
||||
|
||||
INCLUDES = -I$(top_srcdir) -I$(srcdir) $(PYTHON_INCLUDES)
|
||||
|
||||
ges_la_CFLAGS = -I$(top_srcdir)\
|
||||
$(PYGOBJECT_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS) $(GST_CFLAGS) -Wno-write-strings
|
||||
ges_la_LDFLAGS = -export-symbols-regex "^(initges|_PyGObject_API).*" \
|
||||
-module -avoid-version $(GST_PLUGIN_LDFLAGS)
|
||||
ges_la_LIBADD = $(top_builddir)/ges/libges-@GST_MAJORMINOR@.la \
|
||||
$(GST_PLUGINS_BASE_LIBS) $(GST_BASE_LIBS) \
|
||||
-lges-@GST_MAJORMINOR@ -lges-@GST_MAJORMINOR@ \
|
||||
-lges-@GST_MAJORMINOR@ $(GST_LIBS) $(LIBM)
|
||||
ges_la_SOURCES = gesmodule.c
|
||||
nodist_ges_la_SOURCES = ges.c
|
||||
|
||||
EXTRA_DIST = $(defs_DATA) $(OVERRIDES) arg-types.py
|
||||
|
||||
CLEANFILES = ges.c
|
||||
|
||||
.defs.c:
|
||||
($(PYTHON) $(srcdir)/codegen/codegen.py \
|
||||
--load-types $(srcdir)/arg-types.py \
|
||||
--register $(srcdir)/ges-types.defs \
|
||||
--override $(srcdir)/$*.override \
|
||||
--prefix pyges $<) > gen-$*.c \
|
||||
&& cp gen-$*.c $*.c \
|
||||
&& rm -f gen-$*.c
|
||||
|
||||
|
|
@ -1,421 +0,0 @@
|
|||
# -*- Mode: Python -*-
|
||||
# vi:si:et:sw=4:sts=4:ts=4
|
||||
#
|
||||
# gst-python
|
||||
# Copyright (C) 2002 David I. Lehn
|
||||
# 2004 Johan Dahlin
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Library General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Library General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Library General Public
|
||||
# License along with this library; if not, write to the
|
||||
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
# Boston, MA 02111-1307, USA.
|
||||
#
|
||||
# Author: David I. Lehn <dlehn@users.sourceforge.net>
|
||||
|
||||
from argtypes import UInt64Arg, Int64Arg, PointerArg, ArgMatcher, ArgType, matcher
|
||||
from reversewrapper import Parameter, ReturnType, GBoxedParam, GBoxedReturn, IntParam, IntReturn
|
||||
|
||||
class XmlNodeArg(ArgType):
|
||||
"""libxml2 node generator"""
|
||||
|
||||
names = {"xobj":"xmlNode",
|
||||
"xptr":"xmlNodePtr",
|
||||
"xwrap":"libxml_xmlNodePtrWrap"}
|
||||
|
||||
parm = (' if(xml == NULL) return NULL;\n'
|
||||
' xobj = PyObject_GetAttrString(xml, "%(xobj)s");\n'
|
||||
' if(!PyObject_IsInstance(py%(name)s, xobj)) {\n'
|
||||
' PyErr_Clear();\n'
|
||||
' PyErr_SetString(PyExc_RuntimeError,"%(name)s is not a %(xobj)s instance");\n'
|
||||
' Py_DECREF(xobj);Py_DECREF(xml);\n'
|
||||
' return NULL;\n'
|
||||
' }\n'
|
||||
' o = PyObject_GetAttrString(py%(name)s, "_o");\n'
|
||||
' %(name)s = PyCObject_AsVoidPtr(o);\n')
|
||||
parmp = (' Py_DECREF(o); Py_DECREF(xobj);Py_DECREF(xml);\n')
|
||||
|
||||
ret = (' if(xml == NULL) return NULL;\n')
|
||||
retp = (' xargs = PyTuple_New(1);\n'
|
||||
' xobj = PyObject_GetAttrString(xml, "%(xobj)s");\n'
|
||||
' o = %(xwrap)s(ret);\n'
|
||||
' PyTuple_SetItem(xargs, 0, o);\n'
|
||||
' return PyInstance_New(xobj, xargs, PyDict_New());\n')
|
||||
|
||||
def write_param(self, ptype, pname, pdflt, pnull, info):
|
||||
info.varlist.add('PyObject', '*xml = _gst_get_libxml2_module()')
|
||||
info.varlist.add('PyObject', '*o')
|
||||
info.varlist.add('PyObject', '*xobj')
|
||||
info.varlist.add('PyObject', '*py' + pname)
|
||||
info.varlist.add(self.names["xptr"], pname)
|
||||
#if pnull:
|
||||
info.add_parselist('O', ['&py'+pname], [pname])
|
||||
info.arglist.append(pname)
|
||||
self.names["name"] = pname
|
||||
info.codebefore.append(self.parm % self.names)
|
||||
info.codeafter.append(self.parmp % self.names);
|
||||
def write_return(self, ptype, ownsreturn, info):
|
||||
info.varlist.add('PyObject', '*xml = _gst_get_libxml2_module()')
|
||||
info.varlist.add('PyObject', '*xargs')
|
||||
info.varlist.add('PyObject', '*xobj')
|
||||
info.varlist.add('PyObject', '*o')
|
||||
info.varlist.add(self.names["xptr"], 'ret')
|
||||
info.codebefore.append(self.ret % self.names)
|
||||
info.codeafter.append(self.retp % self.names)
|
||||
|
||||
class XmlDocArg(XmlNodeArg):
|
||||
"""libxml2 doc generator"""
|
||||
names = {"xobj":"xmlDoc",
|
||||
"xptr":"xmlDocPtr",
|
||||
"xwrap":"libxml_xmlDocPtrWrap"}
|
||||
|
||||
class GstCapsArg(ArgType):
|
||||
"""GstCaps node generator"""
|
||||
|
||||
before = (' %(name)s = pygst_caps_from_pyobject (py_%(name)s, %(namecopy)s);\n'
|
||||
' if (PyErr_Occurred())\n'
|
||||
' return NULL;\n')
|
||||
beforenull = (' if (py_%(name)s == Py_None || py_%(name)s == NULL)\n'
|
||||
' %(name)s = NULL;\n'
|
||||
' else\n'
|
||||
' ' + before)
|
||||
after = (' if (%(name)s && %(name)s_is_copy)\n'
|
||||
' gst_caps_unref (%(name)s);\n')
|
||||
|
||||
def write_param(self, ptype, pname, pdflt, pnull, info):
|
||||
if ptype == 'const-GstCaps*':
|
||||
self.write_const_param(pname, pdflt, pnull, info)
|
||||
elif ptype == 'GstCaps*':
|
||||
self.write_normal_param(pname, pdflt, pnull, info)
|
||||
else:
|
||||
raise RuntimeError, "write_param not implemented for %s" % ptype
|
||||
|
||||
def write_const_param(self, pname, pdflt, pnull, info):
|
||||
if pdflt:
|
||||
assert pdflt == 'NULL'
|
||||
info.varlist.add('PyObject', '*py_' + pname + ' = NULL')
|
||||
else:
|
||||
info.varlist.add('PyObject', '*py_' + pname)
|
||||
info.varlist.add('GstCaps', '*'+pname)
|
||||
info.varlist.add('gboolean', pname+'_is_copy')
|
||||
info.add_parselist('O', ['&py_'+pname], [pname])
|
||||
info.arglist.append(pname)
|
||||
if pnull:
|
||||
info.codebefore.append (self.beforenull % { 'name' : pname, 'namecopy' : '&'+pname+'_is_copy' })
|
||||
else:
|
||||
info.codebefore.append (self.before % { 'name' : pname, 'namecopy' : '&'+pname+'_is_copy' })
|
||||
info.codeafter.append (self.after % { 'name' : pname, 'namecopy' : '&'+pname+'_is_copy' })
|
||||
|
||||
def write_normal_param(self, pname, pdflt, pnull, info):
|
||||
if pdflt:
|
||||
assert pdflt == 'NULL'
|
||||
info.varlist.add('PyObject', '*py_' + pname + ' = NULL')
|
||||
else:
|
||||
info.varlist.add('PyObject', '*py_' + pname)
|
||||
info.varlist.add('GstCaps', '*'+pname)
|
||||
info.add_parselist('O', ['&py_'+pname], [pname])
|
||||
info.arglist.append(pname)
|
||||
if pnull:
|
||||
info.codebefore.append (self.beforenull % { 'name' : pname, 'namecopy' : 'NULL' })
|
||||
else:
|
||||
info.codebefore.append (self.before % { 'name' : pname, 'namecopy' : 'NULL' })
|
||||
|
||||
def write_return(self, ptype, ownsreturn, info):
|
||||
if ptype == 'GstCaps*':
|
||||
info.varlist.add('GstCaps', '*ret')
|
||||
copyval = 'FALSE'
|
||||
elif ptype == 'const-GstCaps*':
|
||||
info.varlist.add('const GstCaps', '*ret')
|
||||
copyval = 'TRUE'
|
||||
else:
|
||||
raise RuntimeError, "write_return not implemented for %s" % ptype
|
||||
info.codeafter.append(' return pyg_boxed_new (GST_TYPE_CAPS, (GstCaps*) ret, '+copyval+', TRUE);')
|
||||
|
||||
class GstIteratorArg(ArgType):
|
||||
def write_return(self, ptype, ownsreturn, info):
|
||||
info.varlist.add('GstIterator', '*ret')
|
||||
info.codeafter.append(' return pygst_iterator_new(ret);')
|
||||
|
||||
class GstMiniObjectArg(ArgType):
|
||||
|
||||
before = (' %(name)s = %(macro)s(pygstminiobject_get (py_%(name)s));\n'
|
||||
' if (PyErr_Occurred())\n'
|
||||
' return NULL;\n')
|
||||
|
||||
def write_param(self, ptype, pname, pdflt, pnull, info):
|
||||
if pdflt:
|
||||
assert pdflt == 'NULL'
|
||||
info.varlist.add('PyObject', '*py_' + pname + ' = NULL')
|
||||
else:
|
||||
info.varlist.add('PyObject', '*py_' + pname)
|
||||
|
||||
#Converts 'GstBuffer*' to 'GstBuffer'
|
||||
#and const-GstBuffer* to 'const GstBuffer'
|
||||
info.varlist.add(ptype.replace('-',' ').replace('*',''), '*'+pname)
|
||||
|
||||
if ptype in ['GstBuffer*', 'const-GstBuffer*']:
|
||||
info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_BUFFER' })
|
||||
|
||||
elif ptype in ['GstEncodingProfile*', 'const-GstEncodingProfile*']:
|
||||
info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_ENCODING_PROFILE' })
|
||||
|
||||
elif ptype in ['GstMessage*', 'const-GstMessage*']:
|
||||
info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_MESSAGE' })
|
||||
|
||||
elif ptype in ['GstEvent*', 'const-GstEvent*']:
|
||||
info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_EVENT' })
|
||||
|
||||
elif ptype in ['GstQuery*', 'const-GstQuery*']:
|
||||
info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_QUERY' })
|
||||
|
||||
else:
|
||||
raise RuntimeError, "write_param not implemented for %s" % ptype
|
||||
|
||||
info.add_parselist('O', ['&py_'+pname], [pname])
|
||||
info.arglist.append(pname)
|
||||
|
||||
def write_return(self, ptype, ownsreturn, info):
|
||||
info.varlist.add(ptype, 'ret')
|
||||
info.codeafter.append(' return pygstminiobject_new((GstMiniObject *) ret);')
|
||||
|
||||
class GstMiniObjectParam(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GstMiniObject *')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name)
|
||||
self.wrapper.write_code(code=("if (%s) {\n"
|
||||
" py_%s = pygstminiobject_new((GstMiniObject *) %s);\n"
|
||||
" gst_mini_object_unref ((GstMiniObject *) %s);\n"
|
||||
"} else {\n"
|
||||
" Py_INCREF(Py_None);\n"
|
||||
" py_%s = Py_None;\n"
|
||||
"}"
|
||||
% (self.name, self.name, self.name, self.name, self.name)),
|
||||
cleanup=("gst_mini_object_ref ((GstMiniObject *) %s); Py_DECREF(py_%s);" % (self.name, self.name)))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
matcher.register_reverse('GstMiniObject*', GstMiniObjectParam)
|
||||
|
||||
class GstMiniObjectReturn(ReturnType):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GstMiniObject *')
|
||||
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return NULL;")
|
||||
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code("retval = (%s) pygstminiobject_get(py_retval);"
|
||||
% self.get_c_type())
|
||||
self.wrapper.write_code("gst_mini_object_ref((GstMiniObject *) retval);")
|
||||
|
||||
matcher.register_reverse_ret('GstMiniObject*', GstMiniObjectReturn)
|
||||
|
||||
class GstCapsParam(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GstCaps *')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name)
|
||||
self.wrapper.write_code(code=("if (%s)\n"
|
||||
" py_%s = pyg_boxed_new (GST_TYPE_CAPS, %s, FALSE, TRUE);\n"
|
||||
"else {\n"
|
||||
" Py_INCREF(Py_None);\n"
|
||||
" py_%s = Py_None;\n"
|
||||
"}"
|
||||
% (self.name, self.name, self.name, self.name)),
|
||||
cleanup=("gst_caps_ref(%s);\nPy_DECREF(py_%s);" % (self.name, self.name)))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
matcher.register_reverse('GstCaps*', GstCapsParam)
|
||||
|
||||
class GstCapsReturn(ReturnType):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GstCaps *')
|
||||
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return NULL;")
|
||||
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code("retval = (%s) pygst_caps_from_pyobject (py_retval, NULL);"
|
||||
% self.get_c_type())
|
||||
## self.wrapper.write_code("gst_mini_object_ref((GstMiniObject *) retval);")
|
||||
|
||||
matcher.register_reverse_ret('GstCaps*', GstCapsReturn)
|
||||
|
||||
|
||||
class Int64Param(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'gint64')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = PyLong_FromLongLong(%s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
class Int64Return(ReturnType):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'gint64')
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return -G_MAXINT;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression="!PyLong_Check(py_retval)",
|
||||
failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be an long");')
|
||||
self.wrapper.write_code("retval = PyLong_AsLongLong(py_retval);")
|
||||
|
||||
class UInt64Param(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'guint64')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = PyLong_FromUnsignedLongLong(%s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
class UInt64Return(ReturnType):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'guint64')
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return -G_MAXINT;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression="!PyLong_Check(py_retval)",
|
||||
failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be an long");')
|
||||
self.wrapper.write_code("retval = PyLong_AsUnsignedLongLongMask(py_retval);")
|
||||
|
||||
class ULongParam(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'gulong')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = PyLong_FromUnsignedLong(%s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
class ULongReturn(ReturnType):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'gulong')
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return -G_MAXINT;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression="!PyLong_Check(py_retval)",
|
||||
failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be an long");')
|
||||
self.wrapper.write_code("retval = PyLong_AsUnsignedLongMask(py_retval);")
|
||||
|
||||
class ConstStringReturn(ReturnType):
|
||||
|
||||
def get_c_type(self):
|
||||
return "const gchar *"
|
||||
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("const gchar *retval;")
|
||||
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return NULL;")
|
||||
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression="!PyString_Check(py_retval)",
|
||||
failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be a string");')
|
||||
self.wrapper.write_code("retval = g_strdup(PyString_AsString(py_retval));")
|
||||
|
||||
class StringArrayArg(ArgType):
|
||||
"""Arg type for NULL-terminated string pointer arrays (GStrv, aka gchar**)."""
|
||||
def write_return(self, ptype, ownsreturn, info):
|
||||
if ownsreturn:
|
||||
raise NotImplementedError ()
|
||||
else:
|
||||
info.varlist.add("gchar", "**ret")
|
||||
info.codeafter.append(" if (ret) {\n"
|
||||
" guint size = g_strv_length(ret);\n"
|
||||
" PyObject *py_ret = PyTuple_New(size);\n"
|
||||
" gint i;\n"
|
||||
" for (i = 0; i < size; i++)\n"
|
||||
" PyTuple_SetItem(py_ret, i,\n"
|
||||
" PyString_FromString(ret[i]));\n"
|
||||
" return py_ret;\n"
|
||||
" }\n"
|
||||
" return PyTuple_New (0);\n")
|
||||
|
||||
|
||||
matcher.register('GstClockTime', UInt64Arg())
|
||||
matcher.register('GstElementFactoryListType', UInt64Arg())
|
||||
matcher.register('GstClockTimeDiff', Int64Arg())
|
||||
matcher.register('xmlNodePtr', XmlNodeArg())
|
||||
matcher.register('xmlDocPtr', XmlDocArg())
|
||||
matcher.register('GstCaps', GstCapsArg()) #FIXME: does this work?
|
||||
matcher.register('GstCaps*', GstCapsArg()) #FIXME: does this work?
|
||||
matcher.register('const-GstCaps*', GstCapsArg())
|
||||
matcher.register('GstIterator*', GstIteratorArg())
|
||||
|
||||
arg = PointerArg('gpointer', 'G_TYPE_POINTER')
|
||||
matcher.register('GstClockID', arg)
|
||||
|
||||
for typename in ["GstPlugin", "GstStructure", "GstTagList", "GError", "GstDate", "GstSegment"]:
|
||||
matcher.register_reverse(typename, GBoxedParam)
|
||||
matcher.register_reverse_ret(typename, GBoxedReturn)
|
||||
|
||||
for typename in ["GstEncodingProfile*", "cons-GstEncodingProfile", "GstBuffer*", "const-GstBuffer*", "GstEvent*", "const-GstEvent*", "GstMessage*", "const-GstMessage*", "GstQuery*", "const-GstQuery*"]:
|
||||
matcher.register(typename, GstMiniObjectArg())
|
||||
matcher.register_reverse(typename, GstMiniObjectParam)
|
||||
matcher.register_reverse_ret(typename, GstMiniObjectReturn)
|
||||
|
||||
for typename in ["gint64", "GstClockTimeDiff"]:
|
||||
matcher.register_reverse(typename, Int64Param)
|
||||
matcher.register_reverse_ret(typename, Int64Return)
|
||||
|
||||
for typename in ["guint64", "GstClockTime", "GstElementFactoryListType"]:
|
||||
matcher.register_reverse(typename, UInt64Param)
|
||||
matcher.register_reverse_ret(typename, UInt64Return)
|
||||
|
||||
matcher.register_reverse_ret("const-gchar*", ConstStringReturn)
|
||||
|
||||
matcher.register_reverse("GType", IntParam)
|
||||
matcher.register_reverse_ret("GType", IntReturn)
|
||||
|
||||
matcher.register_reverse("gulong", ULongParam)
|
||||
matcher.register_reverse_ret("gulong", ULongReturn)
|
||||
|
||||
matcher.register("GStrv", StringArrayArg())
|
||||
|
||||
del arg
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
EXTRA_DIST = \
|
||||
argtypes.py \
|
||||
code-coverage.py \
|
||||
codegen.py \
|
||||
definitions.py \
|
||||
defsparser.py \
|
||||
docextract.py \
|
||||
docgen.py \
|
||||
h2def.py \
|
||||
__init__.py \
|
||||
mergedefs.py \
|
||||
mkskel.py \
|
||||
override.py \
|
||||
reversewrapper.py \
|
||||
scmexpr.py
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
|
||||
__all__ = [
|
||||
'argtypes',
|
||||
'codegen',
|
||||
'definitions',
|
||||
'defsparser',
|
||||
'docextract',
|
||||
'docgen',
|
||||
'h2def',
|
||||
'defsgen'
|
||||
'mergedefs',
|
||||
'mkskel',
|
||||
'override',
|
||||
'scmexpr'
|
||||
]
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,44 +0,0 @@
|
|||
#! /usr/bin/env python
|
||||
|
||||
from __future__ import generators
|
||||
import sys, os
|
||||
|
||||
def read_symbols(file, type=None, dynamic=0):
|
||||
if dynamic:
|
||||
cmd = 'nm -D %s' % file
|
||||
else:
|
||||
cmd = 'nm %s' % file
|
||||
for line in os.popen(cmd, 'r'):
|
||||
if line[0] != ' ': # has an address as first bit of line
|
||||
while line[0] != ' ':
|
||||
line = line[1:]
|
||||
while line[0] == ' ':
|
||||
line = line[1:]
|
||||
# we should be up to "type symbolname" now
|
||||
sym_type = line[0]
|
||||
symbol = line[1:].strip()
|
||||
|
||||
if not type or type == sym_type:
|
||||
yield symbol
|
||||
|
||||
def main():
|
||||
if len(sys.argv) != 3:
|
||||
sys.stderr.write('usage: coverage-check library.so wrapper.so\n')
|
||||
sys.exit(1)
|
||||
library = sys.argv[1]
|
||||
wrapper = sys.argv[2]
|
||||
|
||||
# first create a dict with all referenced symbols in the wrapper
|
||||
# should really be a set, but a dict will do ...
|
||||
wrapper_symbols = {}
|
||||
for symbol in read_symbols(wrapper, type='U', dynamic=1):
|
||||
wrapper_symbols[symbol] = 1
|
||||
|
||||
# now go through the library looking for matches on the defined symbols:
|
||||
for symbol in read_symbols(library, type='T', dynamic=1):
|
||||
if symbol[0] == '_': continue
|
||||
if symbol not in wrapper_symbols:
|
||||
print symbol
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,575 +0,0 @@
|
|||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
import copy
|
||||
import sys
|
||||
|
||||
def get_valid_scheme_definitions(defs):
|
||||
return [x for x in defs if isinstance(x, tuple) and len(x) >= 2]
|
||||
|
||||
def unescape(s):
|
||||
s = s.replace('\r\n', '\\r\\n').replace('\t', '\\t')
|
||||
return s.replace('\r', '\\r').replace('\n', '\\n')
|
||||
|
||||
def make_docstring(lines):
|
||||
return "(char *) " + '\n'.join(['"%s"' % unescape(s) for s in lines])
|
||||
|
||||
# New Parameter class, wich emulates a tuple for compatibility reasons
|
||||
class Parameter(object):
|
||||
def __init__(self, ptype, pname, pdflt, pnull, pdir=None):
|
||||
self.ptype = ptype
|
||||
self.pname = pname
|
||||
self.pdflt = pdflt
|
||||
self.pnull = pnull
|
||||
self.pdir = pdir
|
||||
|
||||
def __len__(self): return 4
|
||||
def __getitem__(self, i):
|
||||
return (self.ptype, self.pname, self.pdflt, self.pnull)[i]
|
||||
|
||||
def merge(self, old):
|
||||
if old.pdflt is not None:
|
||||
self.pdflt = old.pdflt
|
||||
if old.pnull is not None:
|
||||
self.pnull = old.pnull
|
||||
|
||||
# We currently subclass 'str' to make impact on the rest of codegen as
|
||||
# little as possible. Later we can subclass 'object' instead, but
|
||||
# then we must find and adapt all places which expect return types to
|
||||
# be strings.
|
||||
class ReturnType(str):
|
||||
def __new__(cls, *args, **kwds):
|
||||
return str.__new__(cls, *args[:1])
|
||||
def __init__(self, type_name, optional=False):
|
||||
str.__init__(self)
|
||||
self.optional = optional
|
||||
|
||||
# Parameter for property based constructors
|
||||
class Property(object):
|
||||
def __init__(self, pname, optional, argname):
|
||||
self.pname = pname
|
||||
self.optional = optional
|
||||
self.argname = argname
|
||||
|
||||
def __len__(self): return 4
|
||||
def __getitem__(self, i):
|
||||
return ('', self.pname, self.optional, self.argname)[i]
|
||||
|
||||
def merge(self, old):
|
||||
if old.optional is not None:
|
||||
self.optional = old.optional
|
||||
if old.argname is not None:
|
||||
self.argname = old.argname
|
||||
|
||||
|
||||
class Definition(object):
|
||||
docstring = "NULL"
|
||||
|
||||
def py_name(self):
|
||||
return '%s.%s' % (self.module, self.name)
|
||||
|
||||
py_name = property(py_name)
|
||||
|
||||
def __init__(self, *args):
|
||||
"""Create a new defs object of this type. The arguments are the
|
||||
components of the definition"""
|
||||
raise RuntimeError("this is an abstract class")
|
||||
|
||||
def merge(self, old):
|
||||
"""Merge in customisations from older version of definition"""
|
||||
raise RuntimeError("this is an abstract class")
|
||||
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
"""write out this definition in defs file format"""
|
||||
raise RuntimeError("this is an abstract class")
|
||||
|
||||
def guess_return_value_ownership(self):
|
||||
"return 1 if caller owns return value"
|
||||
if getattr(self, 'is_constructor_of', False):
|
||||
self.caller_owns_return = True
|
||||
elif self.ret in ('char*', 'gchar*', 'string'):
|
||||
self.caller_owns_return = True
|
||||
else:
|
||||
self.caller_owns_return = False
|
||||
|
||||
|
||||
class ObjectDef(Definition):
|
||||
def __init__(self, name, *args):
|
||||
self.name = name
|
||||
self.module = None
|
||||
self.parent = None
|
||||
self.c_name = None
|
||||
self.typecode = None
|
||||
self.fields = []
|
||||
self.implements = []
|
||||
self.class_init_func = None
|
||||
self.has_new_constructor_api = False
|
||||
for arg in get_valid_scheme_definitions(args):
|
||||
if arg[0] == 'in-module':
|
||||
self.module = arg[1]
|
||||
elif arg[0] == 'docstring':
|
||||
self.docstring = make_docstring(arg[1:])
|
||||
elif arg[0] == 'parent':
|
||||
self.parent = arg[1]
|
||||
elif arg[0] == 'c-name':
|
||||
self.c_name = arg[1]
|
||||
elif arg[0] == 'gtype-id':
|
||||
self.typecode = arg[1]
|
||||
elif arg[0] == 'fields':
|
||||
for parg in arg[1:]:
|
||||
self.fields.append((parg[0], parg[1]))
|
||||
elif arg[0] == 'implements':
|
||||
self.implements.append(arg[1])
|
||||
def merge(self, old):
|
||||
# currently the .h parser doesn't try to work out what fields of
|
||||
# an object structure should be public, so we just copy the list
|
||||
# from the old version ...
|
||||
self.fields = old.fields
|
||||
self.implements = old.implements
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-object ' + self.name + '\n')
|
||||
if self.module:
|
||||
fp.write(' (in-module "' + self.module + '")\n')
|
||||
if self.parent != (None, None):
|
||||
fp.write(' (parent "' + self.parent + '")\n')
|
||||
for interface in self.implements:
|
||||
fp.write(' (implements "' + interface + '")\n')
|
||||
if self.c_name:
|
||||
fp.write(' (c-name "' + self.c_name + '")\n')
|
||||
if self.typecode:
|
||||
fp.write(' (gtype-id "' + self.typecode + '")\n')
|
||||
if self.fields:
|
||||
fp.write(' (fields\n')
|
||||
for (ftype, fname) in self.fields:
|
||||
fp.write(' \'("' + ftype + '" "' + fname + '")\n')
|
||||
fp.write(' )\n')
|
||||
fp.write(')\n\n')
|
||||
|
||||
class InterfaceDef(Definition):
|
||||
def __init__(self, name, *args):
|
||||
self.name = name
|
||||
self.module = None
|
||||
self.c_name = None
|
||||
self.typecode = None
|
||||
self.vtable = None
|
||||
self.fields = []
|
||||
self.interface_info = None
|
||||
for arg in get_valid_scheme_definitions(args):
|
||||
if arg[0] == 'in-module':
|
||||
self.module = arg[1]
|
||||
elif arg[0] == 'docstring':
|
||||
self.docstring = make_docstring(arg[1:])
|
||||
elif arg[0] == 'c-name':
|
||||
self.c_name = arg[1]
|
||||
elif arg[0] == 'gtype-id':
|
||||
self.typecode = arg[1]
|
||||
elif arg[0] == 'vtable':
|
||||
self.vtable = arg[1]
|
||||
if self.vtable is None:
|
||||
self.vtable = self.c_name + "Iface"
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-interface ' + self.name + '\n')
|
||||
if self.module:
|
||||
fp.write(' (in-module "' + self.module + '")\n')
|
||||
if self.c_name:
|
||||
fp.write(' (c-name "' + self.c_name + '")\n')
|
||||
if self.typecode:
|
||||
fp.write(' (gtype-id "' + self.typecode + '")\n')
|
||||
fp.write(')\n\n')
|
||||
|
||||
class EnumDef(Definition):
|
||||
def __init__(self, name, *args):
|
||||
self.deftype = 'enum'
|
||||
self.name = name
|
||||
self.in_module = None
|
||||
self.c_name = None
|
||||
self.typecode = None
|
||||
self.values = []
|
||||
for arg in get_valid_scheme_definitions(args):
|
||||
if arg[0] == 'in-module':
|
||||
self.in_module = arg[1]
|
||||
elif arg[0] == 'c-name':
|
||||
self.c_name = arg[1]
|
||||
elif arg[0] == 'gtype-id':
|
||||
self.typecode = arg[1]
|
||||
elif arg[0] == 'values':
|
||||
for varg in arg[1:]:
|
||||
self.values.append((varg[0], varg[1]))
|
||||
def merge(self, old):
|
||||
pass
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-' + self.deftype + ' ' + self.name + '\n')
|
||||
if self.in_module:
|
||||
fp.write(' (in-module "' + self.in_module + '")\n')
|
||||
fp.write(' (c-name "' + self.c_name + '")\n')
|
||||
fp.write(' (gtype-id "' + self.typecode + '")\n')
|
||||
if self.values:
|
||||
fp.write(' (values\n')
|
||||
for name, val in self.values:
|
||||
fp.write(' \'("' + name + '" "' + val + '")\n')
|
||||
fp.write(' )\n')
|
||||
fp.write(')\n\n')
|
||||
|
||||
class FlagsDef(EnumDef):
|
||||
def __init__(self, *args):
|
||||
apply(EnumDef.__init__, (self,) + args)
|
||||
self.deftype = 'flags'
|
||||
|
||||
class BoxedDef(Definition):
|
||||
def __init__(self, name, *args):
|
||||
self.name = name
|
||||
self.module = None
|
||||
self.c_name = None
|
||||
self.typecode = None
|
||||
self.copy = None
|
||||
self.release = None
|
||||
self.fields = []
|
||||
for arg in get_valid_scheme_definitions(args):
|
||||
if arg[0] == 'in-module':
|
||||
self.module = arg[1]
|
||||
elif arg[0] == 'c-name':
|
||||
self.c_name = arg[1]
|
||||
elif arg[0] == 'gtype-id':
|
||||
self.typecode = arg[1]
|
||||
elif arg[0] == 'copy-func':
|
||||
self.copy = arg[1]
|
||||
elif arg[0] == 'release-func':
|
||||
self.release = arg[1]
|
||||
elif arg[0] == 'fields':
|
||||
for parg in arg[1:]:
|
||||
self.fields.append((parg[0], parg[1]))
|
||||
def merge(self, old):
|
||||
# currently the .h parser doesn't try to work out what fields of
|
||||
# an object structure should be public, so we just copy the list
|
||||
# from the old version ...
|
||||
self.fields = old.fields
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-boxed ' + self.name + '\n')
|
||||
if self.module:
|
||||
fp.write(' (in-module "' + self.module + '")\n')
|
||||
if self.c_name:
|
||||
fp.write(' (c-name "' + self.c_name + '")\n')
|
||||
if self.typecode:
|
||||
fp.write(' (gtype-id "' + self.typecode + '")\n')
|
||||
if self.copy:
|
||||
fp.write(' (copy-func "' + self.copy + '")\n')
|
||||
if self.release:
|
||||
fp.write(' (release-func "' + self.release + '")\n')
|
||||
if self.fields:
|
||||
fp.write(' (fields\n')
|
||||
for (ftype, fname) in self.fields:
|
||||
fp.write(' \'("' + ftype + '" "' + fname + '")\n')
|
||||
fp.write(' )\n')
|
||||
fp.write(')\n\n')
|
||||
|
||||
class PointerDef(Definition):
|
||||
def __init__(self, name, *args):
|
||||
self.name = name
|
||||
self.module = None
|
||||
self.c_name = None
|
||||
self.typecode = None
|
||||
self.fields = []
|
||||
for arg in get_valid_scheme_definitions(args):
|
||||
if arg[0] == 'in-module':
|
||||
self.module = arg[1]
|
||||
elif arg[0] == 'c-name':
|
||||
self.c_name = arg[1]
|
||||
elif arg[0] == 'gtype-id':
|
||||
self.typecode = arg[1]
|
||||
elif arg[0] == 'fields':
|
||||
for parg in arg[1:]:
|
||||
self.fields.append((parg[0], parg[1]))
|
||||
def merge(self, old):
|
||||
# currently the .h parser doesn't try to work out what fields of
|
||||
# an object structure should be public, so we just copy the list
|
||||
# from the old version ...
|
||||
self.fields = old.fields
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-pointer ' + self.name + '\n')
|
||||
if self.module:
|
||||
fp.write(' (in-module "' + self.module + '")\n')
|
||||
if self.c_name:
|
||||
fp.write(' (c-name "' + self.c_name + '")\n')
|
||||
if self.typecode:
|
||||
fp.write(' (gtype-id "' + self.typecode + '")\n')
|
||||
if self.fields:
|
||||
fp.write(' (fields\n')
|
||||
for (ftype, fname) in self.fields:
|
||||
fp.write(' \'("' + ftype + '" "' + fname + '")\n')
|
||||
fp.write(' )\n')
|
||||
fp.write(')\n\n')
|
||||
|
||||
class MethodDefBase(Definition):
|
||||
def __init__(self, name, *args):
|
||||
dump = 0
|
||||
self.name = name
|
||||
self.ret = None
|
||||
self.caller_owns_return = None
|
||||
self.unblock_threads = None
|
||||
self.c_name = None
|
||||
self.typecode = None
|
||||
self.of_object = None
|
||||
self.params = [] # of form (type, name, default, nullok)
|
||||
self.varargs = 0
|
||||
self.deprecated = None
|
||||
for arg in get_valid_scheme_definitions(args):
|
||||
if arg[0] == 'of-object':
|
||||
self.of_object = arg[1]
|
||||
elif arg[0] == 'docstring':
|
||||
self.docstring = make_docstring(arg[1:])
|
||||
elif arg[0] == 'c-name':
|
||||
self.c_name = arg[1]
|
||||
elif arg[0] == 'gtype-id':
|
||||
self.typecode = arg[1]
|
||||
elif arg[0] == 'return-type':
|
||||
type_name = arg[1]
|
||||
optional = False
|
||||
for prop in arg[2:]:
|
||||
if prop[0] == 'optional':
|
||||
optional = True
|
||||
self.ret = ReturnType(type_name, optional)
|
||||
elif arg[0] == 'caller-owns-return':
|
||||
self.caller_owns_return = arg[1] in ('t', '#t')
|
||||
elif arg[0] == 'unblock-threads':
|
||||
self.unblock_threads = arg[1] in ('t', '#t')
|
||||
elif arg[0] == 'parameters':
|
||||
for parg in arg[1:]:
|
||||
ptype = parg[0]
|
||||
pname = parg[1]
|
||||
pdflt = None
|
||||
pnull = 0
|
||||
pdir = None
|
||||
for farg in parg[2:]:
|
||||
assert isinstance(farg, tuple)
|
||||
if farg[0] == 'default':
|
||||
pdflt = farg[1]
|
||||
elif farg[0] == 'null-ok':
|
||||
pnull = 1
|
||||
elif farg[0] == 'direction':
|
||||
pdir = farg[1]
|
||||
self.params.append(Parameter(ptype, pname, pdflt, pnull, pdir))
|
||||
elif arg[0] == 'varargs':
|
||||
self.varargs = arg[1] in ('t', '#t')
|
||||
elif arg[0] == 'deprecated':
|
||||
self.deprecated = arg[1]
|
||||
else:
|
||||
sys.stderr.write("Warning: %s argument unsupported.\n"
|
||||
% (arg[0]))
|
||||
dump = 1
|
||||
if dump:
|
||||
self.write_defs(sys.stderr)
|
||||
|
||||
if self.caller_owns_return is None and self.ret is not None:
|
||||
self.guess_return_value_ownership()
|
||||
|
||||
def merge(self, old, parmerge):
|
||||
self.caller_owns_return = old.caller_owns_return
|
||||
self.varargs = old.varargs
|
||||
# here we merge extra parameter flags accross to the new object.
|
||||
if not parmerge:
|
||||
self.params = copy.deepcopy(old.params)
|
||||
return
|
||||
for i in range(len(self.params)):
|
||||
ptype, pname, pdflt, pnull = self.params[i]
|
||||
for p2 in old.params:
|
||||
if p2[1] == pname:
|
||||
self.params[i] = (ptype, pname, p2[2], p2[3])
|
||||
break
|
||||
def _write_defs(self, fp=sys.stdout):
|
||||
if self.of_object != (None, None):
|
||||
fp.write(' (of-object "' + self.of_object + '")\n')
|
||||
if self.c_name:
|
||||
fp.write(' (c-name "' + self.c_name + '")\n')
|
||||
if self.typecode:
|
||||
fp.write(' (gtype-id "' + self.typecode + '")\n')
|
||||
if self.caller_owns_return:
|
||||
fp.write(' (caller-owns-return #t)\n')
|
||||
if self.unblock_threads:
|
||||
fp.write(' (unblock_threads #t)\n')
|
||||
if self.ret:
|
||||
fp.write(' (return-type "' + self.ret + '")\n')
|
||||
if self.deprecated:
|
||||
fp.write(' (deprecated "' + self.deprecated + '")\n')
|
||||
if self.params:
|
||||
fp.write(' (parameters\n')
|
||||
for ptype, pname, pdflt, pnull in self.params:
|
||||
fp.write(' \'("' + ptype + '" "' + pname +'"')
|
||||
if pdflt: fp.write(' (default "' + pdflt + '")')
|
||||
if pnull: fp.write(' (null-ok)')
|
||||
fp.write(')\n')
|
||||
fp.write(' )\n')
|
||||
if self.varargs:
|
||||
fp.write(' (varargs #t)\n')
|
||||
fp.write(')\n\n')
|
||||
|
||||
|
||||
class MethodDef(MethodDefBase):
|
||||
def __init__(self, name, *args):
|
||||
MethodDefBase.__init__(self, name, *args)
|
||||
for item in ('c_name', 'of_object'):
|
||||
if self.__dict__[item] == None:
|
||||
self.write_defs(sys.stderr)
|
||||
raise RuntimeError("definition missing required %s" % (item,))
|
||||
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-method ' + self.name + '\n')
|
||||
self._write_defs(fp)
|
||||
|
||||
class VirtualDef(MethodDefBase):
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-virtual ' + self.name + '\n')
|
||||
self._write_defs(fp)
|
||||
|
||||
class FunctionDef(Definition):
|
||||
def __init__(self, name, *args):
|
||||
dump = 0
|
||||
self.name = name
|
||||
self.in_module = None
|
||||
self.is_constructor_of = None
|
||||
self.ret = None
|
||||
self.caller_owns_return = None
|
||||
self.unblock_threads = None
|
||||
self.c_name = None
|
||||
self.typecode = None
|
||||
self.params = [] # of form (type, name, default, nullok)
|
||||
self.varargs = 0
|
||||
self.deprecated = None
|
||||
for arg in get_valid_scheme_definitions(args):
|
||||
if arg[0] == 'in-module':
|
||||
self.in_module = arg[1]
|
||||
elif arg[0] == 'docstring':
|
||||
self.docstring = make_docstring(arg[1:])
|
||||
elif arg[0] == 'is-constructor-of':
|
||||
self.is_constructor_of = arg[1]
|
||||
elif arg[0] == 'c-name':
|
||||
self.c_name = arg[1]
|
||||
elif arg[0] == 'gtype-id':
|
||||
self.typecode = arg[1]
|
||||
elif arg[0] == 'return-type':
|
||||
self.ret = arg[1]
|
||||
elif arg[0] == 'caller-owns-return':
|
||||
self.caller_owns_return = arg[1] in ('t', '#t')
|
||||
elif arg[0] == 'unblock-threads':
|
||||
self.unblock_threads = arg[1] in ('t', '#t')
|
||||
elif arg[0] == 'parameters':
|
||||
for parg in arg[1:]:
|
||||
ptype = parg[0]
|
||||
pname = parg[1]
|
||||
pdflt = None
|
||||
pnull = 0
|
||||
for farg in parg[2:]:
|
||||
if farg[0] == 'default':
|
||||
pdflt = farg[1]
|
||||
elif farg[0] == 'null-ok':
|
||||
pnull = 1
|
||||
self.params.append(Parameter(ptype, pname, pdflt, pnull))
|
||||
elif arg[0] == 'properties':
|
||||
if self.is_constructor_of is None:
|
||||
print >> sys.stderr, "Warning: (properties ...) "\
|
||||
"is only valid for constructors"
|
||||
for prop in arg[1:]:
|
||||
pname = prop[0]
|
||||
optional = False
|
||||
argname = pname
|
||||
for farg in prop[1:]:
|
||||
if farg[0] == 'optional':
|
||||
optional = True
|
||||
elif farg[0] == 'argname':
|
||||
argname = farg[1]
|
||||
self.params.append(Property(pname, optional, argname))
|
||||
elif arg[0] == 'varargs':
|
||||
self.varargs = arg[1] in ('t', '#t')
|
||||
elif arg[0] == 'deprecated':
|
||||
self.deprecated = arg[1]
|
||||
else:
|
||||
sys.stderr.write("Warning: %s argument unsupported\n"
|
||||
% (arg[0],))
|
||||
dump = 1
|
||||
if dump:
|
||||
self.write_defs(sys.stderr)
|
||||
|
||||
if self.caller_owns_return is None and self.ret is not None:
|
||||
self.guess_return_value_ownership()
|
||||
for item in ('c_name',):
|
||||
if self.__dict__[item] == None:
|
||||
self.write_defs(sys.stderr)
|
||||
raise RuntimeError("definition missing required %s" % (item,))
|
||||
|
||||
_method_write_defs = MethodDef.__dict__['write_defs']
|
||||
|
||||
def merge(self, old, parmerge):
|
||||
self.caller_owns_return = old.caller_owns_return
|
||||
self.varargs = old.varargs
|
||||
if not parmerge:
|
||||
self.params = copy.deepcopy(old.params)
|
||||
return
|
||||
# here we merge extra parameter flags accross to the new object.
|
||||
def merge_param(param):
|
||||
for old_param in old.params:
|
||||
if old_param.pname == param.pname:
|
||||
if isinstance(old_param, Property):
|
||||
# h2def never scans Property's, therefore if
|
||||
# we have one it was manually written, so we
|
||||
# keep it.
|
||||
return copy.deepcopy(old_param)
|
||||
else:
|
||||
param.merge(old_param)
|
||||
return param
|
||||
raise RuntimeError("could not find %s in old_parameters %r" % (
|
||||
param.pname, [p.pname for p in old.params]))
|
||||
try:
|
||||
self.params = map(merge_param, self.params)
|
||||
except RuntimeError:
|
||||
# parameter names changed and we can't find a match; it's
|
||||
# safer to keep the old parameter list untouched.
|
||||
self.params = copy.deepcopy(old.params)
|
||||
|
||||
if not self.is_constructor_of:
|
||||
try:
|
||||
self.is_constructor_of = old.is_constructor_of
|
||||
except AttributeError:
|
||||
pass
|
||||
if isinstance(old, MethodDef):
|
||||
self.name = old.name
|
||||
# transmogrify from function into method ...
|
||||
self.write_defs = self._method_write_defs
|
||||
self.of_object = old.of_object
|
||||
del self.params[0]
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
fp.write('(define-function ' + self.name + '\n')
|
||||
if self.in_module:
|
||||
fp.write(' (in-module "' + self.in_module + '")\n')
|
||||
if self.is_constructor_of:
|
||||
fp.write(' (is-constructor-of "' + self.is_constructor_of +'")\n')
|
||||
if self.c_name:
|
||||
fp.write(' (c-name "' + self.c_name + '")\n')
|
||||
if self.typecode:
|
||||
fp.write(' (gtype-id "' + self.typecode + '")\n')
|
||||
if self.caller_owns_return:
|
||||
fp.write(' (caller-owns-return #t)\n')
|
||||
if self.unblock_threads:
|
||||
fp.write(' (unblock-threads #t)\n')
|
||||
if self.ret:
|
||||
fp.write(' (return-type "' + self.ret + '")\n')
|
||||
if self.deprecated:
|
||||
fp.write(' (deprecated "' + self.deprecated + '")\n')
|
||||
if self.params:
|
||||
if isinstance(self.params[0], Parameter):
|
||||
fp.write(' (parameters\n')
|
||||
for ptype, pname, pdflt, pnull in self.params:
|
||||
fp.write(' \'("' + ptype + '" "' + pname +'"')
|
||||
if pdflt: fp.write(' (default "' + pdflt + '")')
|
||||
if pnull: fp.write(' (null-ok)')
|
||||
fp.write(')\n')
|
||||
fp.write(' )\n')
|
||||
elif isinstance(self.params[0], Property):
|
||||
fp.write(' (properties\n')
|
||||
for prop in self.params:
|
||||
fp.write(' \'("' + prop.pname +'"')
|
||||
if prop.optional: fp.write(' (optional)')
|
||||
fp.write(')\n')
|
||||
fp.write(' )\n')
|
||||
else:
|
||||
assert False, "strange parameter list %r" % self.params[0]
|
||||
if self.varargs:
|
||||
fp.write(' (varargs #t)\n')
|
||||
|
||||
fp.write(')\n\n')
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
import os, sys
|
||||
import scmexpr
|
||||
from definitions import BoxedDef, EnumDef, FlagsDef, FunctionDef, \
|
||||
InterfaceDef, MethodDef, ObjectDef, PointerDef, VirtualDef
|
||||
|
||||
include_path = ['.']
|
||||
|
||||
class IncludeParser(scmexpr.Parser):
|
||||
"""A simple parser that follows include statements automatically"""
|
||||
def include(self, input_filename):
|
||||
global include_path
|
||||
if os.path.isabs(input_filename):
|
||||
filename = input_filename
|
||||
# set self.filename to the include name, to handle recursive includes
|
||||
oldfile = self.filename
|
||||
self.filename = filename
|
||||
self.startParsing()
|
||||
self.filename = oldfile
|
||||
else:
|
||||
inc_path = [os.path.dirname(self.filename)] + include_path
|
||||
for filename in [os.path.join(path_entry, input_filename)
|
||||
for path_entry in inc_path]:
|
||||
if not os.path.exists(filename):
|
||||
continue
|
||||
# set self.filename to the include name, to handle recursive includes
|
||||
oldfile = self.filename
|
||||
self.filename = filename
|
||||
self.startParsing()
|
||||
self.filename = oldfile
|
||||
break
|
||||
else:
|
||||
raise IOError("%s not found in include path %s" % (input_filename, inc_path))
|
||||
|
||||
class DefsParser(IncludeParser):
|
||||
def __init__(self, arg, defines={}):
|
||||
IncludeParser.__init__(self, arg)
|
||||
self.objects = []
|
||||
self.interfaces = []
|
||||
self.enums = [] # enums and flags
|
||||
self.boxes = [] # boxed types
|
||||
self.pointers = [] # pointer types
|
||||
self.functions = [] # functions and methods
|
||||
self.virtuals = [] # virtual methods
|
||||
self.c_name = {} # hash of c names of functions
|
||||
self.methods = {} # hash of methods of particular objects
|
||||
self.defines = defines # -Dfoo=bar options, as dictionary
|
||||
|
||||
def define_object(self, *args):
|
||||
odef = apply(ObjectDef, args)
|
||||
self.objects.append(odef)
|
||||
self.c_name[odef.c_name] = odef
|
||||
def define_interface(self, *args):
|
||||
idef = apply(InterfaceDef, args)
|
||||
self.interfaces.append(idef)
|
||||
self.c_name[idef.c_name] = idef
|
||||
def define_enum(self, *args):
|
||||
edef = apply(EnumDef, args)
|
||||
self.enums.append(edef)
|
||||
self.c_name[edef.c_name] = edef
|
||||
def define_flags(self, *args):
|
||||
fdef = apply(FlagsDef, args)
|
||||
self.enums.append(fdef)
|
||||
self.c_name[fdef.c_name] = fdef
|
||||
def define_boxed(self, *args):
|
||||
bdef = apply(BoxedDef, args)
|
||||
self.boxes.append(bdef)
|
||||
self.c_name[bdef.c_name] = bdef
|
||||
def define_pointer(self, *args):
|
||||
pdef = apply(PointerDef, args)
|
||||
self.pointers.append(pdef)
|
||||
self.c_name[pdef.c_name] = pdef
|
||||
def define_function(self, *args):
|
||||
fdef = apply(FunctionDef, args)
|
||||
self.functions.append(fdef)
|
||||
self.c_name[fdef.c_name] = fdef
|
||||
def define_method(self, *args):
|
||||
mdef = apply(MethodDef, args)
|
||||
self.functions.append(mdef)
|
||||
self.c_name[mdef.c_name] = mdef
|
||||
def define_virtual(self, *args):
|
||||
vdef = apply(VirtualDef, args)
|
||||
self.virtuals.append(vdef)
|
||||
def merge(self, old, parmerge):
|
||||
for obj in self.objects:
|
||||
if old.c_name.has_key(obj.c_name):
|
||||
obj.merge(old.c_name[obj.c_name])
|
||||
for f in self.functions:
|
||||
if old.c_name.has_key(f.c_name):
|
||||
f.merge(old.c_name[f.c_name], parmerge)
|
||||
|
||||
def printMissing(self, old):
|
||||
for obj in self.objects:
|
||||
if not old.c_name.has_key(obj.c_name):
|
||||
obj.write_defs()
|
||||
for f in self.functions:
|
||||
if not old.c_name.has_key(f.c_name):
|
||||
f.write_defs()
|
||||
|
||||
def write_defs(self, fp=sys.stdout):
|
||||
for obj in self.objects:
|
||||
obj.write_defs(fp)
|
||||
for enum in self.enums:
|
||||
enum.write_defs(fp)
|
||||
for boxed in self.boxes:
|
||||
boxed.write_defs(fp)
|
||||
for pointer in self.pointers:
|
||||
pointer.write_defs(fp)
|
||||
for func in self.functions:
|
||||
func.write_defs(fp)
|
||||
|
||||
def find_object(self, c_name):
|
||||
for obj in self.objects:
|
||||
if obj.c_name == c_name:
|
||||
return obj
|
||||
else:
|
||||
raise ValueError('object %r not found' % c_name)
|
||||
|
||||
def find_constructor(self, obj, overrides):
|
||||
for func in self.functions:
|
||||
if isinstance(func, FunctionDef) and \
|
||||
func.is_constructor_of == obj.c_name and \
|
||||
not overrides.is_ignored(func.c_name):
|
||||
return func
|
||||
|
||||
def find_methods(self, obj):
|
||||
objname = obj.c_name
|
||||
return filter(lambda func, on=objname: isinstance(func, MethodDef) and
|
||||
func.of_object == on, self.functions)
|
||||
|
||||
def find_virtuals(self, obj):
|
||||
objname = obj.c_name
|
||||
retval = filter(lambda func, on=objname: isinstance(func, VirtualDef) and
|
||||
func.of_object == on, self.virtuals)
|
||||
return retval
|
||||
|
||||
def find_functions(self):
|
||||
return filter(lambda func: isinstance(func, FunctionDef) and
|
||||
not func.is_constructor_of, self.functions)
|
||||
|
||||
def ifdef(self, *args):
|
||||
if args[0] in self.defines:
|
||||
for arg in args[1:]:
|
||||
#print >> sys.stderr, "-----> Handling conditional definition (%s): %s" % (args[0], arg)
|
||||
self.handle(arg)
|
||||
else:
|
||||
pass
|
||||
#print >> sys.stderr, "-----> Conditional %s is not true" % (args[0],)
|
||||
|
||||
def ifndef(self, *args):
|
||||
if args[0] not in self.defines:
|
||||
for arg in args[1:]:
|
||||
self.handle(arg)
|
||||
|
|
@ -1,461 +0,0 @@
|
|||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
'''Simple module for extracting GNOME style doc comments from C
|
||||
sources, so I can use them for other purposes.'''
|
||||
|
||||
import sys, os, string, re
|
||||
|
||||
# Used to tell if the "Since: ..." portion of the gtkdoc function description
|
||||
# should be omitted. This is useful for some C++ modules such as gstreamermm
|
||||
# that wrap C API which is still unstable and including this information would
|
||||
# not be useful.
|
||||
# This variable is modified from docextract_to_xml based on the --no-since
|
||||
# option being specified.
|
||||
no_since = False
|
||||
|
||||
__all__ = ['extract']
|
||||
|
||||
class GtkDoc:
|
||||
def __init__(self):
|
||||
self.name = None
|
||||
self.block_type = '' # The block type ('function', 'signal', 'property')
|
||||
self.params = []
|
||||
self.annotations = []
|
||||
self.description = ''
|
||||
self.ret = ('', []) # (return, annotations)
|
||||
def set_name(self, name):
|
||||
self.name = name
|
||||
def set_type(self, block_type):
|
||||
self.block_type = block_type
|
||||
def get_type(self):
|
||||
return self.block_type
|
||||
def add_param(self, name, description, annotations=[]):
|
||||
if name == '...':
|
||||
name = 'Varargs'
|
||||
self.params.append((name, description, annotations))
|
||||
def append_to_last_param(self, extra):
|
||||
self.params[-1] = (self.params[-1][0], self.params[-1][1] + extra,
|
||||
self.params[-1][2])
|
||||
def append_to_named_param(self, name, extra):
|
||||
for i in range(len(self.params)):
|
||||
if self.params[i][0] == name:
|
||||
self.params[i] = (name, self.params[i][1] + extra,
|
||||
self.params[i][2])
|
||||
return
|
||||
# fall through to adding extra parameter ...
|
||||
self.add_param(name, extra)
|
||||
def add_annotation(self, annotation):
|
||||
self.annotations.append(annotation)
|
||||
def get_annotations(self):
|
||||
return self.annotations
|
||||
def append_to_description(self, extra):
|
||||
self.description = self.description + extra
|
||||
def get_description(self):
|
||||
return self.description
|
||||
def add_return(self, first_line, annotations=[]):
|
||||
self.ret = (first_line, annotations)
|
||||
def append_to_return(self, extra):
|
||||
self.ret = (self.ret[0] + extra, self.ret[1])
|
||||
|
||||
comment_start_pattern = re.compile(r'^\s*/\*\*\s')
|
||||
comment_end_pattern = re.compile(r'^\s*\*+/')
|
||||
comment_line_lead_pattern = re.compile(r'^\s*\*\s*')
|
||||
comment_empty_line_pattern = re.compile(r'^\s*\**\s*$')
|
||||
function_name_pattern = re.compile(r'^([a-z]\w*)\s*:?(\s*\(.*\)\s*){0,2}\s*$')
|
||||
signal_name_pattern = re.compile(r'^([A-Z]\w+::[a-z0-9-]+)\s*:?(\s*\(.*\)\s*){0,2}\s*$')
|
||||
property_name_pattern = re.compile(r'^([A-Z]\w+:[a-z0-9-]+)\s*:?(\s*\(.*\)\s*){0,2}\s*$')
|
||||
return_pattern = re.compile(r'^@?(returns:|return\s+value:)(.*\n?)$', re.IGNORECASE)
|
||||
deprecated_pattern = re.compile(r'^(deprecated\s*:\s*.*\n?)$', re.IGNORECASE)
|
||||
rename_to_pattern = re.compile(r'^(rename\s+to)\s*:\s*(.*\n?)$', re.IGNORECASE)
|
||||
param_pattern = re.compile(r'^@(\S+)\s*:(.*\n?)$')
|
||||
# Used to extract the annotations in the parameter and return descriptions
|
||||
# extracted using above [param|return]_pattern patterns.
|
||||
annotations_pattern = re.compile(r'^(?:(\s*\(.*\)\s*)*:)')
|
||||
# Used to construct the annotation lists.
|
||||
annotation_lead_pattern = re.compile(r'^\s*\(\s*(.*?)\s*\)\s*')
|
||||
|
||||
# These patterns determine the identifier of the current comment block. They
|
||||
# are grouped in a list for easy determination of block identifiers (in
|
||||
# skip_to_identifier). The function_name_pattern should be tested for last
|
||||
# because it always matches signal and property identifiers.
|
||||
identifier_patterns = [ signal_name_pattern, property_name_pattern, function_name_pattern ]
|
||||
|
||||
# This pattern is to match return sections that forget to have a colon (':')
|
||||
# after the initial 'Return' phrase. It is not included by default in the list
|
||||
# of final sections below because a lot of function descriptions begin with
|
||||
# 'Returns ...' and the process_description() function would stop right at that
|
||||
# first line, thinking it is a return section.
|
||||
no_colon_return_pattern = re.compile(r'^@?(returns|return\s+value)\s*(.*\n?)$', re.IGNORECASE)
|
||||
since_pattern = re.compile(r'^(since\s*:\s*.*\n?)$', re.IGNORECASE)
|
||||
|
||||
# These patterns normally will be encountered after the description. Knowing
|
||||
# the order of their appearance is difficult so this list is used to test when
|
||||
# one begins and the other ends when processing the rest of the sections after
|
||||
# the description.
|
||||
final_section_patterns = [ return_pattern, since_pattern, deprecated_pattern, rename_to_pattern ]
|
||||
|
||||
def parse_file(fp, doc_dict):
|
||||
line = fp.readline()
|
||||
while line:
|
||||
cur_doc = GtkDoc()
|
||||
line = skip_to_comment_block(fp, line)
|
||||
line = skip_to_identifier(fp, line, cur_doc)
|
||||
# See if the identifier is found (stored in the current GtkDoc by
|
||||
# skip_to_identifier). If so, continue reading the rest of the comment
|
||||
# block.
|
||||
if cur_doc.name:
|
||||
line = process_params(fp, line, cur_doc)
|
||||
line = process_description(fp, line, cur_doc)
|
||||
line = process_final_sections(fp, line, cur_doc)
|
||||
# Add the current doc block to the dictionary of doc blocks.
|
||||
doc_dict[cur_doc.name] = cur_doc
|
||||
|
||||
# Given a list of annotations as string of the form
|
||||
# '(annotation1) (annotation2) ...' return a list of annotations of the form
|
||||
# [ (name1, value1), (name2, value2) ... ]. Not all annotations have values so
|
||||
# the values in the list of tuples could be empty ('').
|
||||
def get_annotation_list(annotations):
|
||||
annotation_list = []
|
||||
while annotations:
|
||||
match = annotation_lead_pattern.match(annotations)
|
||||
if match:
|
||||
annotation_contents = match.group(1)
|
||||
name, split, value = annotation_contents.strip().partition(' ')
|
||||
annotation_list.append((name, value))
|
||||
# Remove first occurrence to continue processing.
|
||||
annotations = annotation_lead_pattern.sub('', annotations)
|
||||
else:
|
||||
break
|
||||
return annotation_list
|
||||
|
||||
# Given a currently read line, test that line and continue reading until the
|
||||
# beginning of a comment block is found or eof is reached. Return the last
|
||||
# read line.
|
||||
def skip_to_comment_block(fp, line):
|
||||
while line:
|
||||
if comment_start_pattern.match(line):
|
||||
break
|
||||
line = fp.readline()
|
||||
return line
|
||||
|
||||
# Given the current line in a comment block, continue skipping lines until a
|
||||
# non-blank line in the comment block is found or until the end of the block
|
||||
# (or eof) is reached. Returns the line where reading stopped.
|
||||
def skip_to_nonblank(fp, line):
|
||||
while line:
|
||||
if not comment_empty_line_pattern.match(line):
|
||||
break
|
||||
line = fp.readline()
|
||||
# Stop processing if eof or end of comment block is reached.
|
||||
if not line or comment_end_pattern.match(line):
|
||||
break
|
||||
return line
|
||||
|
||||
# Given the first line of a comment block (the '/**'), see if the next
|
||||
# non-blank line is the identifier of the comment block. Stop processing if
|
||||
# the end of the block or eof is reached. Store the identifier (if there is
|
||||
# one) and its type ('function', 'signal' or 'property') in the given GtkDoc.
|
||||
# Return the line where the identifier is found or the line that stops the
|
||||
# processing (if eof or the end of the comment block is found first).
|
||||
def skip_to_identifier(fp, line, cur_doc):
|
||||
# Skip the initial comment block line ('/**') if not eof.
|
||||
if line: line = fp.readline()
|
||||
|
||||
# Now skip empty lines.
|
||||
line = skip_to_nonblank(fp, line)
|
||||
|
||||
# See if the first non-blank line is the identifier.
|
||||
if line and not comment_end_pattern.match(line):
|
||||
# Remove the initial ' * ' in comment block line and see if there is an
|
||||
# identifier.
|
||||
line = comment_line_lead_pattern.sub('', line)
|
||||
for pattern in identifier_patterns:
|
||||
match = pattern.match(line)
|
||||
if match:
|
||||
# Set the GtkDoc name.
|
||||
cur_doc.set_name(match.group(1))
|
||||
# Get annotations and add them to the GtkDoc.
|
||||
annotations = get_annotation_list(match.group(2))
|
||||
for annotation in annotations:
|
||||
cur_doc.add_annotation(annotation)
|
||||
# Set the GtkDoc type.
|
||||
if pattern == signal_name_pattern:
|
||||
cur_doc.set_type('signal')
|
||||
elif pattern == property_name_pattern:
|
||||
cur_doc.set_type('property')
|
||||
elif pattern == function_name_pattern:
|
||||
cur_doc.set_type('function')
|
||||
return line
|
||||
return line
|
||||
|
||||
# Given a currently read line (presumably the identifier line), read the next
|
||||
# lines, testing to see if the lines are part of parameter descriptions. If
|
||||
# so, store the parameter descriptions in the given doc block. Stop on eof and
|
||||
# return the last line that stops the processing.
|
||||
def process_params(fp, line, cur_doc):
|
||||
# Skip the identifier line if not eof. Also skip any blank lines in the
|
||||
# comment block. Return if eof or the end of the comment block are
|
||||
# encountered.
|
||||
if line: line = fp.readline()
|
||||
line = skip_to_nonblank(fp, line)
|
||||
if not line or comment_end_pattern.match(line):
|
||||
return line
|
||||
|
||||
# Remove initial ' * ' in first non-empty comment block line.
|
||||
line = comment_line_lead_pattern.sub('', line)
|
||||
|
||||
# Now process possible parameters as long as no eof or the end of the
|
||||
# param section is not reached (which could be triggered by anything that
|
||||
# doesn't match a '@param:..." line, even the end of the comment block).
|
||||
match = param_pattern.match(line)
|
||||
while line and match:
|
||||
description = match.group(2)
|
||||
|
||||
# First extract the annotations from the description and save them.
|
||||
annotations = []
|
||||
annotation_match = annotations_pattern.match(description)
|
||||
if annotation_match:
|
||||
annotations = get_annotation_list(annotation_match.group(1))
|
||||
# Remove the annotations from the description
|
||||
description = annotations_pattern.sub('', description)
|
||||
|
||||
# Default to appending lines to current parameter.
|
||||
append_func = cur_doc.append_to_last_param
|
||||
|
||||
# See if the return has been included as part of the parameter
|
||||
# section and make sure that lines are added to the GtkDoc return if
|
||||
# so.
|
||||
if match.group(1).lower() == "returns":
|
||||
cur_doc.add_return(description, annotations)
|
||||
append_func = cur_doc.append_to_return
|
||||
# If not, just add it as a regular parameter.
|
||||
else:
|
||||
cur_doc.add_param(match.group(1), description, annotations)
|
||||
|
||||
# Now read lines and append them until next parameter, beginning of
|
||||
# description (an empty line), the end of the comment block or eof.
|
||||
line = fp.readline()
|
||||
while line:
|
||||
# Stop processing if end of comment block or a blank comment line
|
||||
# is encountered.
|
||||
if comment_empty_line_pattern.match(line) or \
|
||||
comment_end_pattern.match(line):
|
||||
break
|
||||
|
||||
# Remove initial ' * ' in comment block line.
|
||||
line = comment_line_lead_pattern.sub('', line)
|
||||
|
||||
# Break from current param processing if a new one is
|
||||
# encountered.
|
||||
if param_pattern.match(line): break;
|
||||
|
||||
# Otherwise, just append the current line and get the next line.
|
||||
append_func(line)
|
||||
line = fp.readline()
|
||||
|
||||
# Re-evaluate match for while condition
|
||||
match = param_pattern.match(line)
|
||||
|
||||
# End by returning the current line.
|
||||
return line
|
||||
|
||||
# Having processed parameters, read the following lines into the description of
|
||||
# the current doc block until the end of the comment block, the end of file or
|
||||
# a return section is encountered.
|
||||
def process_description(fp, line, cur_doc):
|
||||
# First skip empty lines returning on eof or end of comment block.
|
||||
line = skip_to_nonblank(fp, line)
|
||||
if not line or comment_end_pattern.match(line):
|
||||
return line
|
||||
|
||||
# Remove initial ' * ' in non-empty comment block line.
|
||||
line = comment_line_lead_pattern.sub('', line)
|
||||
|
||||
# Also remove possible 'Description:' prefix.
|
||||
if line[:12] == 'Description:': line = line[12:]
|
||||
|
||||
# Used to tell if the previous line was blank and a return section
|
||||
# uncommonly marked with 'Returns ...' instead of 'Returns: ...' has
|
||||
# started (assume it is non-empty to begin with).
|
||||
prev_line = 'non-empty'
|
||||
|
||||
# Now read lines until a new section (like a return or a since section) is
|
||||
# encountered.
|
||||
while line:
|
||||
# See if the description section has ended (if the line begins with
|
||||
# 'Returns ...' and the previous line was empty -- this loop replaces
|
||||
# empty lines with a newline).
|
||||
if no_colon_return_pattern.match(line) and prev_line == '\n':
|
||||
return line
|
||||
# Or if one of the patterns of the final sections match
|
||||
for pattern in final_section_patterns:
|
||||
if pattern.match(line):
|
||||
return line
|
||||
|
||||
# If not, append lines to description in the doc comment block.
|
||||
cur_doc.append_to_description(line)
|
||||
|
||||
prev_line = line
|
||||
line = fp.readline()
|
||||
|
||||
# Stop processing on eof or at the end of comment block.
|
||||
if not line or comment_end_pattern.match(line):
|
||||
return line
|
||||
|
||||
# Remove initial ' * ' in line so that the text can be appended to the
|
||||
# description of the comment block and make sure that if the line is
|
||||
# empty it be interpreted as a newline.
|
||||
line = comment_line_lead_pattern.sub('', line)
|
||||
if not line: line = '\n'
|
||||
|
||||
# Given the line that ended the description (the first line of one of the final
|
||||
# sections) process the final sections ('Returns:', 'Since:', etc.) until the
|
||||
# end of the comment block or eof. Return the line that ends the processing.
|
||||
def process_final_sections(fp, line, cur_doc):
|
||||
while line and not comment_end_pattern.match(line):
|
||||
# Remove leading ' * ' from current non-empty comment line.
|
||||
line = comment_line_lead_pattern.sub('', line)
|
||||
# Temporarily append the no colon return pattern to the final section
|
||||
# patterns now that the description has been processed. It will be
|
||||
# removed after the for loop below executes so that future descriptions
|
||||
# that begin with 'Returns ...' are not interpreted as a return
|
||||
# section.
|
||||
final_section_patterns.append(no_colon_return_pattern)
|
||||
for pattern in final_section_patterns:
|
||||
match = pattern.match(line)
|
||||
if match:
|
||||
if pattern == return_pattern or \
|
||||
pattern == no_colon_return_pattern:
|
||||
# Dealing with a 'Returns:' so first extract the
|
||||
# annotations from the description and save them.
|
||||
description = match.group(2)
|
||||
annotations = []
|
||||
annotation_match = \
|
||||
annotations_pattern.match(description)
|
||||
if annotation_match:
|
||||
annotations = \
|
||||
get_annotation_list(annotation_match.group(1))
|
||||
# Remove the annotations from the description
|
||||
description = annotations_pattern.sub('', description)
|
||||
|
||||
# Now add the return.
|
||||
cur_doc.add_return(description, annotations)
|
||||
# In case more lines need to be appended.
|
||||
append_func = cur_doc.append_to_return
|
||||
elif pattern == rename_to_pattern:
|
||||
# Dealing with a 'Rename to:' section (GObjectIntrospection
|
||||
# annotation) so no further lines will be appended but this
|
||||
# single one (and only to the annotations).
|
||||
append_func = None
|
||||
cur_doc.add_annotation((match.group(1),
|
||||
match.group(2)))
|
||||
else:
|
||||
# For all others ('Since:' and 'Deprecated:') just append
|
||||
# the line to the description for now.
|
||||
# But if --no-since is specified, don't append it.
|
||||
if no_since and pattern == since_pattern:
|
||||
pass
|
||||
else:
|
||||
cur_doc.append_to_description(line)
|
||||
|
||||
# In case more lines need to be appended.
|
||||
append_func = cur_doc.append_to_description
|
||||
|
||||
# Stop final section pattern matching for loop since a match
|
||||
# has already been found.
|
||||
break
|
||||
|
||||
# Remove the no colon return pattern (which was temporarily added in
|
||||
# the just executed loop) from the list of final section patterns.
|
||||
final_section_patterns.pop()
|
||||
|
||||
line = fp.readline()
|
||||
|
||||
# Now continue appending lines to current section until a new one is
|
||||
# found or an eof or the end of the comment block is encountered.
|
||||
finished = False
|
||||
while not finished and line and \
|
||||
not comment_end_pattern.match(line):
|
||||
# Remove leading ' * ' from line and make sure that if it is empty,
|
||||
# it be interpreted as a newline.
|
||||
line = comment_line_lead_pattern.sub('', line)
|
||||
if not line: line = '\n'
|
||||
|
||||
for pattern in final_section_patterns:
|
||||
if pattern.match(line):
|
||||
finished = True
|
||||
break
|
||||
|
||||
# Break out of loop if a new section is found (determined in above
|
||||
# inner loop).
|
||||
if finished: break
|
||||
|
||||
# Now it's safe to append line.
|
||||
if append_func: append_func(line)
|
||||
|
||||
# Get the next line to continue processing.
|
||||
line = fp.readline()
|
||||
|
||||
return line
|
||||
|
||||
def parse_dir(dir, doc_dict):
|
||||
for file in os.listdir(dir):
|
||||
if file in ('.', '..'): continue
|
||||
path = os.path.join(dir, file)
|
||||
if os.path.isdir(path):
|
||||
parse_dir(path, doc_dict)
|
||||
if len(file) > 2 and file[-2:] == '.c':
|
||||
sys.stderr.write("Processing " + path + '\n')
|
||||
parse_file(open(path, 'r'), doc_dict)
|
||||
|
||||
def extract(dirs, doc_dict=None):
|
||||
if not doc_dict: doc_dict = {}
|
||||
for dir in dirs:
|
||||
parse_dir(dir, doc_dict)
|
||||
return doc_dict
|
||||
|
||||
tmpl_section_pattern = re.compile(r'^<!-- ##### (\w+) (\w+) ##### -->$')
|
||||
def parse_tmpl(fp, doc_dict):
|
||||
cur_doc = None
|
||||
|
||||
line = fp.readline()
|
||||
while line:
|
||||
match = tmpl_section_pattern.match(line)
|
||||
if match:
|
||||
cur_doc = None # new input shouldn't affect the old doc dict
|
||||
sect_type = match.group(1)
|
||||
sect_name = match.group(2)
|
||||
|
||||
if sect_type == 'FUNCTION':
|
||||
cur_doc = doc_dict.get(sect_name)
|
||||
if not cur_doc:
|
||||
cur_doc = GtkDoc()
|
||||
cur_doc.set_name(sect_name)
|
||||
doc_dict[sect_name] = cur_doc
|
||||
elif line == '<!-- # Unused Parameters # -->\n':
|
||||
cur_doc = None # don't worry about unused params.
|
||||
elif cur_doc:
|
||||
if line[:10] == '@Returns: ':
|
||||
if string.strip(line[10:]):
|
||||
cur_doc.append_to_return(line[10:])
|
||||
elif line[0] == '@':
|
||||
pos = string.find(line, ':')
|
||||
if pos >= 0:
|
||||
cur_doc.append_to_named_param(line[1:pos], line[pos+1:])
|
||||
else:
|
||||
cur_doc.append_to_description(line)
|
||||
else:
|
||||
cur_doc.append_to_description(line)
|
||||
|
||||
line = fp.readline()
|
||||
|
||||
def extract_tmpl(dirs, doc_dict=None):
|
||||
if not doc_dict: doc_dict = {}
|
||||
for dir in dirs:
|
||||
for file in os.listdir(dir):
|
||||
if file in ('.', '..'): continue
|
||||
path = os.path.join(dir, file)
|
||||
if os.path.isdir(path):
|
||||
continue
|
||||
if len(file) > 2 and file[-2:] == '.sgml':
|
||||
parse_tmpl(open(path, 'r'), doc_dict)
|
||||
return doc_dict
|
||||
|
|
@ -1,766 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
import getopt
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
import definitions
|
||||
import defsparser
|
||||
import docextract
|
||||
import override
|
||||
|
||||
|
||||
class Node:
|
||||
|
||||
def __init__(self, name, interfaces=[]):
|
||||
self.name = name
|
||||
self.interfaces = interfaces
|
||||
self.subclasses = []
|
||||
|
||||
def add_child(self, node):
|
||||
self.subclasses.append(node)
|
||||
|
||||
|
||||
def build_object_tree(parser):
|
||||
# reorder objects so that parent classes come first ...
|
||||
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
|
||||
|
||||
root = Node(None)
|
||||
nodes = {None: root}
|
||||
for obj_def in objects:
|
||||
parent_name = obj_def.parent
|
||||
if parent_name == 'GObject':
|
||||
parent_name = None
|
||||
parent_node = nodes[parent_name]
|
||||
node = Node(obj_def.c_name, obj_def.implements)
|
||||
parent_node.add_child(node)
|
||||
nodes[node.name] = node
|
||||
|
||||
if parser.interfaces:
|
||||
interfaces = Node('gobject.GInterface')
|
||||
root.add_child(interfaces)
|
||||
nodes[interfaces.name] = interfaces
|
||||
for obj_def in parser.interfaces:
|
||||
node = Node(obj_def.c_name)
|
||||
interfaces.add_child(node)
|
||||
nodes[node.name] = node
|
||||
|
||||
if parser.boxes:
|
||||
boxed = Node('gobject.GBoxed')
|
||||
root.add_child(boxed)
|
||||
nodes[boxed.name] = boxed
|
||||
for obj_def in parser.boxes:
|
||||
node = Node(obj_def.c_name)
|
||||
boxed.add_child(node)
|
||||
nodes[node.name] = node
|
||||
|
||||
if parser.pointers:
|
||||
pointers = Node('gobject.GPointer')
|
||||
root.add_child(pointers)
|
||||
nodes[pointers.name] = pointers
|
||||
for obj_def in parser.pointers:
|
||||
node = Node(obj_def.c_name)
|
||||
pointers.add_child(node)
|
||||
nodes[node.name] = node
|
||||
|
||||
return root
|
||||
|
||||
|
||||
class DocWriter:
|
||||
|
||||
def __init__(self):
|
||||
self._fp = None
|
||||
# parse the defs file
|
||||
self.parser = defsparser.DefsParser(())
|
||||
self.overrides = override.Overrides()
|
||||
self.classmap = {}
|
||||
self.docs = {}
|
||||
|
||||
def add_sourcedirs(self, source_dirs):
|
||||
self.docs = docextract.extract(source_dirs, self.docs)
|
||||
|
||||
def add_tmpldirs(self, tmpl_dirs):
|
||||
self.docs = docextract.extract_tmpl(tmpl_dirs, self.docs)
|
||||
|
||||
def add_docs(self, defs_file, overrides_file, module_name):
|
||||
'''parse information about a given defs file'''
|
||||
self.parser.filename = defs_file
|
||||
self.parser.startParsing(defs_file)
|
||||
if overrides_file:
|
||||
self.overrides.handle_file(overrides_file)
|
||||
|
||||
for obj in (self.parser.objects + self.parser.interfaces +
|
||||
self.parser.boxes + self.parser.pointers):
|
||||
if not obj.c_name in self.classmap:
|
||||
self.classmap[obj.c_name] = '%s.%s' % (
|
||||
module_name, obj.name)
|
||||
|
||||
def pyname(self, name):
|
||||
return self.classmap.get(name, name)
|
||||
|
||||
def _compare(self, obja, objb):
|
||||
return cmp(self.pyname(obja.c_name), self.pyname(objb.c_name))
|
||||
|
||||
def output_docs(self, output_prefix):
|
||||
files = {}
|
||||
|
||||
# class hierarchy
|
||||
hierarchy = build_object_tree(self.parser)
|
||||
filename = self.create_filename('hierarchy', output_prefix)
|
||||
self._fp = open(filename, 'w')
|
||||
self.write_full_hierarchy(hierarchy)
|
||||
self._fp.close()
|
||||
|
||||
obj_defs = (self.parser.objects + self.parser.interfaces +
|
||||
self.parser.boxes + self.parser.pointers)
|
||||
obj_defs.sort(self._compare)
|
||||
|
||||
for obj_def in obj_defs:
|
||||
filename = self.create_filename(obj_def.c_name, output_prefix)
|
||||
self._fp = open(filename, 'w')
|
||||
if isinstance(obj_def, definitions.ObjectDef):
|
||||
self.output_object_docs(obj_def)
|
||||
elif isinstance(obj_def, definitions.InterfaceDef):
|
||||
self.output_interface_docs(obj_def)
|
||||
elif isinstance(obj_def, definitions.BoxedDef):
|
||||
self.output_boxed_docs(obj_def)
|
||||
elif isinstance(obj_def, definitions.PointerDef):
|
||||
self.output_boxed_docs(obj_def)
|
||||
self._fp.close()
|
||||
files[os.path.basename(filename)] = obj_def
|
||||
|
||||
if not files:
|
||||
return
|
||||
|
||||
output_filename = self.create_toc_filename(output_prefix)
|
||||
self._fp = open(output_filename, 'w')
|
||||
self.output_toc(files)
|
||||
self._fp.close()
|
||||
|
||||
def output_object_docs(self, obj_def):
|
||||
self.write_class_header(obj_def.c_name)
|
||||
|
||||
self.write_heading('Synopsis')
|
||||
self.write_synopsis(obj_def)
|
||||
self.close_section()
|
||||
|
||||
# construct the inheritence hierarchy ...
|
||||
ancestry = [(obj_def.c_name, obj_def.implements)]
|
||||
try:
|
||||
parent = obj_def.parent
|
||||
while parent != None:
|
||||
if parent == 'GObject':
|
||||
ancestry.append(('GObject', []))
|
||||
parent = None
|
||||
else:
|
||||
parent_def = self.parser.find_object(parent)
|
||||
ancestry.append((parent_def.c_name, parent_def.implements))
|
||||
parent = parent_def.parent
|
||||
except ValueError:
|
||||
pass
|
||||
ancestry.reverse()
|
||||
self.write_heading('Ancestry')
|
||||
self.write_hierarchy(obj_def.c_name, ancestry)
|
||||
self.close_section()
|
||||
|
||||
constructor = self.parser.find_constructor(obj_def, self.overrides)
|
||||
if constructor:
|
||||
self.write_heading('Constructor')
|
||||
self.write_constructor(constructor,
|
||||
self.docs.get(constructor.c_name, None))
|
||||
self.close_section()
|
||||
|
||||
methods = self.parser.find_methods(obj_def)
|
||||
methods = filter(lambda meth, self=self:
|
||||
not self.overrides.is_ignored(meth.c_name), methods)
|
||||
if methods:
|
||||
self.write_heading('Methods')
|
||||
for method in methods:
|
||||
self.write_method(method, self.docs.get(method.c_name, None))
|
||||
self.close_section()
|
||||
|
||||
self.write_class_footer(obj_def.c_name)
|
||||
|
||||
def get_methods_for_object(self, obj_def):
|
||||
methods = []
|
||||
for method in self.parser.find_methods(obj_def):
|
||||
if not self.overrides.is_ignored(method.c_name):
|
||||
methods.append(method)
|
||||
return methods
|
||||
|
||||
def output_interface_docs(self, int_def):
|
||||
self.write_class_header(int_def.c_name)
|
||||
|
||||
self.write_heading('Synopsis')
|
||||
self.write_synopsis(int_def)
|
||||
self.close_section()
|
||||
|
||||
methods = self.get_methods_for_object(int_def)
|
||||
if methods:
|
||||
self.write_heading('Methods')
|
||||
for method in methods:
|
||||
self.write_method(method, self.docs.get(method.c_name, None))
|
||||
self.close_section()
|
||||
self.write_class_footer(int_def.c_name)
|
||||
|
||||
def output_boxed_docs(self, box_def):
|
||||
self.write_class_header(box_def.c_name)
|
||||
|
||||
self.write_heading('Synopsis')
|
||||
self.write_synopsis(box_def)
|
||||
self.close_section()
|
||||
|
||||
constructor = self.parser.find_constructor(box_def, self.overrides)
|
||||
if constructor:
|
||||
self.write_heading('Constructor')
|
||||
self.write_constructor(constructor,
|
||||
self.docs.get(constructor.c_name, None))
|
||||
self.close_section()
|
||||
|
||||
methods = self.get_methods_for_object(box_def)
|
||||
if methods:
|
||||
self.write_heading('Methods')
|
||||
for method in methods:
|
||||
self.write_method(method, self.docs.get(method.c_name, None))
|
||||
self.close_section()
|
||||
|
||||
self.write_class_footer(box_def.c_name)
|
||||
|
||||
def output_toc(self, files):
|
||||
self._fp.write('TOC\n\n')
|
||||
for filename in sorted(files):
|
||||
obj_def = files[filename]
|
||||
self._fp.write(obj_def.c_name + ' - ' + filename + '\n')
|
||||
|
||||
# override the following to create a more complex output format
|
||||
|
||||
def create_filename(self, obj_name, output_prefix):
|
||||
'''Create output filename for this particular object'''
|
||||
return output_prefix + '-' + obj_name.lower() + '.txt'
|
||||
|
||||
def create_toc_filename(self, output_prefix):
|
||||
return self.create_filename(self, 'docs', output_prefix)
|
||||
|
||||
def write_full_hierarchy(self, hierarchy):
|
||||
|
||||
def handle_node(node, indent=''):
|
||||
for child in node.subclasses:
|
||||
self._fp.write(indent + node.name)
|
||||
if node.interfaces:
|
||||
self._fp.write(' (implements ')
|
||||
self._fp.write(', '.join(node.interfaces))
|
||||
self._fp.write(')\n')
|
||||
else:
|
||||
self._fp.write('\n')
|
||||
handle_node(child, indent + ' ')
|
||||
handle_node(hierarchy)
|
||||
|
||||
def serialize_params(self, func_def):
|
||||
params = []
|
||||
for param in func_def.params:
|
||||
params.append(param[1])
|
||||
return ', '.join(params)
|
||||
|
||||
# these need to handle default args ...
|
||||
|
||||
def create_constructor_prototype(self, func_def):
|
||||
return '%s(%s)' % (func_def.is_constructor_of,
|
||||
self.serialize_params(func_def))
|
||||
|
||||
def create_function_prototype(self, func_def):
|
||||
return '%s(%s)' % (func_def.name,
|
||||
self.serialize_params(func_def))
|
||||
|
||||
def create_method_prototype(self, meth_def):
|
||||
return '%s.%s(%s)' % (meth_def.of_object,
|
||||
meth_def.name,
|
||||
self.serialize_params(meth_def))
|
||||
|
||||
def write_class_header(self, obj_name):
|
||||
self._fp.write('Class %s\n' % obj_name)
|
||||
self._fp.write('======%s\n\n' % ('=' * len(obj_name)))
|
||||
|
||||
def write_class_footer(self, obj_name):
|
||||
pass
|
||||
|
||||
def write_heading(self, text):
|
||||
self._fp.write('\n' + text + '\n' + ('-' * len(text)) + '\n')
|
||||
|
||||
def close_section(self):
|
||||
pass
|
||||
|
||||
def write_synopsis(self, obj_def):
|
||||
self._fp.write('class %s' % obj_def.c_name)
|
||||
if isinstance(obj_def, definitions.ObjectDef):
|
||||
bases = []
|
||||
if obj_def.parent:
|
||||
bases.append(obj_def.parent)
|
||||
bases = bases = obj_def.implements
|
||||
if bases:
|
||||
self._fp.write('(%s)' % ', '.join(bases, ))
|
||||
self._fp.write(':\n')
|
||||
|
||||
constructor = self.parser.find_constructor(obj_def, self.overrides)
|
||||
if constructor:
|
||||
prototype = self.create_constructor_prototype(constructor)
|
||||
self._fp.write(' def %s\n' % prototype)
|
||||
|
||||
for method in self.get_methods_for_object(obj_def):
|
||||
prototype = self.create_method_prototype(method)
|
||||
self._fp.write(' def %s\n' % prototype)
|
||||
|
||||
def write_hierarchy(self, obj_name, ancestry):
|
||||
indent = ''
|
||||
for name, interfaces in ancestry:
|
||||
self._fp.write(indent + '+-- ' + name)
|
||||
if interfaces:
|
||||
self._fp.write(' (implements ')
|
||||
self._fp.write(', '.join(interfaces))
|
||||
self._fp.write(')\n')
|
||||
else:
|
||||
self._fp.write('\n')
|
||||
indent = indent + ' '
|
||||
self._fp.write('\n')
|
||||
|
||||
def write_constructor(self, func_def, func_doc):
|
||||
prototype = self.create_constructor_prototype(func_def)
|
||||
self._fp.write(prototype + '\n\n')
|
||||
for type, name, dflt, null in func_def.params:
|
||||
self.write_parameter(name, func_doc)
|
||||
self.write_return_value(func_def, func_doc)
|
||||
if func_doc and func_doc.description:
|
||||
self._fp.write(func_doc.description)
|
||||
self._fp.write('\n\n\n')
|
||||
|
||||
def write_method(self, meth_def, func_doc):
|
||||
prototype = self.create_method_prototype(meth_def)
|
||||
self._fp.write(prototype + '\n\n')
|
||||
for type, name, dflt, null in meth_def.params:
|
||||
self.write_parameter(name, func_doc)
|
||||
self.write_return_value(meth_def, func_doc)
|
||||
if func_doc and func_doc.description:
|
||||
self._fp.write('\n')
|
||||
self._fp.write(func_doc.description)
|
||||
self._fp.write('\n\n')
|
||||
|
||||
def write_parameter(self, param_name, func_doc):
|
||||
if func_doc:
|
||||
descr = func_doc.get_param_description(param_name)
|
||||
else:
|
||||
descr = 'a ' + type
|
||||
self._fp.write(' ' + param_name + ': ' + descr + '\n')
|
||||
|
||||
def write_return_value(self, meth_def, func_doc):
|
||||
if meth_def.ret and meth_def.ret != 'none':
|
||||
if func_doc and func_doc.ret:
|
||||
descr = func_doc.ret
|
||||
else:
|
||||
descr = 'a ' + meth_def.ret
|
||||
self._fp.write(' Returns: ' + descr + '\n')
|
||||
|
||||
CLASS_HEADER_TEMPLATE = """<refentry id="%(entryid)s">
|
||||
<refmeta>
|
||||
<refentrytitle>%(name)s</refentrytitle>
|
||||
<manvolnum>3</manvolnum>
|
||||
<refmiscinfo>%(miscinfo)s</refmiscinfo>
|
||||
</refmeta>
|
||||
|
||||
<refnamediv>
|
||||
<refname>%(name)s</refname><refpurpose></refpurpose>
|
||||
</refnamediv>
|
||||
|
||||
"""
|
||||
VARIABLE_TEMPLATE = """<varlistentry>
|
||||
<term><parameter>%(parameter)s</parameter> :</term>
|
||||
<listitem><simpara>%(description)s</simpara></listitem>
|
||||
</varlistentry>
|
||||
"""
|
||||
|
||||
DOCBOOK_HEADER = """<?xml version="1.0" standalone="no"?>
|
||||
<!DOCTYPE synopsis PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
|
||||
"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd">
|
||||
"""
|
||||
|
||||
|
||||
class DocbookDocWriter(DocWriter):
|
||||
|
||||
def __init__(self):
|
||||
DocWriter.__init__(self)
|
||||
|
||||
self._function_pat = re.compile(r'(\w+)\s*\(\)')
|
||||
self._parameter_pat = re.compile(r'\@(\w+)')
|
||||
self._constant_pat = re.compile(r'\%(-?\w+)')
|
||||
self._symbol_pat = re.compile(r'#([\w-]+)')
|
||||
|
||||
self._transtable = ['-'] * 256
|
||||
# make string -> reference translation func
|
||||
for digit in '0123456789':
|
||||
self._transtable[ord(digit)] = digit
|
||||
|
||||
for letter in 'abcdefghijklmnopqrstuvwxyz':
|
||||
self._transtable[ord(letter)] = letter
|
||||
self._transtable[ord(letter.upper())] = letter
|
||||
self._transtable = ''.join(self._transtable)
|
||||
|
||||
def create_filename(self, obj_name, output_prefix):
|
||||
'''Create output filename for this particular object'''
|
||||
stem = output_prefix + '-' + obj_name.lower()
|
||||
return stem + '.xml'
|
||||
|
||||
def create_toc_filename(self, output_prefix):
|
||||
return self.create_filename('classes', output_prefix)
|
||||
|
||||
def make_class_ref(self, obj_name):
|
||||
return 'class-' + obj_name.translate(self._transtable)
|
||||
|
||||
def make_method_ref(self, meth_def):
|
||||
return 'method-%s--%s' % (
|
||||
meth_def.of_object.translate(self._transtable),
|
||||
meth_def.name.translate(self._transtable))
|
||||
|
||||
def _format_function(self, match):
|
||||
info = self.parser.c_name.get(match.group(1), None)
|
||||
if info:
|
||||
if isinstance(info, defsparser.FunctionDef):
|
||||
return self._format_funcdef(info)
|
||||
if isinstance(info, defsparser.MethodDef):
|
||||
return self._format_method(info)
|
||||
|
||||
# fall through through
|
||||
return '<function>%s()</function>' % (match.group(1), )
|
||||
|
||||
def _format_funcdef(self, info):
|
||||
if info.is_constructor_of is not None:
|
||||
# should have a link here
|
||||
return '<methodname>%s()</methodname>' % (
|
||||
self.pyname(info.is_constructor_of), )
|
||||
else:
|
||||
return '<function>%s()</function>' % (info.name, )
|
||||
|
||||
def _format_param(self, match):
|
||||
return '<parameter>%s</parameterdliteral>' % (match.group(1), )
|
||||
|
||||
def _format_const(self, match):
|
||||
return '<literal>%s</literal>' % (match.group(1), )
|
||||
|
||||
def _format_method(self, info):
|
||||
return ('<link linkend="%s">'
|
||||
'<methodname>%s.%s</methodname>'
|
||||
'</link>') % (self.make_method_ref(info),
|
||||
self.pyname(info.of_object),
|
||||
info.name)
|
||||
|
||||
def _format_object(self, info):
|
||||
return ('<link linkend="%s">'
|
||||
'<classname>%s</classname>'
|
||||
'</link>') % (self.make_class_ref(info.c_name),
|
||||
self.pyname(info.c_name))
|
||||
|
||||
def _format_symbol(self, match):
|
||||
info = self.parser.c_name.get(match.group(1), None)
|
||||
if info:
|
||||
if isinstance(info, defsparser.FunctionDef):
|
||||
return self._format_funcdef(info)
|
||||
elif isinstance(info, defsparser.MethodDef):
|
||||
return self._format_method(info)
|
||||
elif isinstance(info, (defsparser.ObjectDef,
|
||||
defsparser.InterfaceDef,
|
||||
defsparser.BoxedDef,
|
||||
defsparser.PointerDef)):
|
||||
return self._format_object(info)
|
||||
|
||||
# fall through through
|
||||
return '<literal>%s</literal>' % (match.group(1), )
|
||||
|
||||
def reformat_text(self, text, singleline=0):
|
||||
# replace special strings ...
|
||||
text = self._function_pat.sub(self._format_function, text)
|
||||
text = self._parameter_pat.sub(self._format_param, text)
|
||||
text = self._constant_pat.sub(self._format_const, text)
|
||||
text = self._symbol_pat.sub(self._format_symbol, text)
|
||||
|
||||
# don't bother with <para> expansion for single line text.
|
||||
if singleline:
|
||||
return text
|
||||
|
||||
lines = text.strip().split('\n')
|
||||
for index in range(len(lines)):
|
||||
if lines[index].strip() == '':
|
||||
lines[index] = '</para>\n<para>'
|
||||
continue
|
||||
return '<para>%s</para>' % ('\n'.join(lines), )
|
||||
|
||||
# write out hierarchy
|
||||
|
||||
def write_full_hierarchy(self, hierarchy):
|
||||
|
||||
def handle_node(node, indent=''):
|
||||
if node.name:
|
||||
self._fp.write('%s<link linkend="%s">%s</link>' %
|
||||
(indent, self.make_class_ref(node.name),
|
||||
self.pyname(node.name)))
|
||||
if node.interfaces:
|
||||
self._fp.write(' (implements ')
|
||||
for i in range(len(node.interfaces)):
|
||||
self._fp.write('<link linkend="%s">%s</link>' %
|
||||
(self.make_class_ref(node.interfaces[i]),
|
||||
self.pyname(node.interfaces[i])))
|
||||
if i != len(node.interfaces) - 1:
|
||||
self._fp.write(', ')
|
||||
self._fp.write(')\n')
|
||||
else:
|
||||
self._fp.write('\n')
|
||||
|
||||
indent = indent + ' '
|
||||
node.subclasses.sort(lambda a, b:
|
||||
cmp(self.pyname(a.name), self.pyname(b.name)))
|
||||
for child in node.subclasses:
|
||||
handle_node(child, indent)
|
||||
|
||||
self._fp.write(DOCBOOK_HEADER)
|
||||
self._fp.write('<synopsis>')
|
||||
handle_node(hierarchy)
|
||||
self._fp.write('</synopsis>\n')
|
||||
|
||||
# these need to handle default args ...
|
||||
|
||||
def create_constructor_prototype(self, func_def):
|
||||
xml = ['<constructorsynopsis language="python">\n']
|
||||
xml.append(' <methodname>__init__</methodname>\n')
|
||||
for type, name, dflt, null in func_def.params:
|
||||
xml.append(' <methodparam><parameter>')
|
||||
xml.append(name)
|
||||
xml.append('</parameter>')
|
||||
if dflt:
|
||||
xml.append('<initializer>')
|
||||
xml.append(dflt)
|
||||
xml.append('</initializer>')
|
||||
xml.append('</methodparam>\n')
|
||||
if not func_def.params:
|
||||
xml.append(' <methodparam></methodparam>')
|
||||
xml.append(' </constructorsynopsis>')
|
||||
return ''.join(xml)
|
||||
|
||||
def create_function_prototype(self, func_def):
|
||||
xml = ['<funcsynopsis language="python">\n <funcprototype>\n']
|
||||
xml.append(' <funcdef><function>')
|
||||
xml.append(func_def.name)
|
||||
xml.append('</function></funcdef>\n')
|
||||
for type, name, dflt, null in func_def.params:
|
||||
xml.append(' <paramdef><parameter>')
|
||||
xml.append(name)
|
||||
xml.append('</parameter>')
|
||||
if dflt:
|
||||
xml.append('<initializer>')
|
||||
xml.append(dflt)
|
||||
xml.append('</initializer>')
|
||||
xml.append('</paramdef>\n')
|
||||
if not func_def.params:
|
||||
xml.append(' <paramdef></paramdef')
|
||||
xml.append(' </funcprototype>\n </funcsynopsis>')
|
||||
return ''.join(xml)
|
||||
|
||||
def create_method_prototype(self, meth_def, addlink=0):
|
||||
xml = ['<methodsynopsis language="python">\n']
|
||||
xml.append(' <methodname>')
|
||||
if addlink:
|
||||
xml.append('<link linkend="%s">' % self.make_method_ref(meth_def))
|
||||
xml.append(self.pyname(meth_def.name))
|
||||
if addlink:
|
||||
xml.append('</link>')
|
||||
xml.append('</methodname>\n')
|
||||
for type, name, dflt, null in meth_def.params:
|
||||
xml.append(' <methodparam><parameter>')
|
||||
xml.append(name)
|
||||
xml.append('</parameter>')
|
||||
if dflt:
|
||||
xml.append('<initializer>')
|
||||
xml.append(dflt)
|
||||
xml.append('</initializer>')
|
||||
xml.append('</methodparam>\n')
|
||||
if not meth_def.params:
|
||||
xml.append(' <methodparam></methodparam>')
|
||||
xml.append(' </methodsynopsis>')
|
||||
return ''.join(xml)
|
||||
|
||||
def write_class_header(self, obj_name):
|
||||
self._fp.write(DOCBOOK_HEADER)
|
||||
self._fp.write(CLASS_HEADER_TEMPLATE % dict(
|
||||
entryid=self.make_class_ref(obj_name),
|
||||
name=self.pyname(obj_name),
|
||||
miscinfo="PyGTK Docs"))
|
||||
|
||||
def write_class_footer(self, obj_name):
|
||||
self._fp.write('</refentry>\n')
|
||||
|
||||
def write_heading(self, text):
|
||||
self._fp.write(' <refsect1>\n')
|
||||
self._fp.write(' <title>' + text + '</title>\n\n')
|
||||
|
||||
def close_section(self):
|
||||
self._fp.write(' </refsect1>\n')
|
||||
|
||||
def write_synopsis(self, obj_def):
|
||||
self._fp.write('<classsynopsis language="python">\n')
|
||||
self._fp.write(' <ooclass><classname>%s</classname></ooclass>\n'
|
||||
% self.pyname(obj_def.c_name))
|
||||
if isinstance(obj_def, definitions.ObjectDef):
|
||||
if obj_def.parent:
|
||||
self._fp.write(' <ooclass><classname><link linkend="%s">%s'
|
||||
'</link></classname></ooclass>\n'
|
||||
% (self.make_class_ref(obj_def.parent),
|
||||
self.pyname(obj_def.parent)))
|
||||
for base in obj_def.implements:
|
||||
self._fp.write(' <ooclass><classname><link linkend="%s">%s'
|
||||
'</link></classname></ooclass>\n'
|
||||
% (self.make_class_ref(base), self.pyname(base)))
|
||||
elif isinstance(obj_def, definitions.InterfaceDef):
|
||||
self._fp.write(' <ooclass><classname>gobject.GInterface'
|
||||
'</classname></ooclass>\n')
|
||||
elif isinstance(obj_def, definitions.BoxedDef):
|
||||
self._fp.write(' <ooclass><classname>gobject.GBoxed'
|
||||
'</classname></ooclass>\n')
|
||||
elif isinstance(obj_def, definitions.PointerDef):
|
||||
self._fp.write(' <ooclass><classname>gobject.GPointer'
|
||||
'</classname></ooclass>\n')
|
||||
|
||||
constructor = self.parser.find_constructor(obj_def, self.overrides)
|
||||
if constructor:
|
||||
self._fp.write(
|
||||
'%s\n' % self.create_constructor_prototype(constructor))
|
||||
for method in self.get_methods_for_object(obj_def):
|
||||
self._fp.write(
|
||||
'%s\n' % self.create_method_prototype(method, addlink=1))
|
||||
self._fp.write('</classsynopsis>\n\n')
|
||||
|
||||
def write_hierarchy(self, obj_name, ancestry):
|
||||
self._fp.write('<synopsis>')
|
||||
indent = ''
|
||||
for name, interfaces in ancestry:
|
||||
self._fp.write(
|
||||
'%s+-- <link linkend="%s">%s</link>' %
|
||||
(indent, self.make_class_ref(name), self.pyname(name)))
|
||||
if interfaces:
|
||||
self._fp.write(' (implements ')
|
||||
for i in range(len(interfaces)):
|
||||
self._fp.write('<link linkend="%s">%s</link>' %
|
||||
(self.make_class_ref(interfaces[i]),
|
||||
self.pyname(interfaces[i])))
|
||||
if i != len(interfaces) - 1:
|
||||
self._fp.write(', ')
|
||||
self._fp.write(')\n')
|
||||
else:
|
||||
self._fp.write('\n')
|
||||
indent = indent + ' '
|
||||
self._fp.write('</synopsis>\n\n')
|
||||
|
||||
def write_params(self, params, ret, func_doc):
|
||||
if not params and (not ret or ret == 'none'):
|
||||
return
|
||||
self._fp.write(' <variablelist>\n')
|
||||
for type, name, dflt, null in params:
|
||||
if func_doc:
|
||||
descr = func_doc.get_param_description(name).strip()
|
||||
else:
|
||||
descr = 'a ' + type
|
||||
self._fp.write(VARIABLE_TEMPLATE % dict(
|
||||
parameter=name,
|
||||
description=self.reformat_text(descr, singleline=1)))
|
||||
if ret and ret != 'none':
|
||||
if func_doc and func_doc.ret:
|
||||
descr = func_doc.ret.strip()
|
||||
else:
|
||||
descr = 'a ' + ret
|
||||
self._fp.write(VARIABLE_TEMPLATE % dict(
|
||||
parameter='Returns',
|
||||
description=self.reformat_text(descr, singleline=1)))
|
||||
self._fp.write(' </variablelist>\n')
|
||||
|
||||
def write_constructor(self, func_def, func_doc):
|
||||
prototype = self.create_constructor_prototype(func_def)
|
||||
self._fp.write('<programlisting>%s</programlisting>\n' % prototype)
|
||||
self.write_params(func_def.params, func_def.ret, func_doc)
|
||||
|
||||
if func_doc and func_doc.description:
|
||||
self._fp.write(self.reformat_text(func_doc.description))
|
||||
self._fp.write('\n\n\n')
|
||||
|
||||
def write_method(self, meth_def, func_doc):
|
||||
self._fp.write(' <refsect2 id="%s">\n' % (
|
||||
self.make_method_ref(meth_def), ))
|
||||
self._fp.write(' <title>%s.%s</title>\n\n' % (
|
||||
self.pyname(meth_def.of_object),
|
||||
meth_def.name))
|
||||
prototype = self.create_method_prototype(meth_def)
|
||||
self._fp.write('<programlisting>%s</programlisting>\n' % prototype)
|
||||
self.write_params(meth_def.params, meth_def.ret, func_doc)
|
||||
if func_doc and func_doc.description:
|
||||
self._fp.write(self.reformat_text(func_doc.description))
|
||||
self._fp.write(' </refsect2>\n\n\n')
|
||||
|
||||
def output_toc(self, files, fp=sys.stdout):
|
||||
self._fp.write(DOCBOOK_HEADER)
|
||||
|
||||
#self._fp.write('<reference id="class-reference">\n')
|
||||
#self._fp.write(' <title>Class Documentation</title>\n')
|
||||
#for filename, obj_def in files:
|
||||
# self._fp.write('&' +
|
||||
# obj_def.c_name.translate(self._transtable) + ';\n')
|
||||
#self._fp.write('</reference>\n')
|
||||
|
||||
self._fp.write('<reference id="class-reference" '
|
||||
'xmlns:xi="http://www.w3.org/2001/XInclude">\n')
|
||||
self._fp.write(' <title>Class Reference</title>\n')
|
||||
for filename in sorted(files):
|
||||
self._fp.write(' <xi:include href="%s"/>\n' % filename)
|
||||
self._fp.write('</reference>\n')
|
||||
|
||||
|
||||
def main(args):
|
||||
try:
|
||||
opts, args = getopt.getopt(args[1:], "d:s:o:",
|
||||
["defs-file=", "override=", "source-dir=",
|
||||
"output-prefix="])
|
||||
except getopt.error, e:
|
||||
sys.stderr.write('docgen.py: %s\n' % e)
|
||||
sys.stderr.write(
|
||||
'usage: docgen.py -d file.defs [-s /src/dir] [-o output-prefix]\n')
|
||||
return 1
|
||||
|
||||
defs_file = None
|
||||
overrides_file = None
|
||||
source_dirs = []
|
||||
output_prefix = 'docs'
|
||||
for opt, arg in opts:
|
||||
if opt in ('-d', '--defs-file'):
|
||||
defs_file = arg
|
||||
if opt in ('--override', ):
|
||||
overrides_file = arg
|
||||
elif opt in ('-s', '--source-dir'):
|
||||
source_dirs.append(arg)
|
||||
elif opt in ('-o', '--output-prefix'):
|
||||
output_prefix = arg
|
||||
if len(args) != 0 or not defs_file:
|
||||
sys.stderr.write(
|
||||
'usage: docgen.py -d file.defs [-s /src/dir] [-o output-prefix]\n')
|
||||
return 1
|
||||
|
||||
d = DocbookDocWriter()
|
||||
d.add_sourcedirs(source_dirs)
|
||||
d.add_docs(defs_file, overrides_file, 'gio')
|
||||
d.output_docs(output_prefix)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main(sys.argv))
|
||||
|
|
@ -1,637 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
# GPL'ed
|
||||
# Toby D. Reeves <toby@max.rl.plh.af.mil>
|
||||
#
|
||||
# Modified by James Henstridge <james@daa.com.au> to output stuff in
|
||||
# Havoc's new defs format. Info on this format can be seen at:
|
||||
# http://mail.gnome.org/archives/gtk-devel-list/2000-January/msg00070.html
|
||||
# Updated to be PEP-8 compatible and refactored to use OOP
|
||||
#
|
||||
# Scan the given public .h files of a GTK module (or module using
|
||||
# GTK object conventions) and generates a set of scheme defs.
|
||||
#
|
||||
# h2def searches through a header file looking for function prototypes and
|
||||
# generates a scheme style defenition for each prototype.
|
||||
# Basically the operation of h2def is:
|
||||
#
|
||||
# - read each .h file into a buffer which is scrubbed of extraneous data
|
||||
# - find all object defenitions:
|
||||
# - find all structures that may represent a GtkObject
|
||||
# - find all structures that might represent a class
|
||||
# - find all structures that may represent a GtkObject subclass
|
||||
# - find all structures that might represent a class/Iface inherited from
|
||||
# GTypeInterface
|
||||
# - find all enum defenitions
|
||||
# - write out the defs
|
||||
#
|
||||
# The command line options are:
|
||||
#
|
||||
# -s --separate Create separate files for objects and function/method defs
|
||||
# using the given name as the base name (optional). If this
|
||||
# is not specified the combined object and function defs
|
||||
# will be output to sys.stdout.
|
||||
# -f --defsfilter Extract defs from the given file to filter the output defs
|
||||
# that is don't output defs that are defined in the
|
||||
# defsfile. More than one deffile may be specified.
|
||||
# -m --modulename The prefix to be stripped from the front of function names
|
||||
# for the given module
|
||||
# -n --namespace The module or namespace name to be used, for example
|
||||
# WebKit where h2def is unable to detect the module name
|
||||
# automatically. it also sets the gtype-id prefix.
|
||||
# --onlyenums Only produce defs for enums and flags
|
||||
# --onlyobjdefs Only produce defs for objects
|
||||
# -v Verbose output
|
||||
#
|
||||
# Examples:
|
||||
#
|
||||
# python h2def.py /usr/local/include/pango-1.0/pango/*.h >/tmp/pango.defs
|
||||
#
|
||||
# - Outputs all defs for the pango module.
|
||||
#
|
||||
# python h2def.py -m gdk -s /tmp/gdk-2.10 \
|
||||
# -f /usr/tmp/pygtk/gtk/gdk-base.defs \
|
||||
# /usr/local/include/gtk-2.0/gdk/*.h \
|
||||
# /usr/local/include/gtk-2.0/gdk-pixbuf/*.h
|
||||
#
|
||||
# - Outputs the gdk module defs that are not contained in the defs file
|
||||
# /usr/tmp/pygtk/gtk/gdk-base.defs. Two output files are created:
|
||||
# /tmp/gdk-2.10-types.defs and /tmp/gdk-2.10.defs.
|
||||
#
|
||||
# python h2def.py -n WebKit /usr/incude/webkit-1.0/webkit/*.h \
|
||||
# >/tmp/webkit.defs
|
||||
#
|
||||
# - Outputs all the defs for webkit module, setting the module name to WebKit
|
||||
# and the gtype-id prefix to WEBKIT_ which can't be detected automatically.
|
||||
#
|
||||
|
||||
import getopt
|
||||
import os
|
||||
import re
|
||||
import string
|
||||
import sys
|
||||
|
||||
import defsparser
|
||||
|
||||
# ------------------ Create typecodes from typenames ---------
|
||||
|
||||
_upperstr_pat1 = re.compile(r'([^A-Z])([A-Z])')
|
||||
_upperstr_pat2 = re.compile(r'([A-Z][A-Z])([A-Z][0-9a-z])')
|
||||
_upperstr_pat3 = re.compile(r'^([A-Z])([A-Z])')
|
||||
|
||||
def to_upper_str(name):
|
||||
"""Converts a typename to the equivalent upercase and underscores
|
||||
name. This is used to form the type conversion macros and enum/flag
|
||||
name variables"""
|
||||
name = _upperstr_pat1.sub(r'\1_\2', name)
|
||||
name = _upperstr_pat2.sub(r'\1_\2', name)
|
||||
name = _upperstr_pat3.sub(r'\1_\2', name, count=1)
|
||||
return string.upper(name)
|
||||
|
||||
def typecode(typename, namespace=None):
|
||||
"""create a typecode (eg. GTK_TYPE_WIDGET) from a typename"""
|
||||
if namespace:
|
||||
return string.replace(string.upper(namespace) + "_" + to_upper_str(typename[len(namespace):]), '_', '_TYPE_', 1)
|
||||
|
||||
return string.replace(to_upper_str(typename), '_', '_TYPE_', 1)
|
||||
|
||||
|
||||
# ------------------ Find object definitions -----------------
|
||||
# Strips the comments from buffer
|
||||
def strip_comments(buf):
|
||||
parts = []
|
||||
lastpos = 0
|
||||
while 1:
|
||||
pos = string.find(buf, '/*', lastpos)
|
||||
if pos >= 0:
|
||||
parts.append(buf[lastpos:pos])
|
||||
pos = string.find(buf, '*/', pos)
|
||||
if pos >= 0:
|
||||
lastpos = pos + 2
|
||||
else:
|
||||
break
|
||||
else:
|
||||
parts.append(buf[lastpos:])
|
||||
break
|
||||
return string.join(parts, '')
|
||||
|
||||
# Strips the dll API from buffer, for example WEBKIT_API
|
||||
def strip_dll_api(buf):
|
||||
pat = re.compile("[A-Z]*_API ")
|
||||
buf = pat.sub("", buf)
|
||||
return buf
|
||||
|
||||
obj_name_pat = "[A-Z][a-z]*[A-Z][A-Za-z0-9]*"
|
||||
|
||||
split_prefix_pat = re.compile('([A-Z]+[a-z]*)([A-Za-z0-9]+)')
|
||||
|
||||
def find_obj_defs(buf, objdefs=[]):
|
||||
"""
|
||||
Try to find object definitions in header files.
|
||||
"""
|
||||
|
||||
# filter out comments from buffer.
|
||||
buf = strip_comments(buf)
|
||||
|
||||
# filter out dll api
|
||||
buf = strip_dll_api(buf)
|
||||
|
||||
maybeobjdefs = [] # contains all possible objects from file
|
||||
|
||||
# first find all structures that look like they may represent a GtkObject
|
||||
pat = re.compile("struct\s+_(" + obj_name_pat + ")\s*{\s*" +
|
||||
"(" + obj_name_pat + ")\s+", re.MULTILINE)
|
||||
pos = 0
|
||||
while pos < len(buf):
|
||||
m = pat.search(buf, pos)
|
||||
if not m: break
|
||||
maybeobjdefs.append((m.group(1), m.group(2)))
|
||||
pos = m.end()
|
||||
|
||||
# handle typedef struct { ... } style struct defs.
|
||||
pat = re.compile("typedef struct\s+[_\w]*\s*{\s*" +
|
||||
"(" + obj_name_pat + ")\s+[^}]*}\s*" +
|
||||
"(" + obj_name_pat + ")\s*;", re.MULTILINE)
|
||||
pos = 0
|
||||
while pos < len(buf):
|
||||
m = pat.search(buf, pos)
|
||||
if not m: break
|
||||
maybeobjdefs.append((m.group(2), m.group(1)))
|
||||
pos = m.end()
|
||||
|
||||
# now find all structures that look like they might represent a class:
|
||||
pat = re.compile("struct\s+_(" + obj_name_pat + ")Class\s*{\s*" +
|
||||
"(" + obj_name_pat + ")Class\s+", re.MULTILINE)
|
||||
pos = 0
|
||||
while pos < len(buf):
|
||||
m = pat.search(buf, pos)
|
||||
if not m: break
|
||||
t = (m.group(1), m.group(2))
|
||||
# if we find an object structure together with a corresponding
|
||||
# class structure, then we have probably found a GtkObject subclass.
|
||||
if t in maybeobjdefs:
|
||||
objdefs.append(t)
|
||||
pos = m.end()
|
||||
|
||||
pat = re.compile("typedef struct\s+[_\w]*\s*{\s*" +
|
||||
"(" + obj_name_pat + ")Class\s+[^}]*}\s*" +
|
||||
"(" + obj_name_pat + ")Class\s*;", re.MULTILINE)
|
||||
pos = 0
|
||||
while pos < len(buf):
|
||||
m = pat.search(buf, pos)
|
||||
if not m: break
|
||||
t = (m.group(2), m.group(1))
|
||||
# if we find an object structure together with a corresponding
|
||||
# class structure, then we have probably found a GtkObject subclass.
|
||||
if t in maybeobjdefs:
|
||||
objdefs.append(t)
|
||||
pos = m.end()
|
||||
|
||||
# now find all structures that look like they might represent
|
||||
# a class inherited from GTypeInterface:
|
||||
pat = re.compile("struct\s+_(" + obj_name_pat + ")Class\s*{\s*" +
|
||||
"GTypeInterface\s+", re.MULTILINE)
|
||||
pos = 0
|
||||
while pos < len(buf):
|
||||
m = pat.search(buf, pos)
|
||||
if not m: break
|
||||
t = (m.group(1), '')
|
||||
t2 = (m.group(1)+'Class', 'GTypeInterface')
|
||||
# if we find an object structure together with a corresponding
|
||||
# class structure, then we have probably found a GtkObject subclass.
|
||||
if t2 in maybeobjdefs:
|
||||
objdefs.append(t)
|
||||
pos = m.end()
|
||||
|
||||
# now find all structures that look like they might represent
|
||||
# an Iface inherited from GTypeInterface:
|
||||
pat = re.compile("struct\s+_(" + obj_name_pat + ")Iface\s*{\s*" +
|
||||
"GTypeInterface\s+", re.MULTILINE)
|
||||
pos = 0
|
||||
while pos < len(buf):
|
||||
m = pat.search(buf, pos)
|
||||
if not m: break
|
||||
t = (m.group(1), '')
|
||||
t2 = (m.group(1)+'Iface', 'GTypeInterface')
|
||||
# if we find an object structure together with a corresponding
|
||||
# class structure, then we have probably found a GtkObject subclass.
|
||||
if t2 in maybeobjdefs:
|
||||
objdefs.append(t)
|
||||
pos = m.end()
|
||||
|
||||
def sort_obj_defs(objdefs):
|
||||
objdefs.sort() # not strictly needed, but looks nice
|
||||
pos = 0
|
||||
while pos < len(objdefs):
|
||||
klass,parent = objdefs[pos]
|
||||
for i in range(pos+1, len(objdefs)):
|
||||
# parent below subclass ... reorder
|
||||
if objdefs[i][0] == parent:
|
||||
objdefs.insert(i+1, objdefs[pos])
|
||||
del objdefs[pos]
|
||||
break
|
||||
else:
|
||||
pos = pos + 1
|
||||
return objdefs
|
||||
|
||||
# ------------------ Find enum definitions -----------------
|
||||
|
||||
def find_enum_defs(buf, enums=[]):
|
||||
# strip comments
|
||||
# bulk comments
|
||||
buf = strip_comments(buf)
|
||||
|
||||
# strip dll api macros
|
||||
buf = strip_dll_api(buf)
|
||||
|
||||
# strip # directives
|
||||
pat = re.compile(r"""^[#].*?$""", re.MULTILINE)
|
||||
buf = pat.sub('', buf)
|
||||
|
||||
buf = re.sub('\n', ' ', buf)
|
||||
|
||||
enum_pat = re.compile(r'enum\s*{([^}]*)}\s*([A-Z][A-Za-z]*)(\s|;)')
|
||||
splitter = re.compile(r'\s*,\s', re.MULTILINE)
|
||||
pos = 0
|
||||
while pos < len(buf):
|
||||
m = enum_pat.search(buf, pos)
|
||||
if not m: break
|
||||
|
||||
name = m.group(2)
|
||||
vals = m.group(1)
|
||||
isflags = string.find(vals, '<<') >= 0
|
||||
entries = []
|
||||
for val in splitter.split(vals):
|
||||
if not string.strip(val): continue
|
||||
entries.append(string.split(val)[0])
|
||||
if name != 'GdkCursorType':
|
||||
enums.append((name, isflags, entries))
|
||||
|
||||
pos = m.end()
|
||||
|
||||
# ------------------ Find function definitions -----------------
|
||||
|
||||
def clean_func(buf):
|
||||
"""
|
||||
Ideally would make buf have a single prototype on each line.
|
||||
Actually just cuts out a good deal of junk, but leaves lines
|
||||
where a regex can figure prototypes out.
|
||||
"""
|
||||
# bulk comments
|
||||
buf = strip_comments(buf)
|
||||
|
||||
# dll api
|
||||
buf = strip_dll_api(buf)
|
||||
|
||||
# compact continued lines
|
||||
pat = re.compile(r"""\\\n""", re.MULTILINE)
|
||||
buf = pat.sub('', buf)
|
||||
|
||||
# Preprocess directives
|
||||
pat = re.compile(r"""^[#].*?$""", re.MULTILINE)
|
||||
buf = pat.sub('', buf)
|
||||
|
||||
#typedefs, stucts, and enums
|
||||
pat = re.compile(r"""^(typedef|struct|enum)(\s|.|\n)*?;\s*""",
|
||||
re.MULTILINE)
|
||||
buf = pat.sub('', buf)
|
||||
|
||||
#strip DECLS macros
|
||||
pat = re.compile(r"""G_BEGIN_DECLS|BEGIN_LIBGTOP_DECLS""", re.MULTILINE)
|
||||
buf = pat.sub('', buf)
|
||||
|
||||
#extern "C"
|
||||
pat = re.compile(r"""^\s*(extern)\s+\"C\"\s+{""", re.MULTILINE)
|
||||
buf = pat.sub('', buf)
|
||||
|
||||
#multiple whitespace
|
||||
pat = re.compile(r"""\s+""", re.MULTILINE)
|
||||
buf = pat.sub(' ', buf)
|
||||
|
||||
#clean up line ends
|
||||
pat = re.compile(r""";\s*""", re.MULTILINE)
|
||||
buf = pat.sub('\n', buf)
|
||||
buf = buf.lstrip()
|
||||
|
||||
#associate *, &, and [] with type instead of variable
|
||||
#pat = re.compile(r'\s+([*|&]+)\s*(\w+)')
|
||||
pat = re.compile(r' \s* ([*|&]+) \s* (\w+)', re.VERBOSE)
|
||||
buf = pat.sub(r'\1 \2', buf)
|
||||
pat = re.compile(r'\s+ (\w+) \[ \s* \]', re.VERBOSE)
|
||||
buf = pat.sub(r'[] \1', buf)
|
||||
|
||||
# make return types that are const work.
|
||||
buf = re.sub(r'\s*\*\s*G_CONST_RETURN\s*\*\s*', '** ', buf)
|
||||
buf = string.replace(buf, 'G_CONST_RETURN ', 'const-')
|
||||
buf = string.replace(buf, 'const ', 'const-')
|
||||
|
||||
#strip GSEAL macros from the middle of function declarations:
|
||||
pat = re.compile(r"""GSEAL""", re.VERBOSE)
|
||||
buf = pat.sub('', buf)
|
||||
|
||||
return buf
|
||||
|
||||
proto_pat=re.compile(r"""
|
||||
(?P<ret>(-|\w|\&|\*)+\s*) # return type
|
||||
\s+ # skip whitespace
|
||||
(?P<func>\w+)\s*[(] # match the function name until the opening (
|
||||
\s*(?P<args>.*?)\s*[)] # group the function arguments
|
||||
""", re.IGNORECASE|re.VERBOSE)
|
||||
#"""
|
||||
arg_split_pat = re.compile("\s*,\s*")
|
||||
|
||||
get_type_pat = re.compile(r'(const-)?([A-Za-z0-9]+)\*?\s+')
|
||||
pointer_pat = re.compile('.*\*$')
|
||||
func_new_pat = re.compile('(\w+)_new$')
|
||||
|
||||
class DefsWriter:
|
||||
def __init__(self, fp=None, prefix=None, ns=None, verbose=False,
|
||||
defsfilter=None):
|
||||
if not fp:
|
||||
fp = sys.stdout
|
||||
|
||||
self.fp = fp
|
||||
self.prefix = prefix
|
||||
self.namespace = ns
|
||||
self.verbose = verbose
|
||||
|
||||
self._enums = {}
|
||||
self._objects = {}
|
||||
self._functions = {}
|
||||
if defsfilter:
|
||||
filter = defsparser.DefsParser(defsfilter)
|
||||
filter.startParsing()
|
||||
for func in filter.functions + filter.methods.values():
|
||||
self._functions[func.c_name] = func
|
||||
for obj in filter.objects + filter.boxes + filter.interfaces:
|
||||
self._objects[obj.c_name] = obj
|
||||
for obj in filter.enums:
|
||||
self._enums[obj.c_name] = obj
|
||||
|
||||
def write_def(self, deffile):
|
||||
buf = open(deffile).read()
|
||||
|
||||
self.fp.write('\n;; From %s\n\n' % os.path.basename(deffile))
|
||||
self._define_func(buf)
|
||||
self.fp.write('\n')
|
||||
|
||||
def write_enum_defs(self, enums, fp=None):
|
||||
if not fp:
|
||||
fp = self.fp
|
||||
|
||||
fp.write(';; Enumerations and flags ...\n\n')
|
||||
trans = string.maketrans(string.uppercase + '_',
|
||||
string.lowercase + '-')
|
||||
filter = self._enums
|
||||
for cname, isflags, entries in enums:
|
||||
if filter:
|
||||
if cname in filter:
|
||||
continue
|
||||
name = cname
|
||||
module = None
|
||||
if self.namespace:
|
||||
module = self.namespace
|
||||
name = cname[len(self.namespace):]
|
||||
else:
|
||||
m = split_prefix_pat.match(cname)
|
||||
if m:
|
||||
module = m.group(1)
|
||||
name = m.group(2)
|
||||
if isflags:
|
||||
fp.write('(define-flags ' + name + '\n')
|
||||
else:
|
||||
fp.write('(define-enum ' + name + '\n')
|
||||
if module:
|
||||
fp.write(' (in-module "' + module + '")\n')
|
||||
fp.write(' (c-name "' + cname + '")\n')
|
||||
fp.write(' (gtype-id "' + typecode(cname, self.namespace) + '")\n')
|
||||
prefix = entries[0]
|
||||
for ent in entries:
|
||||
# shorten prefix til we get a match ...
|
||||
# and handle GDK_FONT_FONT, GDK_FONT_FONTSET case
|
||||
while ((len(prefix) and prefix[-1] != '_') or ent[:len(prefix)] != prefix
|
||||
or len(prefix) >= len(ent)):
|
||||
prefix = prefix[:-1]
|
||||
prefix_len = len(prefix)
|
||||
fp.write(' (values\n')
|
||||
for ent in entries:
|
||||
fp.write(' \'("%s" "%s")\n' %
|
||||
(string.translate(ent[prefix_len:], trans), ent))
|
||||
fp.write(' )\n')
|
||||
fp.write(')\n\n')
|
||||
|
||||
def write_obj_defs(self, objdefs, fp=None):
|
||||
if not fp:
|
||||
fp = self.fp
|
||||
|
||||
fp.write(';; -*- scheme -*-\n')
|
||||
fp.write('; object definitions ...\n')
|
||||
|
||||
filter = self._objects
|
||||
for klass, parent in objdefs:
|
||||
if filter:
|
||||
if klass in filter:
|
||||
continue
|
||||
if self.namespace:
|
||||
cname = klass[len(self.namespace):]
|
||||
cmodule = self.namespace
|
||||
else:
|
||||
m = split_prefix_pat.match(klass)
|
||||
cname = klass
|
||||
cmodule = None
|
||||
if m:
|
||||
cmodule = m.group(1)
|
||||
cname = m.group(2)
|
||||
fp.write('(define-object ' + cname + '\n')
|
||||
if cmodule:
|
||||
fp.write(' (in-module "' + cmodule + '")\n')
|
||||
if parent:
|
||||
fp.write(' (parent "' + parent + '")\n')
|
||||
fp.write(' (c-name "' + klass + '")\n')
|
||||
fp.write(' (gtype-id "' + typecode(klass, self.namespace) + '")\n')
|
||||
# should do something about accessible fields
|
||||
fp.write(')\n\n')
|
||||
|
||||
def _define_func(self, buf):
|
||||
buf = clean_func(buf)
|
||||
buf = string.split(buf,'\n')
|
||||
filter = self._functions
|
||||
for p in buf:
|
||||
if not p:
|
||||
continue
|
||||
m = proto_pat.match(p)
|
||||
if m == None:
|
||||
if self.verbose:
|
||||
sys.stderr.write('No match:|%s|\n' % p)
|
||||
continue
|
||||
func = m.group('func')
|
||||
if func[0] == '_':
|
||||
continue
|
||||
if filter:
|
||||
if func in filter:
|
||||
continue
|
||||
ret = m.group('ret')
|
||||
args = m.group('args')
|
||||
args = arg_split_pat.split(args)
|
||||
for i in range(len(args)):
|
||||
spaces = string.count(args[i], ' ')
|
||||
if spaces > 1:
|
||||
args[i] = string.replace(args[i], ' ', '-', spaces - 1)
|
||||
|
||||
self._write_func(func, ret, args)
|
||||
|
||||
def _write_func(self, name, ret, args):
|
||||
if len(args) >= 1:
|
||||
# methods must have at least one argument
|
||||
munged_name = name.replace('_', '')
|
||||
m = get_type_pat.match(args[0])
|
||||
if m:
|
||||
obj = m.group(2)
|
||||
if munged_name[:len(obj)] == obj.lower():
|
||||
self._write_method(obj, name, ret, args)
|
||||
return
|
||||
|
||||
if self.prefix:
|
||||
l = len(self.prefix)
|
||||
if name[:l] == self.prefix and name[l] == '_':
|
||||
fname = name[l+1:]
|
||||
else:
|
||||
fname = name
|
||||
else:
|
||||
fname = name
|
||||
|
||||
# it is either a constructor or normal function
|
||||
self.fp.write('(define-function ' + fname + '\n')
|
||||
self.fp.write(' (c-name "' + name + '")\n')
|
||||
|
||||
# Hmmm... Let's asume that a constructor function name
|
||||
# ends with '_new' and it returns a pointer.
|
||||
m = func_new_pat.match(name)
|
||||
if pointer_pat.match(ret) and m:
|
||||
cname = ''
|
||||
names = m.group(1).split('_')
|
||||
|
||||
if self.namespace:
|
||||
cname = self.namespace
|
||||
names = names[1:]
|
||||
|
||||
for s in names:
|
||||
cname += s.title()
|
||||
if cname != '':
|
||||
self.fp.write(' (is-constructor-of "' + cname + '")\n')
|
||||
|
||||
self._write_return(ret)
|
||||
self._write_arguments(args)
|
||||
|
||||
def _write_method(self, obj, name, ret, args):
|
||||
regex = string.join(map(lambda x: x+'_?', string.lower(obj)),'')
|
||||
mname = re.sub(regex, '', name, 1)
|
||||
if self.prefix:
|
||||
l = len(self.prefix) + 1
|
||||
if mname[:l] == self.prefix and mname[l+1] == '_':
|
||||
mname = mname[l+1:]
|
||||
self.fp.write('(define-method ' + mname + '\n')
|
||||
self.fp.write(' (of-object "' + obj + '")\n')
|
||||
self.fp.write(' (c-name "' + name + '")\n')
|
||||
self._write_return(ret)
|
||||
self._write_arguments(args[1:])
|
||||
|
||||
def _write_return(self, ret):
|
||||
if ret != 'void':
|
||||
self.fp.write(' (return-type "' + ret + '")\n')
|
||||
else:
|
||||
self.fp.write(' (return-type "none")\n')
|
||||
|
||||
def _write_arguments(self, args):
|
||||
is_varargs = 0
|
||||
has_args = len(args) > 0
|
||||
for arg in args:
|
||||
if arg == '...':
|
||||
is_varargs = 1
|
||||
elif arg in ('void', 'void '):
|
||||
has_args = 0
|
||||
if has_args:
|
||||
self.fp.write(' (parameters\n')
|
||||
for arg in args:
|
||||
if arg != '...':
|
||||
tupleArg = tuple(string.split(arg))
|
||||
if len(tupleArg) == 2:
|
||||
self.fp.write(' \'("%s" "%s")\n' % tupleArg)
|
||||
self.fp.write(' )\n')
|
||||
if is_varargs:
|
||||
self.fp.write(' (varargs #t)\n')
|
||||
self.fp.write(')\n\n')
|
||||
|
||||
# ------------------ Main function -----------------
|
||||
|
||||
def main(args):
|
||||
verbose = False
|
||||
onlyenums = False
|
||||
onlyobjdefs = False
|
||||
separate = False
|
||||
modulename = None
|
||||
namespace = None
|
||||
defsfilter = None
|
||||
opts, args = getopt.getopt(args[1:], 'vs:m:n:f:',
|
||||
['onlyenums', 'onlyobjdefs',
|
||||
'modulename=', 'namespace=',
|
||||
'separate=', 'defsfilter='])
|
||||
for o, v in opts:
|
||||
if o == '-v':
|
||||
verbose = True
|
||||
if o == '--onlyenums':
|
||||
onlyenums = True
|
||||
if o == '--onlyobjdefs':
|
||||
onlyobjdefs = True
|
||||
if o in ('-s', '--separate'):
|
||||
separate = v
|
||||
if o in ('-m', '--modulename'):
|
||||
modulename = v
|
||||
if o in ('-n', '--namespace'):
|
||||
namespace = v
|
||||
if o in ('-f', '--defsfilter'):
|
||||
defsfilter = v
|
||||
|
||||
if not args[0:1]:
|
||||
print 'Must specify at least one input file name'
|
||||
return -1
|
||||
|
||||
# read all the object definitions in
|
||||
objdefs = []
|
||||
enums = []
|
||||
for filename in args:
|
||||
buf = open(filename).read()
|
||||
find_obj_defs(buf, objdefs)
|
||||
find_enum_defs(buf, enums)
|
||||
objdefs = sort_obj_defs(objdefs)
|
||||
|
||||
if separate:
|
||||
methods = file(separate + '.defs', 'w')
|
||||
types = file(separate + '-types.defs', 'w')
|
||||
|
||||
dw = DefsWriter(methods, prefix=modulename, ns=namespace,
|
||||
verbose=verbose, defsfilter=defsfilter)
|
||||
dw.write_obj_defs(objdefs, types)
|
||||
dw.write_enum_defs(enums, types)
|
||||
print "Wrote %s-types.defs" % separate
|
||||
|
||||
for filename in args:
|
||||
dw.write_def(filename)
|
||||
print "Wrote %s.defs" % separate
|
||||
else:
|
||||
dw = DefsWriter(prefix=modulename, ns=namespace,
|
||||
verbose=verbose, defsfilter=defsfilter)
|
||||
|
||||
if onlyenums:
|
||||
dw.write_enum_defs(enums)
|
||||
elif onlyobjdefs:
|
||||
dw.write_obj_defs(objdefs)
|
||||
else:
|
||||
dw.write_obj_defs(objdefs)
|
||||
dw.write_enum_defs(enums)
|
||||
|
||||
for filename in args:
|
||||
dw.write_def(filename)
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main(sys.argv))
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
|
||||
import optparse
|
||||
|
||||
import defsparser
|
||||
|
||||
parser = optparse.OptionParser(
|
||||
usage="usage: %prog [options] generated-defs old-defs")
|
||||
parser.add_option("-p", "--merge-parameters",
|
||||
help="Merge changes in function/methods parameter lists",
|
||||
action="store_true", dest="parmerge", default=False)
|
||||
(options, args) = parser.parse_args()
|
||||
|
||||
if len(args) != 2:
|
||||
parser.error("wrong number of arguments")
|
||||
|
||||
newp = defsparser.DefsParser(args[0])
|
||||
oldp = defsparser.DefsParser(args[1])
|
||||
|
||||
newp.startParsing()
|
||||
oldp.startParsing()
|
||||
|
||||
newp.merge(oldp, options.parmerge)
|
||||
|
||||
newp.write_defs()
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
|
||||
import sys, os, getopt
|
||||
|
||||
module_init_template = \
|
||||
'/* -*- Mode: C; c-basic-offset: 4 -*- */\n' + \
|
||||
'#ifdef HAVE_CONFIG_H\n' + \
|
||||
'# include "config.h"\n' + \
|
||||
'#endif\n' + \
|
||||
'#include <Python.h>\n' + \
|
||||
'#include <pygtk.h>\n' + \
|
||||
'\n' + \
|
||||
'/* include any extra headers needed here */\n' + \
|
||||
'\n' + \
|
||||
'void %(prefix)s_register_classes(PyObject *d);\n' + \
|
||||
'extern PyMethodDef %(prefix)s_functions[];\n' + \
|
||||
'\n' + \
|
||||
'DL_EXPORT(void)\n' + \
|
||||
'init%(module)s(void)\n' + \
|
||||
'{\n' + \
|
||||
' PyObject *m, *d;\n' + \
|
||||
'\n' + \
|
||||
' /* perform any initialisation required by the library here */\n' + \
|
||||
'\n' + \
|
||||
' m = Py_InitModule("%(module)s", %(prefix)s_functions);\n' + \
|
||||
' d = PyModule_GetDict(m);\n' + \
|
||||
'\n' + \
|
||||
' init_pygtk();\n' + \
|
||||
'\n' + \
|
||||
' %(prefix)s_register_classes(d);\n' + \
|
||||
'\n' + \
|
||||
' /* add anything else to the module dictionary (such as constants) */\n' +\
|
||||
'\n' + \
|
||||
' if (PyErr_Occurred())\n' + \
|
||||
' Py_FatalError("could not initialise module %(module)s");\n' + \
|
||||
'}\n'
|
||||
|
||||
override_template = \
|
||||
'/* -*- Mode: C; c-basic-offset: 4 -*- */\n' + \
|
||||
'%%%%\n' + \
|
||||
'headers\n' + \
|
||||
'/* include any required headers here */\n' + \
|
||||
'%%%%\n' + \
|
||||
'init\n' + \
|
||||
' /* include any code here that needs to be executed before the\n' + \
|
||||
' * extension classes get initialised */\n' + \
|
||||
'%%%%\n' + \
|
||||
'\n' + \
|
||||
'/* you should add appropriate ignore, ignore-glob and\n' + \
|
||||
' * override sections here */\n'
|
||||
|
||||
def open_with_backup(file):
|
||||
if os.path.exists(file):
|
||||
try:
|
||||
os.rename(file, file+'~')
|
||||
except OSError:
|
||||
# fail silently if we can't make a backup
|
||||
pass
|
||||
return open(file, 'w')
|
||||
|
||||
def write_skels(fileprefix, prefix, module):
|
||||
fp = open_with_backup(fileprefix+'module.c')
|
||||
fp.write(module_init_template % { 'prefix': prefix, 'module': module })
|
||||
fp.close()
|
||||
fp = open_with_backup(fileprefix+'.override')
|
||||
fp.write(override_template % { 'prefix': prefix, 'module': module })
|
||||
fp.close()
|
||||
|
||||
if __name__ == '__main__':
|
||||
opts, args = getopt.getopt(sys.argv[1:], 'f:p:m:h',
|
||||
['file-prefix=', 'prefix=', 'module=', 'help'])
|
||||
fileprefix = None
|
||||
prefix = None
|
||||
module = None
|
||||
for opt, arg in opts:
|
||||
if opt in ('-f', '--file-prefix'):
|
||||
fileprefix = arg
|
||||
elif opt in ('-p', '--prefix'):
|
||||
prefix = arg
|
||||
elif opt in ('-m', '--module'):
|
||||
module = arg
|
||||
elif opt in ('-h', '--help'):
|
||||
print 'usage: mkskel.py -f fileprefix -p prefix -m module'
|
||||
sys.exit(0)
|
||||
if not fileprefix or not prefix or not module:
|
||||
print 'usage: mkskel.py -f fileprefix -p prefix -m module'
|
||||
sys.exit(1)
|
||||
write_skels(fileprefix, prefix, module)
|
||||
|
|
@ -1,285 +0,0 @@
|
|||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
|
||||
# this file contains code for loading up an override file. The override file
|
||||
# provides implementations of functions where the code generator could not
|
||||
# do its job correctly.
|
||||
|
||||
import fnmatch
|
||||
import os
|
||||
import re
|
||||
import string
|
||||
import sys
|
||||
|
||||
def class2cname(klass, method):
|
||||
c_name = ''
|
||||
for c in klass:
|
||||
if c.isupper():
|
||||
c_name += '_' + c.lower()
|
||||
else:
|
||||
c_name += c
|
||||
return c_name[1:] + '_' + method
|
||||
|
||||
# import python_type as c_name [for arg_type]
|
||||
# Last ('for') clause is optional. If present, the type will be
|
||||
# imported only if given 'arg_type' is registered.
|
||||
import_pat = re.compile(r'\s*import\s+(\S+)\.([^\s.]+)\s+as\s+(\S+)(\s+for\s+(\S+))?')
|
||||
|
||||
class Overrides:
|
||||
def __init__(self, filename=None):
|
||||
self.modulename = None
|
||||
self.ignores = {}
|
||||
self.glob_ignores = []
|
||||
self.type_ignores = {}
|
||||
self.overrides = {}
|
||||
self.overridden = {}
|
||||
self.kwargs = {}
|
||||
self.noargs = {}
|
||||
self.onearg = {}
|
||||
self.staticmethod = {}
|
||||
self.classmethod = {}
|
||||
self.startlines = {}
|
||||
self.override_attrs = {}
|
||||
self.override_slots = {}
|
||||
self.headers = ''
|
||||
self.body = ''
|
||||
self.init = ''
|
||||
self.imports = []
|
||||
self.defines = {}
|
||||
self.functions = {}
|
||||
self.newstyle_constructors = {}
|
||||
self.dynamicnamespace = False
|
||||
if filename:
|
||||
self.handle_file(filename)
|
||||
|
||||
def handle_file(self, filename):
|
||||
oldpath = os.getcwd()
|
||||
|
||||
fp = open(filename, 'r')
|
||||
dirname = os.path.dirname(os.path.abspath(filename))
|
||||
|
||||
if dirname != oldpath:
|
||||
os.chdir(dirname)
|
||||
|
||||
# read all the components of the file ...
|
||||
bufs = []
|
||||
startline = 1
|
||||
lines = []
|
||||
line = fp.readline()
|
||||
linenum = 1
|
||||
while line:
|
||||
if line == '%%\n' or line == '%%':
|
||||
if lines:
|
||||
bufs.append((string.join(lines, ''), startline))
|
||||
startline = linenum + 1
|
||||
lines = []
|
||||
else:
|
||||
lines.append(line)
|
||||
line = fp.readline()
|
||||
linenum = linenum + 1
|
||||
if lines:
|
||||
bufs.append((string.join(lines, ''), startline))
|
||||
if not bufs: return
|
||||
|
||||
for buf, startline in bufs:
|
||||
self.__parse_override(buf, startline, filename)
|
||||
|
||||
os.chdir(oldpath)
|
||||
|
||||
def __parse_override(self, buffer, startline, filename):
|
||||
pos = string.find(buffer, '\n')
|
||||
if pos >= 0:
|
||||
line = buffer[:pos]
|
||||
rest = buffer[pos+1:]
|
||||
else:
|
||||
line = buffer ; rest = ''
|
||||
words = string.split(line)
|
||||
command = words[0]
|
||||
if (command == 'ignore' or
|
||||
command == 'ignore-' + sys.platform):
|
||||
"ignore/ignore-platform [functions..]"
|
||||
for func in words[1:]:
|
||||
self.ignores[func] = 1
|
||||
for func in string.split(rest):
|
||||
self.ignores[func] = 1
|
||||
elif (command == 'ignore-glob' or
|
||||
command == 'ignore-glob-' + sys.platform):
|
||||
"ignore-glob/ignore-glob-platform [globs..]"
|
||||
for func in words[1:]:
|
||||
self.glob_ignores.append(func)
|
||||
for func in string.split(rest):
|
||||
self.glob_ignores.append(func)
|
||||
elif (command == 'ignore-type' or
|
||||
command == 'ignore-type-' + sys.platform):
|
||||
"ignore-type/ignore-type-platform [typenames..]"
|
||||
for typename in words[1:]:
|
||||
self.type_ignores[typename] = 1
|
||||
for typename in string.split(rest):
|
||||
self.type_ignores[typename] = 1
|
||||
elif command == 'override':
|
||||
"override function/method [kwargs|noargs|onearg] [staticmethod|classmethod]"
|
||||
func = words[1]
|
||||
if 'kwargs' in words[1:]:
|
||||
self.kwargs[func] = 1
|
||||
elif 'noargs' in words[1:]:
|
||||
self.noargs[func] = 1
|
||||
elif 'onearg' in words[1:]:
|
||||
self.onearg[func] = True
|
||||
|
||||
if 'staticmethod' in words[1:]:
|
||||
self.staticmethod[func] = True
|
||||
elif 'classmethod' in words[1:]:
|
||||
self.classmethod[func] = True
|
||||
if func in self.overrides:
|
||||
raise RuntimeError("Function %s is being overridden more than once" % (func,))
|
||||
self.overrides[func] = rest
|
||||
self.startlines[func] = (startline + 1, filename)
|
||||
elif command == 'override-attr':
|
||||
"override-slot Class.attr"
|
||||
attr = words[1]
|
||||
self.override_attrs[attr] = rest
|
||||
self.startlines[attr] = (startline + 1, filename)
|
||||
elif command == 'override-slot':
|
||||
"override-slot Class.slot"
|
||||
slot = words[1]
|
||||
self.override_slots[slot] = rest
|
||||
self.startlines[slot] = (startline + 1, filename)
|
||||
elif command == 'headers':
|
||||
"headers"
|
||||
self.headers = '%s\n#line %d "%s"\n%s' % \
|
||||
(self.headers, startline + 1, filename, rest)
|
||||
elif command == 'body':
|
||||
"body"
|
||||
self.body = '%s\n#line %d "%s"\n%s' % \
|
||||
(self.body, startline + 1, filename, rest)
|
||||
elif command == 'init':
|
||||
"init"
|
||||
self.init = '%s\n#line %d "%s"\n%s' % \
|
||||
(self.init, startline + 1, filename, rest)
|
||||
elif command == 'modulename':
|
||||
"modulename name"
|
||||
self.modulename = words[1]
|
||||
elif command == 'include':
|
||||
"include filename"
|
||||
for filename in words[1:]:
|
||||
self.handle_file(filename)
|
||||
for filename in string.split(rest):
|
||||
self.handle_file(filename)
|
||||
elif command == 'import':
|
||||
"import module1 [\n module2, \n module3 ...]"
|
||||
for line in string.split(buffer, '\n'):
|
||||
match = import_pat.match(line)
|
||||
if match:
|
||||
module, pyname, cname, conditional, importing_for = match.groups()
|
||||
self.imports.append((module, pyname, cname, importing_for or None))
|
||||
elif command == 'define':
|
||||
"define funcname [kwargs|noargs|onearg] [classmethod|staticmethod]"
|
||||
"define Class.method [kwargs|noargs|onearg] [classmethod|staticmethod]"
|
||||
func = words[1]
|
||||
klass = None
|
||||
if func.find('.') != -1:
|
||||
klass, func = func.split('.', 1)
|
||||
|
||||
if not self.defines.has_key(klass):
|
||||
self.defines[klass] = {}
|
||||
self.defines[klass][func] = rest
|
||||
else:
|
||||
self.functions[func] = rest
|
||||
|
||||
if 'kwargs' in words[1:]:
|
||||
self.kwargs[func] = 1
|
||||
elif 'noargs' in words[1:]:
|
||||
self.noargs[func] = 1
|
||||
elif 'onearg' in words[1:]:
|
||||
self.onearg[func] = 1
|
||||
|
||||
if 'staticmethod' in words[1:]:
|
||||
self.staticmethod[func] = True
|
||||
elif 'classmethod' in words[1:]:
|
||||
self.classmethod[func] = True
|
||||
|
||||
self.startlines[func] = (startline + 1, filename)
|
||||
|
||||
elif command == 'new-constructor':
|
||||
"new-constructor GType"
|
||||
gtype, = words[1:]
|
||||
self.newstyle_constructors[gtype] = True
|
||||
elif command == 'options':
|
||||
for option in words[1:]:
|
||||
if option == 'dynamicnamespace':
|
||||
self.dynamicnamespace = True
|
||||
|
||||
def is_ignored(self, name):
|
||||
if self.ignores.has_key(name):
|
||||
return 1
|
||||
for glob in self.glob_ignores:
|
||||
if fnmatch.fnmatchcase(name, glob):
|
||||
return 1
|
||||
return 0
|
||||
|
||||
def is_type_ignored(self, name):
|
||||
return name in self.type_ignores
|
||||
|
||||
def is_overriden(self, name):
|
||||
return self.overrides.has_key(name)
|
||||
|
||||
def is_already_included(self, name):
|
||||
return self.overridden.has_key(name)
|
||||
|
||||
def override(self, name):
|
||||
self.overridden[name] = 1
|
||||
return self.overrides[name]
|
||||
|
||||
def define(self, klass, name):
|
||||
self.overridden[class2cname(klass, name)] = 1
|
||||
return self.defines[klass][name]
|
||||
|
||||
def function(self, name):
|
||||
return self.functions[name]
|
||||
|
||||
def getstartline(self, name):
|
||||
return self.startlines[name]
|
||||
|
||||
def wants_kwargs(self, name):
|
||||
return self.kwargs.has_key(name)
|
||||
|
||||
def wants_noargs(self, name):
|
||||
return self.noargs.has_key(name)
|
||||
|
||||
def wants_onearg(self, name):
|
||||
return self.onearg.has_key(name)
|
||||
|
||||
def is_staticmethod(self, name):
|
||||
return self.staticmethod.has_key(name)
|
||||
|
||||
def is_classmethod(self, name):
|
||||
return self.classmethod.has_key(name)
|
||||
|
||||
def attr_is_overriden(self, attr):
|
||||
return self.override_attrs.has_key(attr)
|
||||
|
||||
def attr_override(self, attr):
|
||||
return self.override_attrs[attr]
|
||||
|
||||
def slot_is_overriden(self, slot):
|
||||
return self.override_slots.has_key(slot)
|
||||
|
||||
def slot_override(self, slot):
|
||||
return self.override_slots[slot]
|
||||
|
||||
def get_headers(self):
|
||||
return self.headers
|
||||
|
||||
def get_body(self):
|
||||
return self.body
|
||||
|
||||
def get_init(self):
|
||||
return self.init
|
||||
|
||||
def get_imports(self):
|
||||
return self.imports
|
||||
|
||||
def get_defines_for(self, klass):
|
||||
return self.defines.get(klass, {})
|
||||
|
||||
def get_functions(self):
|
||||
return self.functions
|
||||
|
|
@ -1,912 +0,0 @@
|
|||
### -*- python -*-
|
||||
### Code to generate "Reverse Wrappers", i.e. C->Python wrappers
|
||||
### (C) 2004 Gustavo Carneiro <gjc@gnome.org>
|
||||
import argtypes
|
||||
import os
|
||||
|
||||
DEBUG_MODE = ('PYGTK_CODEGEN_DEBUG' in os.environ)
|
||||
|
||||
def join_ctype_name(ctype, name):
|
||||
'''Joins a C type and a variable name into a single string'''
|
||||
if ctype[-1] != '*':
|
||||
return " ".join((ctype, name))
|
||||
else:
|
||||
return "".join((ctype, name))
|
||||
|
||||
|
||||
class CodeSink(object):
|
||||
def __init__(self):
|
||||
self.indent_level = 0 # current indent level
|
||||
self.indent_stack = [] # previous indent levels
|
||||
|
||||
def _format_code(self, code):
|
||||
assert isinstance(code, str)
|
||||
l = []
|
||||
for line in code.split('\n'):
|
||||
l.append(' '*self.indent_level + line)
|
||||
if l[-1]:
|
||||
l.append('')
|
||||
return '\n'.join(l)
|
||||
|
||||
def writeln(self, line=''):
|
||||
raise NotImplementedError
|
||||
|
||||
def indent(self, level=4):
|
||||
'''Add a certain ammount of indentation to all lines written
|
||||
from now on and until unindent() is called'''
|
||||
self.indent_stack.append(self.indent_level)
|
||||
self.indent_level += level
|
||||
|
||||
def unindent(self):
|
||||
'''Revert indentation level to the value before last indent() call'''
|
||||
self.indent_level = self.indent_stack.pop()
|
||||
|
||||
|
||||
class FileCodeSink(CodeSink):
|
||||
def __init__(self, fp):
|
||||
CodeSink.__init__(self)
|
||||
assert isinstance(fp, file)
|
||||
self.fp = fp
|
||||
|
||||
def writeln(self, line=''):
|
||||
self.fp.write(self._format_code(line))
|
||||
|
||||
class MemoryCodeSink(CodeSink):
|
||||
def __init__(self):
|
||||
CodeSink.__init__(self)
|
||||
self.lines = []
|
||||
|
||||
def writeln(self, line=''):
|
||||
self.lines.append(self._format_code(line))
|
||||
|
||||
def flush_to(self, sink):
|
||||
assert isinstance(sink, CodeSink)
|
||||
for line in self.lines:
|
||||
sink.writeln(line.rstrip())
|
||||
self.lines = []
|
||||
|
||||
def flush(self):
|
||||
l = []
|
||||
for line in self.lines:
|
||||
l.append(self._format_code(line))
|
||||
self.lines = []
|
||||
return "".join(l)
|
||||
|
||||
class ReverseWrapper(object):
|
||||
'''Object that generates a C->Python wrapper'''
|
||||
def __init__(self, cname, is_static=True):
|
||||
assert isinstance(cname, str)
|
||||
|
||||
self.cname = cname
|
||||
## function object we will call, or object whose method we will call
|
||||
self.called_pyobj = None
|
||||
## name of method of self.called_pyobj we will call
|
||||
self.method_name = None
|
||||
self.is_static = is_static
|
||||
|
||||
self.parameters = []
|
||||
self.declarations = MemoryCodeSink()
|
||||
self.post_return_code = MemoryCodeSink()
|
||||
self.body = MemoryCodeSink()
|
||||
self.check_exception_code = MemoryCodeSink()
|
||||
self.cleanup_actions = []
|
||||
self.pyargv_items = []
|
||||
self.pyargv_optional_items = []
|
||||
self.pyret_parse_items = [] # list of (format_spec, parameter)
|
||||
self.code_sinks_stack = [self.body]
|
||||
|
||||
def set_call_target(self, called_pyobj, method_name=None):
|
||||
assert called_pyobj is not None
|
||||
assert self.called_pyobj is None
|
||||
self.called_pyobj = called_pyobj
|
||||
self.method_name = method_name
|
||||
|
||||
def set_return_type(self, return_type):
|
||||
assert isinstance(return_type, ReturnType)
|
||||
self.return_type = return_type
|
||||
|
||||
def add_parameter(self, param):
|
||||
assert isinstance(param, Parameter)
|
||||
self.parameters.append(param)
|
||||
|
||||
def add_declaration(self, decl_code):
|
||||
self.declarations.writeln(decl_code)
|
||||
|
||||
def add_pyargv_item(self, variable, optional=False):
|
||||
if optional:
|
||||
self.pyargv_optional_items.append(variable)
|
||||
else:
|
||||
self.pyargv_items.append(variable)
|
||||
|
||||
def add_pyret_parse_item(self, format_specifier, parameter, prepend=False):
|
||||
if prepend:
|
||||
self.pyret_parse_items.insert(0, (format_specifier, parameter))
|
||||
else:
|
||||
self.pyret_parse_items.append((format_specifier, parameter))
|
||||
|
||||
|
||||
def push_code_sink(self, code_sink):
|
||||
self.code_sinks_stack.insert(0, code_sink)
|
||||
|
||||
def pop_code_sink(self):
|
||||
return self.code_sinks_stack.pop(0)
|
||||
|
||||
|
||||
def write_code(self, code,
|
||||
cleanup=None,
|
||||
failure_expression=None,
|
||||
failure_cleanup=None,
|
||||
failure_exception=None,
|
||||
code_sink=None):
|
||||
'''Add a chunk of code with cleanup and error handling
|
||||
|
||||
This method is to be used by TypeHandlers when generating code
|
||||
|
||||
Keywork arguments:
|
||||
code -- code to add
|
||||
cleanup -- code to cleanup any dynamic resources created by @code
|
||||
(except in case of failure) (default None)
|
||||
failure_expression -- C boolean expression to indicate
|
||||
if anything failed (default None)
|
||||
failure_cleanup -- code to cleanup any dynamic resources
|
||||
created by @code in case of failure (default None)
|
||||
failure_exception -- code to raise an exception in case of
|
||||
failure (which will be immediately
|
||||
printed and cleared), (default None)
|
||||
code_sink -- "code sink" to use; by default,
|
||||
ReverseWrapper.body is used, which writes the
|
||||
main body of the wrapper, before calling the
|
||||
python method. Alternatively,
|
||||
ReverseWrapper.after_pyret_parse can be used, to
|
||||
write code after the PyArg_ParseTuple that
|
||||
parses the python method return value.
|
||||
'''
|
||||
if code_sink is None:
|
||||
code_sink = self.code_sinks_stack[0]
|
||||
if code is not None:
|
||||
code_sink.writeln(code)
|
||||
if failure_expression is not None:
|
||||
code_sink.writeln("if (%s) {" % (failure_expression,))
|
||||
code_sink.indent()
|
||||
if failure_exception is None:
|
||||
code_sink.writeln("if (PyErr_Occurred())")
|
||||
code_sink.indent()
|
||||
code_sink.writeln("PyErr_Print();")
|
||||
code_sink.unindent()
|
||||
else:
|
||||
code_sink.writeln(failure_exception)
|
||||
code_sink.writeln("PyErr_Print();")
|
||||
if failure_cleanup is not None:
|
||||
code_sink.writeln(failure_cleanup)
|
||||
for cleanup_action in self.cleanup_actions:
|
||||
code_sink.writeln(cleanup_action)
|
||||
|
||||
self.push_code_sink(code_sink)
|
||||
try:
|
||||
self.return_type.write_error_return()
|
||||
finally:
|
||||
self.pop_code_sink()
|
||||
|
||||
code_sink.unindent()
|
||||
code_sink.writeln("}")
|
||||
if cleanup is not None:
|
||||
self.cleanup_actions.insert(0, cleanup)
|
||||
|
||||
def generate(self, sink):
|
||||
'''Generate the code into a CodeSink object'''
|
||||
assert isinstance(sink, CodeSink)
|
||||
|
||||
if DEBUG_MODE:
|
||||
self.declarations.writeln("/* begin declarations */")
|
||||
self.body.writeln("/* begin main body */")
|
||||
self.post_return_code.writeln("/* begin post-return code */")
|
||||
|
||||
self.add_declaration("PyGILState_STATE __py_state;")
|
||||
self.write_code(code="__py_state = pyg_gil_state_ensure();",
|
||||
cleanup="pyg_gil_state_release(__py_state);")
|
||||
|
||||
for param in self.parameters:
|
||||
param.convert_c2py()
|
||||
|
||||
assert self.called_pyobj is not None,\
|
||||
"Parameters failed to provide a target function or method."
|
||||
|
||||
if self.is_static:
|
||||
sink.writeln('static %s' % self.return_type.get_c_type())
|
||||
else:
|
||||
sink.writeln(self.return_type.get_c_type())
|
||||
c_proto_params = map(Parameter.format_for_c_proto, self.parameters)
|
||||
sink.writeln("%s(%s)\n{" % (self.cname, ", ".join(c_proto_params)))
|
||||
|
||||
self.return_type.write_decl()
|
||||
self.add_declaration("PyObject *py_retval;")
|
||||
|
||||
## Handle number of arguments
|
||||
if self.pyargv_items:
|
||||
self.add_declaration("PyObject *py_args;")
|
||||
py_args = "py_args"
|
||||
if self.pyargv_optional_items:
|
||||
self.add_declaration("int argc = %i;" % len(self.pyargv_items))
|
||||
argc = "argc"
|
||||
for arg in self.pyargv_optional_items:
|
||||
self.body.writeln("if (%s)" % arg)
|
||||
self.body.indent()
|
||||
self.body.writeln("++argc;")
|
||||
self.body.unindent()
|
||||
else:
|
||||
argc = str(len(self.pyargv_items))
|
||||
else:
|
||||
if self.pyargv_optional_items:
|
||||
self.add_declaration("PyObject *py_args;")
|
||||
py_args = "py_args"
|
||||
self.add_declaration("int argc = 0;")
|
||||
argc = "argc"
|
||||
for arg in self.pyargv_optional_items:
|
||||
self.body.writeln("if (%s)" % arg)
|
||||
self.body.indent()
|
||||
self.body.writeln("++argc;")
|
||||
self.body.unindent()
|
||||
else:
|
||||
py_args = "NULL"
|
||||
argc = None
|
||||
|
||||
self.body.writeln()
|
||||
|
||||
if py_args != "NULL":
|
||||
self.write_code("py_args = PyTuple_New(%s);" % argc,
|
||||
cleanup="Py_DECREF(py_args);")
|
||||
pos = 0
|
||||
for arg in self.pyargv_items:
|
||||
try: # try to remove the Py_DECREF cleanup action, if we can
|
||||
self.cleanup_actions.remove("Py_DECREF(%s);" % arg)
|
||||
except ValueError: # otherwise we have to Py_INCREF..
|
||||
self.body.writeln("Py_INCREF(%s);" % arg)
|
||||
self.body.writeln("PyTuple_SET_ITEM(%s, %i, %s);" % (py_args, pos, arg))
|
||||
pos += 1
|
||||
for arg in self.pyargv_optional_items:
|
||||
self.body.writeln("if (%s) {" % arg)
|
||||
self.body.indent()
|
||||
try: # try to remove the Py_DECREF cleanup action, if we can
|
||||
self.cleanup_actions.remove("Py_XDECREF(%s);" % arg)
|
||||
except ValueError: # otherwise we have to Py_INCREF..
|
||||
self.body.writeln("Py_INCREF(%s);" % arg)
|
||||
self.body.writeln("PyTuple_SET_ITEM(%s, %i, %s);" % (py_args, pos, arg))
|
||||
self.body.unindent()
|
||||
self.body.writeln("}")
|
||||
pos += 1
|
||||
|
||||
self.body.writeln()
|
||||
|
||||
## Call the python method
|
||||
if self.method_name is None:
|
||||
self.write_code("py_retval = PyObject_Call(%s, %s);"
|
||||
% (self.called_pyobj, py_args),
|
||||
cleanup="Py_XDECREF(py_retval);")
|
||||
self.check_exception_code.flush_to(self.body)
|
||||
self.write_code(None, failure_expression="!py_retval")
|
||||
|
||||
else:
|
||||
self.add_declaration("PyObject *py_method;")
|
||||
self.write_code("py_method = PyObject_GetAttrString(%s, \"%s\");"
|
||||
% (self.called_pyobj, self.method_name),
|
||||
cleanup="Py_DECREF(py_method);",
|
||||
failure_expression="!py_method")
|
||||
self.write_code("py_retval = PyObject_CallObject(py_method, %s);"
|
||||
% (py_args,),
|
||||
cleanup="Py_XDECREF(py_retval);")
|
||||
self.check_exception_code.flush_to(self.body)
|
||||
self.write_code(None, failure_expression="!py_retval")
|
||||
|
||||
## -- Handle the return value --
|
||||
|
||||
## we need to check if the return_type object is prepared to cooperate with multiple return values
|
||||
len_before = len(self.pyret_parse_items)
|
||||
self.return_type.write_conversion()
|
||||
len_after = len(self.pyret_parse_items)
|
||||
assert (self.return_type.get_c_type() == 'void'
|
||||
or not (len_before == len_after and len_after > 0)),\
|
||||
("Bug in reverse wrappers: return type handler %s"
|
||||
" is not prepared to cooperate multiple return values") % (type(self.return_type),)
|
||||
|
||||
sink.indent()
|
||||
|
||||
if self.pyret_parse_items == [("", "")]:
|
||||
## special case when there are no return parameters
|
||||
self.write_code(
|
||||
code=None,
|
||||
failure_expression='py_retval != Py_None',
|
||||
failure_exception=('PyErr_SetString(PyExc_TypeError, '
|
||||
'"virtual method should return None");'))
|
||||
else:
|
||||
if len(self.pyret_parse_items) == 1:
|
||||
## if retval is one item only, pack it in a tuple so we
|
||||
## can use PyArg_ParseTuple as usual..
|
||||
self.write_code('py_retval = Py_BuildValue("(N)", py_retval);')
|
||||
if len(self.pyret_parse_items) > 0:
|
||||
## Parse return values using PyArg_ParseTuple
|
||||
params = ["py_retval",
|
||||
'"%s"' % "".join([format for format, param in self.pyret_parse_items])]
|
||||
params.extend([param for format, param in self.pyret_parse_items if param])
|
||||
self.write_code(code=None, failure_expression=(
|
||||
'!PyArg_ParseTuple(%s)' % (', '.join(params),)))
|
||||
|
||||
if DEBUG_MODE:
|
||||
self.declarations.writeln("/* end declarations */")
|
||||
self.declarations.flush_to(sink)
|
||||
sink.writeln()
|
||||
if DEBUG_MODE:
|
||||
self.body.writeln("/* end main body */")
|
||||
self.body.flush_to(sink)
|
||||
sink.writeln()
|
||||
if DEBUG_MODE:
|
||||
self.post_return_code.writeln("/* end post-return code */")
|
||||
self.post_return_code.flush_to(sink)
|
||||
sink.writeln()
|
||||
|
||||
for cleanup_action in self.cleanup_actions:
|
||||
sink.writeln(cleanup_action)
|
||||
if self.return_type.get_c_type() != 'void':
|
||||
sink.writeln()
|
||||
sink.writeln("return retval;")
|
||||
sink.unindent()
|
||||
sink.writeln("}")
|
||||
|
||||
class TypeHandler(object):
|
||||
def __init__(self, wrapper, **props):
|
||||
assert isinstance(wrapper, ReverseWrapper)
|
||||
self.wrapper = wrapper
|
||||
self.props = props
|
||||
|
||||
class ReturnType(TypeHandler):
|
||||
|
||||
supports_optional = False
|
||||
|
||||
def get_c_type(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def write_decl(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def write_error_return(self):
|
||||
'''Write "return <value>" code in case of error'''
|
||||
raise NotImplementedError
|
||||
|
||||
def write_conversion(self):
|
||||
'''Writes code to convert Python return value in 'py_retval'
|
||||
into C 'retval'. Returns a string with C boolean expression
|
||||
that determines if anything went wrong. '''
|
||||
raise NotImplementedError
|
||||
|
||||
class Parameter(TypeHandler):
|
||||
|
||||
def __init__(self, wrapper, name, **props):
|
||||
TypeHandler.__init__(self, wrapper, **props)
|
||||
self.name = name
|
||||
|
||||
def get_c_type(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def convert_c2py(self):
|
||||
'''Write some code before calling the Python method.'''
|
||||
pass
|
||||
|
||||
def format_for_c_proto(self):
|
||||
return join_ctype_name(self.get_c_type(), self.name)
|
||||
|
||||
|
||||
###---
|
||||
class StringParam(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'char *').replace('const-', 'const ')
|
||||
|
||||
def convert_c2py(self):
|
||||
if self.props.get('optional', False):
|
||||
self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name)
|
||||
self.wrapper.write_code(code=("if (%s)\n"
|
||||
" py_%s = PyString_FromString(%s);\n"
|
||||
% (self.name, self.name, self.name)),
|
||||
cleanup=("Py_XDECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name, optional=True)
|
||||
elif self.props.get('nullok', False):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("if (%s)\n"
|
||||
" py_%s = PyString_FromString(%s);\n"
|
||||
"else {\n"
|
||||
" Py_INCREF(Py_None);\n"
|
||||
" py_%s = Py_None;\n"
|
||||
"}\n"
|
||||
% (self.name, self.name, self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
else:
|
||||
self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name)
|
||||
self.wrapper.write_code(code=("if (%s)\n"
|
||||
" py_%s = PyString_FromString(%s);\n" %
|
||||
(self.name, self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name),
|
||||
failure_expression=("!py_%s" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
for ctype in ('char*', 'gchar*', 'const-char*', 'char-const*', 'const-gchar*',
|
||||
'gchar-const*', 'string', 'static_string'):
|
||||
argtypes.matcher.register_reverse(ctype, StringParam)
|
||||
del ctype
|
||||
|
||||
class StringReturn(ReturnType):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'char *').replace('const-', 'const ')
|
||||
#return "char *"
|
||||
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
#self.wrapper.add_declaration("char *retval;")
|
||||
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return NULL;")
|
||||
|
||||
def write_conversion(self):
|
||||
self.wrapper.add_pyret_parse_item("s", "&retval", prepend=True)
|
||||
self.wrapper.write_code("retval = g_strdup(retval);", code_sink=self.wrapper.post_return_code)
|
||||
|
||||
for ctype in ('char*', 'gchar*', 'const-gchar*'):
|
||||
argtypes.matcher.register_reverse_ret(ctype, StringReturn)
|
||||
del ctype
|
||||
|
||||
|
||||
class VoidReturn(ReturnType):
|
||||
|
||||
def get_c_type(self):
|
||||
return "void"
|
||||
|
||||
def write_decl(self):
|
||||
pass
|
||||
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return;")
|
||||
|
||||
def write_conversion(self):
|
||||
self.wrapper.add_pyret_parse_item("", "", prepend=True)
|
||||
|
||||
argtypes.matcher.register_reverse_ret('void', VoidReturn)
|
||||
argtypes.matcher.register_reverse_ret('none', VoidReturn)
|
||||
|
||||
class GObjectParam(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GObject *')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name)
|
||||
self.wrapper.write_code(code=("if (%s)\n"
|
||||
" py_%s = pygobject_new((GObject *) %s);\n"
|
||||
"else {\n"
|
||||
" Py_INCREF(Py_None);\n"
|
||||
" py_%s = Py_None;\n"
|
||||
"}"
|
||||
% (self.name, self.name, self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
argtypes.matcher.register_reverse('GObject*', GObjectParam)
|
||||
|
||||
class GObjectReturn(ReturnType):
|
||||
|
||||
supports_optional = True
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GObject *')
|
||||
|
||||
def write_decl(self):
|
||||
if not self.props.get('optional'):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
else:
|
||||
self.wrapper.add_declaration("%s retval = NULL;" % self.get_c_type())
|
||||
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return NULL;")
|
||||
|
||||
def write_conversion(self):
|
||||
if not self.props.get('optional'):
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression="!PyObject_TypeCheck(py_retval, &PyGObject_Type)",
|
||||
failure_exception='PyErr_SetString(PyExc_TypeError, "retval should be a GObject");')
|
||||
self.wrapper.write_code("retval = (%s) pygobject_get(py_retval);"
|
||||
% self.get_c_type())
|
||||
self.wrapper.write_code("g_object_ref((GObject *) retval);")
|
||||
else:
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression="py_retval != Py_None && !PyObject_TypeCheck(py_retval, &PyGObject_Type)",
|
||||
failure_exception='PyErr_SetString(PyExc_TypeError, "retval should be None or a GObject");')
|
||||
self.wrapper.write_code("if (py_retval != Py_None) {\n"
|
||||
" retval = (%s) pygobject_get(py_retval);\n"
|
||||
" g_object_ref((GObject *) retval);\n"
|
||||
"}\n"
|
||||
% self.get_c_type())
|
||||
|
||||
argtypes.matcher.register_reverse_ret('GObject*', GObjectReturn)
|
||||
|
||||
|
||||
|
||||
class IntParam(Parameter):
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'int')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = PyInt_FromLong(%s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
class IntReturn(ReturnType):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'int')
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return -G_MAXINT;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.add_pyret_parse_item("i", "&retval", prepend=True)
|
||||
|
||||
for argtype in ('int', 'gint', 'guint', 'short', 'gshort', 'gushort', 'long',
|
||||
'glong', 'gsize', 'gssize', 'guint8', 'gint8', 'guint16',
|
||||
'gint16', 'gint32', 'GTime'):
|
||||
argtypes.matcher.register_reverse(argtype, IntParam)
|
||||
argtypes.matcher.register_reverse_ret(argtype, IntReturn)
|
||||
del argtype
|
||||
|
||||
class IntPtrParam(Parameter):
|
||||
def __init__(self, wrapper, name, **props):
|
||||
if "direction" not in props:
|
||||
raise argtypes.ArgTypeConfigurationError(
|
||||
"cannot use int* parameter without direction")
|
||||
if props["direction"] not in ("out", "inout"):
|
||||
raise argtypes.ArgTypeConfigurationError(
|
||||
"cannot use int* parameter with direction '%s'"
|
||||
% (props["direction"],))
|
||||
Parameter.__init__(self, wrapper, name, **props)
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'int*')
|
||||
def convert_c2py(self):
|
||||
if self.props["direction"] == "inout":
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = PyInt_FromLong(*%s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
self.wrapper.add_pyret_parse_item("i", self.name)
|
||||
for argtype in ('int*', 'gint*'):
|
||||
argtypes.matcher.register_reverse(argtype, IntPtrParam)
|
||||
del argtype
|
||||
|
||||
|
||||
class GEnumReturn(IntReturn):
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression=(
|
||||
"pyg_enum_get_value(%s, py_retval, (gint *)&retval)"
|
||||
% (self.props['typecode'],)))
|
||||
|
||||
argtypes.matcher.register_reverse_ret("GEnum", GEnumReturn)
|
||||
|
||||
class GEnumParam(IntParam):
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = pyg_enum_from_gtype(%s, %s);" %
|
||||
(self.name, self.props['typecode'], self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name),
|
||||
failure_expression=("!py_%s" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
argtypes.matcher.register_reverse("GEnum", GEnumParam)
|
||||
|
||||
class GFlagsReturn(IntReturn):
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(
|
||||
code=None,
|
||||
failure_expression=(
|
||||
"pyg_flags_get_value(%s, py_retval, (gint *)&retval)" %
|
||||
self.props['typecode']))
|
||||
|
||||
argtypes.matcher.register_reverse_ret("GFlags", GFlagsReturn)
|
||||
|
||||
class GFlagsParam(IntParam):
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=(
|
||||
"py_%s = pyg_flags_from_gtype(%s, %s);" %
|
||||
(self.name, self.props['typecode'], self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name),
|
||||
failure_expression=("!py_%s" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
argtypes.matcher.register_reverse("GFlags", GFlagsParam)
|
||||
|
||||
|
||||
class GtkTreePathParam(IntParam):
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=(
|
||||
"py_%s = pygtk_tree_path_to_pyobject(%s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name),
|
||||
failure_expression=("!py_%s" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
argtypes.matcher.register_reverse("GtkTreePath*", GtkTreePathParam)
|
||||
|
||||
|
||||
class GtkTreePathReturn(ReturnType):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GtkTreePath *')
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("GtkTreePath * retval;")
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return NULL;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(
|
||||
"retval = pygtk_tree_path_from_pyobject(py_retval);\n",
|
||||
failure_expression=('!retval'),
|
||||
failure_exception=(
|
||||
'PyErr_SetString(PyExc_TypeError, "retval should be a GtkTreePath");'))
|
||||
|
||||
argtypes.matcher.register_reverse_ret("GtkTreePath*", GtkTreePathReturn)
|
||||
|
||||
|
||||
class BooleanReturn(ReturnType):
|
||||
def get_c_type(self):
|
||||
return "gboolean"
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("gboolean retval;")
|
||||
self.wrapper.add_declaration("PyObject *py_main_retval;")
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return FALSE;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.add_pyret_parse_item("O", "&py_main_retval", prepend=True)
|
||||
self.wrapper.write_code(
|
||||
"retval = PyObject_IsTrue(py_main_retval)? TRUE : FALSE;",
|
||||
code_sink=self.wrapper.post_return_code)
|
||||
argtypes.matcher.register_reverse_ret("gboolean", BooleanReturn)
|
||||
|
||||
class BooleanParam(Parameter):
|
||||
def get_c_type(self):
|
||||
return "gboolean"
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code("py_%s = %s? Py_True : Py_False;"
|
||||
% (self.name, self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
argtypes.matcher.register_reverse("gboolean", BooleanParam)
|
||||
|
||||
|
||||
class DoubleParam(Parameter):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'gdouble')
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = PyFloat_FromDouble(%s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
class DoublePtrParam(Parameter):
|
||||
def __init__(self, wrapper, name, **props):
|
||||
if "direction" not in props:
|
||||
raise argtypes.ArgTypeConfigurationError(
|
||||
"cannot use double* parameter without direction")
|
||||
if props["direction"] not in ("out", ): # inout not yet implemented
|
||||
raise argtypes.ArgTypeConfigurationError(
|
||||
"cannot use double* parameter with direction '%s'"
|
||||
% (props["direction"],))
|
||||
Parameter.__init__(self, wrapper, name, **props)
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'double*')
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_pyret_parse_item("d", self.name)
|
||||
for argtype in ('double*', 'gdouble*'):
|
||||
argtypes.matcher.register_reverse(argtype, DoublePtrParam)
|
||||
del argtype
|
||||
|
||||
class DoubleReturn(ReturnType):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'gdouble')
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return -G_MAXFLOAT;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.add_pyret_parse_item("d", "&retval", prepend=True)
|
||||
|
||||
for argtype in ('float', 'double', 'gfloat', 'gdouble'):
|
||||
argtypes.matcher.register_reverse(argtype, DoubleParam)
|
||||
argtypes.matcher.register_reverse_ret(argtype, DoubleReturn)
|
||||
|
||||
|
||||
class GBoxedParam(Parameter):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type').replace('const-', 'const ')
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
ctype = self.get_c_type()
|
||||
if ctype.startswith('const '):
|
||||
ctype_no_const = ctype[len('const '):]
|
||||
self.wrapper.write_code(
|
||||
code=('py_%s = pyg_boxed_new(%s, (%s) %s, TRUE, TRUE);' %
|
||||
(self.name, self.props['typecode'],
|
||||
ctype_no_const, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
else:
|
||||
self.wrapper.write_code(
|
||||
code=('py_%s = pyg_boxed_new(%s, %s, FALSE, FALSE);' %
|
||||
(self.name, self.props['typecode'], self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
argtypes.matcher.register_reverse("GBoxed", GBoxedParam)
|
||||
|
||||
|
||||
class GBoxedReturn(ReturnType):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type')
|
||||
def write_decl(self):
|
||||
self.wrapper.add_declaration("%s retval;" % self.get_c_type())
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return retval;")
|
||||
def write_conversion(self):
|
||||
self.wrapper.write_code(code = None,
|
||||
failure_expression=("!pyg_boxed_check(py_retval, %s)" %
|
||||
(self.props['typecode'],)),
|
||||
failure_exception=(
|
||||
'PyErr_SetString(PyExc_TypeError, "retval should be a %s");'
|
||||
% (self.props['typename'],)))
|
||||
self.wrapper.write_code('retval = pyg_boxed_get(py_retval, %s);' %
|
||||
self.props['typename'])
|
||||
|
||||
argtypes.matcher.register_reverse_ret("GBoxed", GBoxedReturn)
|
||||
|
||||
|
||||
class GdkRegionPtrReturn(GBoxedReturn):
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return gdk_region_new();")
|
||||
def write_conversion(self):
|
||||
self.props['typecode'] = 'PYGDK_TYPE_REGION'
|
||||
self.props['typename'] = 'GdkRegion'
|
||||
super(GdkRegionPtrReturn, self).write_conversion()
|
||||
|
||||
argtypes.matcher.register_reverse_ret("GdkRegion*", GdkRegionPtrReturn)
|
||||
|
||||
|
||||
class PangoFontDescriptionReturn(GBoxedReturn):
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return pango_font_description_new();")
|
||||
def write_conversion(self):
|
||||
self.props['typecode'] = 'PANGO_TYPE_FONT_DESCRIPTION'
|
||||
self.props['typename'] = 'PangoFontDescription'
|
||||
super(PangoFontDescriptionReturn, self).write_conversion()
|
||||
|
||||
argtypes.matcher.register_reverse_ret("PangoFontDescription*",
|
||||
PangoFontDescriptionReturn)
|
||||
|
||||
|
||||
class PangoFontMetricsReturn(GBoxedReturn):
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return pango_font_metrics_new();")
|
||||
def write_conversion(self):
|
||||
self.props['typecode'] = 'PANGO_TYPE_FONT_METRICS'
|
||||
self.props['typename'] = 'PangoFontMetrics'
|
||||
super(PangoFontMetricsReturn, self).write_conversion()
|
||||
|
||||
argtypes.matcher.register_reverse_ret("PangoFontMetrics*",
|
||||
PangoFontMetricsReturn)
|
||||
|
||||
|
||||
class PangoLanguageReturn(GBoxedReturn):
|
||||
def write_error_return(self):
|
||||
self.wrapper.write_code("return pango_language_from_string(\"\");")
|
||||
def write_conversion(self):
|
||||
self.props['typecode'] = 'PANGO_TYPE_LANGUAGE'
|
||||
self.props['typename'] = 'PangoLanguage'
|
||||
super(PangoLanguageReturn, self).write_conversion()
|
||||
|
||||
argtypes.matcher.register_reverse_ret("PangoLanguage*", PangoLanguageReturn)
|
||||
|
||||
|
||||
class GdkRectanglePtrParam(Parameter):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type').replace('const-', 'const ')
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(
|
||||
code=('py_%s = pyg_boxed_new(GDK_TYPE_RECTANGLE, %s, TRUE, TRUE);' %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name))
|
||||
self.wrapper.add_pyargv_item("py_%s" % self.name)
|
||||
|
||||
argtypes.matcher.register_reverse("GdkRectangle*", GdkRectanglePtrParam)
|
||||
argtypes.matcher.register_reverse('GtkAllocation*', GdkRectanglePtrParam)
|
||||
|
||||
|
||||
class GErrorParam(Parameter):
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type').replace('**', ' **')
|
||||
def convert_c2py(self):
|
||||
self.wrapper.write_code(code=None,
|
||||
failure_expression=("pyg_gerror_exception_check(%s)" % self.name),
|
||||
code_sink=self.wrapper.check_exception_code)
|
||||
|
||||
argtypes.matcher.register_reverse('GError**', GErrorParam)
|
||||
|
||||
|
||||
class PyGObjectMethodParam(Parameter):
|
||||
def __init__(self, wrapper, name, method_name, **props):
|
||||
Parameter.__init__(self, wrapper, name, **props)
|
||||
self.method_name = method_name
|
||||
|
||||
def get_c_type(self):
|
||||
return self.props.get('c_type', 'GObject *')
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject *py_%s;" % self.name)
|
||||
self.wrapper.write_code(code=("py_%s = pygobject_new((GObject *) %s);" %
|
||||
(self.name, self.name)),
|
||||
cleanup=("Py_DECREF(py_%s);" % self.name),
|
||||
failure_expression=("!py_%s" % self.name))
|
||||
self.wrapper.set_call_target("py_%s" % self.name, self.method_name)
|
||||
|
||||
|
||||
class CallbackInUserDataParam(Parameter):
|
||||
def __init__(self, wrapper, name, free_it, **props):
|
||||
Parameter.__init__(self, wrapper, name, **props)
|
||||
self.free_it = free_it
|
||||
|
||||
def get_c_type(self):
|
||||
return "gpointer"
|
||||
|
||||
def convert_c2py(self):
|
||||
self.wrapper.add_declaration("PyObject **_user_data;")
|
||||
cleanup = self.free_it and ("g_free(%s);" % self.name) or None
|
||||
self.wrapper.write_code(code=("_real_user_data = (PyObject **) %s;"
|
||||
% self.name),
|
||||
cleanup=cleanup)
|
||||
|
||||
self.wrapper.add_declaration("PyObject *py_func;")
|
||||
cleanup = self.free_it and "Py_DECREF(py_func);" or None
|
||||
self.wrapper.write_code(code="py_func = _user_data[0];",
|
||||
cleanup=cleanup)
|
||||
self.wrapper.set_call_target("py_func")
|
||||
|
||||
self.wrapper.add_declaration("PyObject *py_user_data;")
|
||||
cleanup = self.free_it and "Py_XDECREF(py_user_data);" or None
|
||||
self.wrapper.write_code(code="py_user_data = _user_data[1];",
|
||||
cleanup=cleanup)
|
||||
self.wrapper.add_pyargv_item("py_user_data", optional=True)
|
||||
|
||||
def _test():
|
||||
import sys
|
||||
|
||||
if 1:
|
||||
wrapper = ReverseWrapper("this_is_the_c_function_name", is_static=True)
|
||||
wrapper.set_return_type(StringReturn(wrapper))
|
||||
wrapper.add_parameter(PyGObjectMethodParam(wrapper, "self", method_name="do_xxx"))
|
||||
wrapper.add_parameter(StringParam(wrapper, "param2", optional=True))
|
||||
wrapper.add_parameter(GObjectParam(wrapper, "param3"))
|
||||
#wrapper.add_parameter(InoutIntParam(wrapper, "param4"))
|
||||
wrapper.generate(FileCodeSink(sys.stderr))
|
||||
|
||||
if 0:
|
||||
wrapper = ReverseWrapper("this_a_callback_wrapper")
|
||||
wrapper.set_return_type(VoidReturn(wrapper))
|
||||
wrapper.add_parameter(StringParam(wrapper, "param1", optional=False))
|
||||
wrapper.add_parameter(GObjectParam(wrapper, "param2"))
|
||||
wrapper.add_parameter(CallbackInUserDataParam(wrapper, "data", free_it=True))
|
||||
wrapper.generate(FileCodeSink(sys.stderr))
|
||||
|
||||
if __name__ == '__main__':
|
||||
_test()
|
||||
|
|
@ -1,143 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# -*- Mode: Python; py-indent-offset: 4 -*-
|
||||
from __future__ import generators
|
||||
|
||||
import string
|
||||
from cStringIO import StringIO
|
||||
|
||||
class error(Exception):
|
||||
def __init__(self, filename, lineno, msg):
|
||||
Exception.__init__(self, msg)
|
||||
self.filename = filename
|
||||
self.lineno = lineno
|
||||
self.msg = msg
|
||||
def __str__(self):
|
||||
return '%s:%d: error: %s' % (self.filename, self.lineno, self.msg)
|
||||
|
||||
trans = [' '] * 256
|
||||
for i in range(256):
|
||||
if chr(i) in string.letters + string.digits + '_':
|
||||
trans[i] = chr(i)
|
||||
else:
|
||||
trans[i] = '_'
|
||||
trans = string.join(trans, '')
|
||||
|
||||
def parse(filename):
|
||||
if isinstance(filename, str):
|
||||
fp = open(filename, 'r')
|
||||
else: # if not string, assume it is some kind of iterator
|
||||
fp = filename
|
||||
filename = getattr(fp, 'name', '<unknown>')
|
||||
whitespace = ' \t\n\r\x0b\x0c'
|
||||
nonsymbol = whitespace + '();\'"'
|
||||
stack = []
|
||||
openlines = []
|
||||
lineno = 0
|
||||
for line in fp:
|
||||
pos = 0
|
||||
lineno += 1
|
||||
while pos < len(line):
|
||||
if line[pos] in whitespace: # ignore whitespace
|
||||
pass
|
||||
elif line[pos] == ';': # comment
|
||||
break
|
||||
elif line[pos:pos+2] == "'(":
|
||||
pass # the open parenthesis will be handled next iteration
|
||||
elif line[pos] == '(':
|
||||
stack.append(())
|
||||
openlines.append(lineno)
|
||||
elif line[pos] == ')':
|
||||
if len(stack) == 0:
|
||||
raise error(filename, lineno, 'close parenthesis found when none open')
|
||||
closed = stack[-1]
|
||||
del stack[-1]
|
||||
del openlines[-1]
|
||||
if stack:
|
||||
stack[-1] += (closed,)
|
||||
else:
|
||||
yield closed
|
||||
elif line[pos] == '"': # quoted string
|
||||
if not stack:
|
||||
raise error(filename, lineno,
|
||||
'string found outside of s-expression')
|
||||
endpos = pos + 1
|
||||
chars = []
|
||||
while endpos < len(line):
|
||||
if endpos+1 < len(line) and line[endpos] == '\\':
|
||||
endpos += 1
|
||||
if line[endpos] == 'n':
|
||||
chars.append('\n')
|
||||
elif line[endpos] == 'r':
|
||||
chars.append('\r')
|
||||
elif line[endpos] == 't':
|
||||
chars.append('\t')
|
||||
else:
|
||||
chars.append('\\')
|
||||
chars.append(line[endpos])
|
||||
elif line[endpos] == '"':
|
||||
break
|
||||
else:
|
||||
chars.append(line[endpos])
|
||||
endpos += 1
|
||||
if endpos >= len(line):
|
||||
raise error(filename, lineno, "unclosed quoted string")
|
||||
pos = endpos
|
||||
stack[-1] += (''.join(chars),)
|
||||
else: # symbol/number
|
||||
if not stack:
|
||||
raise error(filename, lineno,
|
||||
'identifier found outside of s-expression')
|
||||
endpos = pos
|
||||
while endpos < len(line) and line[endpos] not in nonsymbol:
|
||||
endpos += 1
|
||||
symbol = line[pos:endpos]
|
||||
pos = max(pos, endpos-1)
|
||||
try: symbol = int(symbol)
|
||||
except ValueError:
|
||||
try: symbol = float(symbol)
|
||||
except ValueError: pass
|
||||
stack[-1] += (symbol,)
|
||||
pos += 1
|
||||
if len(stack) != 0:
|
||||
msg = '%d unclosed parentheses found at end of ' \
|
||||
'file (opened on line(s) %s)' % (len(stack),
|
||||
', '.join(map(str, openlines)))
|
||||
raise error(filename, lineno, msg)
|
||||
|
||||
class Parser:
|
||||
def __init__(self, filename):
|
||||
"""Argument is either a string, a parse tree, or file object"""
|
||||
self.filename = filename
|
||||
def startParsing(self, filename=None):
|
||||
statements = parse(filename or self.filename)
|
||||
for statement in statements:
|
||||
self.handle(statement)
|
||||
def handle(self, tup):
|
||||
cmd = string.translate(tup[0], trans)
|
||||
if hasattr(self, cmd):
|
||||
getattr(self, cmd)(*tup[1:])
|
||||
else:
|
||||
self.unknown(tup)
|
||||
def unknown(self, tup):
|
||||
pass
|
||||
|
||||
_testString = """; a scheme file
|
||||
(define-func gdk_font_load ; a comment at end of line
|
||||
GdkFont
|
||||
((string name)))
|
||||
|
||||
(define-boxed GdkEvent
|
||||
gdk_event_copy
|
||||
gdk_event_free
|
||||
"sizeof(GdkEvent)")
|
||||
"""
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys
|
||||
if sys.argv[1:]:
|
||||
fp = open(sys.argv[1])
|
||||
else:
|
||||
fp = StringIO(_testString)
|
||||
statements = parse(fp)
|
||||
for s in statements:
|
||||
print `s`
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
examplesdir = $(pkgdatadir)/$(GST_MAJORMINOR)/examples
|
||||
|
||||
examples_DATA = \
|
||||
simple.py
|
||||
effect.py
|
||||
|
||||
EXTRA_DIST = $(examples_DATA)
|
||||
|
|
@ -1,100 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
#
|
||||
# effect.py
|
||||
#
|
||||
# Copyright (C) 2011 Mathieu Duponchelle <seeed@laposte.net>
|
||||
# Copyright (C) 2011 Luis de Bethencourt <luis.debethencourt@collabora.co.uk>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2.1 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this program; if not, write to the
|
||||
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
# Boston, MA 02111-1307, USA.
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 3, or (at your option)
|
||||
# any later version.
|
||||
|
||||
import sys
|
||||
import optparse
|
||||
|
||||
import glib
|
||||
import gobject
|
||||
gobject.threads_init()
|
||||
|
||||
import gst
|
||||
import ges
|
||||
|
||||
class Effect:
|
||||
def __init__(self, effects):
|
||||
ges.init()
|
||||
self.mainloop = glib.MainLoop()
|
||||
|
||||
self.timeline = ges.timeline_new_audio_video()
|
||||
layer = ges.TimelineLayer()
|
||||
self.src = ges.TimelineTestSource()
|
||||
self.src.set_start(long(0))
|
||||
|
||||
self.src.set_duration(long(3000000000))
|
||||
self.src.set_vpattern("smpte75")
|
||||
layer.add_object(self.src)
|
||||
self.timeline.add_layer(layer)
|
||||
|
||||
self.add_effects(effects)
|
||||
|
||||
self.pipeline = ges.TimelinePipeline()
|
||||
self.pipeline.add_timeline(self.timeline)
|
||||
bus = self.pipeline.get_bus()
|
||||
bus.set_sync_handler(self.bus_handler)
|
||||
|
||||
def add_effects(self, effects):
|
||||
for e in effects:
|
||||
effect = ges.TrackParseLaunchEffect(e)
|
||||
self.src.add_track_object(effect)
|
||||
for track in self.timeline.get_tracks():
|
||||
if track.get_caps().to_string() == \
|
||||
"video/x-raw-yuv; video/x-raw-rgb":
|
||||
print "setting effect: " + e
|
||||
track.add_object(effect)
|
||||
|
||||
def bus_handler(self, unused_bus, message):
|
||||
if message.type == gst.MESSAGE_ERROR:
|
||||
print "ERROR"
|
||||
self.mainloop.quit()
|
||||
elif message.type == gst.MESSAGE_EOS:
|
||||
print "Done"
|
||||
self.mainloop.quit()
|
||||
|
||||
return gst.BUS_PASS
|
||||
|
||||
def run(self):
|
||||
if (self.pipeline.set_state(gst.STATE_PLAYING) == \
|
||||
gst.STATE_CHANGE_FAILURE):
|
||||
print "Couldn't start pipeline"
|
||||
|
||||
self.mainloop.run()
|
||||
|
||||
def main(args):
|
||||
usage = "usage: %s effect_name-1 .. effect_name-n\n" % args[0]
|
||||
|
||||
if len(args) < 2:
|
||||
print usage + "using aging tv as a default instead"
|
||||
args.append("agingtv")
|
||||
|
||||
parser = optparse.OptionParser (usage=usage)
|
||||
(opts, args) = parser.parse_args ()
|
||||
|
||||
effect = Effect(args)
|
||||
effect.run()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(sys.argv)
|
||||
|
|
@ -1,99 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
#
|
||||
# simple.py
|
||||
#
|
||||
# Copyright (C) 2011 Thibault Saunier <thibault.saunier@collabora.co.uk>
|
||||
# Copyright (C) 2011 Luis de Bethencourt <luis.debethencourt@collabora.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2.1 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this program; if not, write to the
|
||||
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
# Boston, MA 02111-1307, USA.
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 3, or (at your option)
|
||||
# any later version.
|
||||
|
||||
import sys
|
||||
import optparse
|
||||
|
||||
import glib
|
||||
import gobject
|
||||
gobject.threads_init()
|
||||
|
||||
import gst
|
||||
import ges
|
||||
|
||||
class Simple:
|
||||
def __init__(self, uris):
|
||||
# init ges to have debug logs
|
||||
ges.init()
|
||||
self.mainloop = glib.MainLoop()
|
||||
|
||||
timeline = ges.timeline_new_audio_video()
|
||||
self.layer = ges.SimpleTimelineLayer()
|
||||
timeline.add_layer(self.layer)
|
||||
|
||||
self.pipeline = ges.TimelinePipeline()
|
||||
self.pipeline.add_timeline(timeline)
|
||||
bus = self.pipeline.get_bus()
|
||||
bus.set_sync_handler(self.bus_handler)
|
||||
|
||||
# all timeline objects except the last will have a transition at the end
|
||||
for n in uris[:-1]:
|
||||
self.add_timeline_object(n, True)
|
||||
self.add_timeline_object(uris[-1], False)
|
||||
|
||||
def add_timeline_object(self, uri, do_transition):
|
||||
filesource = ges.TimelineFileSource (uri)
|
||||
filesource.set_duration(long (gst.SECOND * 5))
|
||||
self.layer.add_object(filesource, -1)
|
||||
|
||||
if do_transition:
|
||||
transition = ges.TimelineStandardTransition("crossfade")
|
||||
transition.duration = gst.SECOND * 2
|
||||
self.layer.add_object(transition, -1)
|
||||
|
||||
def bus_handler(self, unused_bus, message):
|
||||
if message.type == gst.MESSAGE_ERROR:
|
||||
print "ERROR"
|
||||
self.mainloop.quit()
|
||||
elif message.type == gst.MESSAGE_EOS:
|
||||
print "Done"
|
||||
self.mainloop.quit()
|
||||
|
||||
return gst.BUS_PASS
|
||||
|
||||
def run(self):
|
||||
if (self.pipeline.set_state(gst.STATE_PLAYING) == \
|
||||
gst.STATE_CHANGE_FAILURE):
|
||||
print "Couldn't start pipeline"
|
||||
|
||||
self.mainloop.run()
|
||||
|
||||
|
||||
def main(args):
|
||||
usage = "usage: %s URI-OF-VIDEO-1 ... URI-OF-VIDEO-n\n" % args[0]
|
||||
|
||||
if len(args) < 2:
|
||||
sys.stderr.write(usage)
|
||||
sys.exit(1)
|
||||
|
||||
parser = optparse.OptionParser (usage=usage)
|
||||
(options, args) = parser.parse_args ()
|
||||
|
||||
simple = Simple(args)
|
||||
simple.run()
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv))
|
||||
|
|
@ -1,391 +0,0 @@
|
|||
;; -*- scheme -*-
|
||||
; object definitions ...
|
||||
(define-object Formatter
|
||||
(in-module "GES")
|
||||
(parent "GObject")
|
||||
(c-name "GESFormatter")
|
||||
(gtype-id "GES_TYPE_FORMATTER")
|
||||
)
|
||||
|
||||
(define-object KeyfileFormatter
|
||||
(in-module "GES")
|
||||
(parent "GESFormatter")
|
||||
(c-name "GESKeyfileFormatter")
|
||||
(gtype-id "GES_TYPE_KEYFILE_FORMATTER")
|
||||
)
|
||||
|
||||
(define-object Timeline
|
||||
(in-module "GES")
|
||||
(parent "GstBin")
|
||||
(c-name "GESTimeline")
|
||||
(gtype-id "GES_TYPE_TIMELINE")
|
||||
)
|
||||
|
||||
(define-object TimelineLayer
|
||||
(in-module "GES")
|
||||
(parent "GInitiallyUnowned")
|
||||
(c-name "GESTimelineLayer")
|
||||
(gtype-id "GES_TYPE_TIMELINE_LAYER")
|
||||
)
|
||||
|
||||
(define-object SimpleTimelineLayer
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineLayer")
|
||||
(c-name "GESSimpleTimelineLayer")
|
||||
(gtype-id "GES_TYPE_SIMPLE_TIMELINE_LAYER")
|
||||
)
|
||||
|
||||
(define-object TimelineObject
|
||||
(in-module "GES")
|
||||
(parent "GInitiallyUnowned")
|
||||
(c-name "GESTimelineObject")
|
||||
(gtype-id "GES_TYPE_TIMELINE_OBJECT")
|
||||
)
|
||||
|
||||
(define-object TimelineOperation
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineObject")
|
||||
(c-name "GESTimelineOperation")
|
||||
(gtype-id "GES_TYPE_TIMELINE_OPERATION")
|
||||
)
|
||||
|
||||
(define-object TimelineEffect
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineOperation")
|
||||
(c-name "GESTimelineEffect")
|
||||
(gtype-id "GES_TYPE_TIMELINE_EFFECT")
|
||||
)
|
||||
|
||||
(define-object TimelineOverlay
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineOperation")
|
||||
(c-name "GESTimelineOverlay")
|
||||
(gtype-id "GES_TYPE_TIMELINE_OVERLAY")
|
||||
)
|
||||
|
||||
(define-object TimelineParseLaunchEffect
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineEffect")
|
||||
(c-name "GESTimelineParseLaunchEffect")
|
||||
(gtype-id "GES_TYPE_TIMELINE_PARSE_LAUNCH_EFFECT")
|
||||
)
|
||||
|
||||
(define-object TimelinePipeline
|
||||
(in-module "GES")
|
||||
(parent "GstPipeline")
|
||||
(c-name "GESTimelinePipeline")
|
||||
(gtype-id "GES_TYPE_TIMELINE_PIPELINE")
|
||||
)
|
||||
|
||||
(define-object TimelineSource
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineObject")
|
||||
(c-name "GESTimelineSource")
|
||||
(gtype-id "GES_TYPE_TIMELINE_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TimelineFileSource
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineSource")
|
||||
(c-name "GESTimelineFileSource")
|
||||
(gtype-id "GES_TYPE_TIMELINE_FILE_SOURCE")
|
||||
)
|
||||
|
||||
(define-object CustomTimelineSource
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineSource")
|
||||
(c-name "GESCustomTimelineSource")
|
||||
(gtype-id "GES_TYPE_CUSTOM_TIMELINE_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TimelineTestSource
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineSource")
|
||||
(c-name "GESTimelineTestSource")
|
||||
(gtype-id "GES_TYPE_TIMELINE_TEST_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TimelineTextOverlay
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineOverlay")
|
||||
(c-name "GESTimelineTextOverlay")
|
||||
(gtype-id "GES_TYPE_TIMELINE_TEXT_OVERLAY")
|
||||
)
|
||||
|
||||
(define-object TimelineTitleSource
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineSource")
|
||||
(c-name "GESTimelineTitleSource")
|
||||
(gtype-id "GES_TYPE_TIMELINE_TITLE_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TimelineTransition
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineOperation")
|
||||
(c-name "GESTimelineTransition")
|
||||
(gtype-id "GES_TYPE_TIMELINE_TRANSITION")
|
||||
)
|
||||
|
||||
(define-object TimelineStandardTransition
|
||||
(in-module "GES")
|
||||
(parent "GESTimelineTransition")
|
||||
(c-name "GESTimelineStandardTransition")
|
||||
(gtype-id "GES_TYPE_TIMELINE_STANDARD_TRANSITION")
|
||||
)
|
||||
|
||||
(define-object Track
|
||||
(in-module "GES")
|
||||
(parent "GstBin")
|
||||
(c-name "GESTrack")
|
||||
(gtype-id "GES_TYPE_TRACK")
|
||||
)
|
||||
|
||||
(define-object TrackObject
|
||||
(in-module "GES")
|
||||
(parent "GInitiallyUnowned")
|
||||
(c-name "GESTrackObject")
|
||||
(gtype-id "GES_TYPE_TRACK_OBJECT")
|
||||
)
|
||||
|
||||
(define-object TrackOperation
|
||||
(in-module "GES")
|
||||
(parent "GESTrackObject")
|
||||
(c-name "GESTrackOperation")
|
||||
(gtype-id "GES_TYPE_TRACK_OPERATION")
|
||||
)
|
||||
|
||||
(define-object TrackEffect
|
||||
(in-module "GES")
|
||||
(parent "GESTrackOperation")
|
||||
(c-name "GESTrackEffect")
|
||||
(gtype-id "GES_TYPE_TRACK_EFFECT")
|
||||
)
|
||||
|
||||
(define-object TrackParseLaunchEffect
|
||||
(in-module "GES")
|
||||
(parent "GESTrackEffect")
|
||||
(c-name "GESTrackParseLaunchEffect")
|
||||
(gtype-id "GES_TYPE_TRACK_PARSE_LAUNCH_EFFECT")
|
||||
)
|
||||
|
||||
(define-object TrackSource
|
||||
(in-module "GES")
|
||||
(parent "GESTrackObject")
|
||||
(c-name "GESTrackSource")
|
||||
(gtype-id "GES_TYPE_TRACK_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TrackImageSource
|
||||
(in-module "GES")
|
||||
(parent "GESTrackSource")
|
||||
(c-name "GESTrackImageSource")
|
||||
(gtype-id "GES_TYPE_TRACK_IMAGE_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TrackFileSource
|
||||
(in-module "GES")
|
||||
(parent "GESTrackSource")
|
||||
(c-name "GESTrackFileSource")
|
||||
(gtype-id "GES_TYPE_TRACK_FILE_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TrackAudioTestSource
|
||||
(in-module "GES")
|
||||
(parent "GESTrackSource")
|
||||
(c-name "GESTrackAudioTestSource")
|
||||
(gtype-id "GES_TYPE_TRACK_AUDIO_TEST_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TrackTextOverlay
|
||||
(in-module "GES")
|
||||
(parent "GESTrackOperation")
|
||||
(c-name "GESTrackTextOverlay")
|
||||
(gtype-id "GES_TYPE_TRACK_TEXT_OVERLAY")
|
||||
)
|
||||
|
||||
(define-object TrackTitleSource
|
||||
(in-module "GES")
|
||||
(parent "GESTrackSource")
|
||||
(c-name "GESTrackTitleSource")
|
||||
(gtype-id "GES_TYPE_TRACK_TITLE_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TrackTransition
|
||||
(in-module "GES")
|
||||
(parent "GESTrackOperation")
|
||||
(c-name "GESTrackTransition")
|
||||
(gtype-id "GES_TYPE_TRACK_TRANSITION")
|
||||
)
|
||||
|
||||
(define-object TrackAudioTransition
|
||||
(in-module "GES")
|
||||
(parent "GESTrackTransition")
|
||||
(c-name "GESTrackAudioTransition")
|
||||
(gtype-id "GES_TYPE_TRACK_AUDIO_TRANSITION")
|
||||
)
|
||||
|
||||
(define-object TrackVideoTestSource
|
||||
(in-module "GES")
|
||||
(parent "GESTrackSource")
|
||||
(c-name "GESTrackVideoTestSource")
|
||||
(gtype-id "GES_TYPE_TRACK_VIDEO_TEST_SOURCE")
|
||||
)
|
||||
|
||||
(define-object TrackVideoTransition
|
||||
(in-module "GES")
|
||||
(parent "GESTrackTransition")
|
||||
(c-name "GESTrackVideoTransition")
|
||||
(gtype-id "GES_TYPE_TRACK_VIDEO_TRANSITION")
|
||||
)
|
||||
|
||||
;; Enumerations and flags ...
|
||||
|
||||
(define-flags TrackType
|
||||
(in-module "GES")
|
||||
(c-name "GESTrackType")
|
||||
(gtype-id "GES_TYPE_TRACK_TYPE")
|
||||
(values
|
||||
'("unknown" "GES_TRACK_TYPE_UNKNOWN")
|
||||
'("audio" "GES_TRACK_TYPE_AUDIO")
|
||||
'("video" "GES_TRACK_TYPE_VIDEO")
|
||||
'("text" "GES_TRACK_TYPE_TEXT")
|
||||
'("custom" "GES_TRACK_TYPE_CUSTOM")
|
||||
)
|
||||
)
|
||||
|
||||
(define-enum VideoStandardTransitionType
|
||||
(in-module "GES")
|
||||
(c-name "GESVideoStandardTransitionType")
|
||||
(gtype-id "GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE")
|
||||
(values
|
||||
'("none" "GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE")
|
||||
'("bar-wipe-lr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR")
|
||||
'("bar-wipe-tb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB")
|
||||
'("box-wipe-tl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL")
|
||||
'("box-wipe-tr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR")
|
||||
'("box-wipe-br" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR")
|
||||
'("box-wipe-bl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL")
|
||||
'("four-box-wipe-ci" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI")
|
||||
'("four-box-wipe-co" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO")
|
||||
'("barndoor-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V")
|
||||
'("barndoor-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H")
|
||||
'("box-wipe-tc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC")
|
||||
'("box-wipe-rc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC")
|
||||
'("box-wipe-bc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC")
|
||||
'("box-wipe-lc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC")
|
||||
'("diagonal-tl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL")
|
||||
'("diagonal-tr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR")
|
||||
'("bowtie-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V")
|
||||
'("bowtie-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H")
|
||||
'("barndoor-dbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL")
|
||||
'("barndoor-dtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL")
|
||||
'("misc-diagonal-dbd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD")
|
||||
'("misc-diagonal-dd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD")
|
||||
'("vee-d" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D")
|
||||
'("vee-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L")
|
||||
'("vee-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U")
|
||||
'("vee-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R")
|
||||
'("barnvee-d" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D")
|
||||
'("barnvee-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L")
|
||||
'("barnvee-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U")
|
||||
'("barnvee-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R")
|
||||
'("iris-rect" "GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT")
|
||||
'("clock-cw12" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12")
|
||||
'("clock-cw3" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3")
|
||||
'("clock-cw6" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6")
|
||||
'("clock-cw9" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9")
|
||||
'("pinwheel-tbv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV")
|
||||
'("pinwheel-tbh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH")
|
||||
'("pinwheel-fb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB")
|
||||
'("fan-ct" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT")
|
||||
'("fan-cr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR")
|
||||
'("doublefan-fov" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV")
|
||||
'("doublefan-foh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH")
|
||||
'("singlesweep-cwt" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT")
|
||||
'("singlesweep-cwr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR")
|
||||
'("singlesweep-cwb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB")
|
||||
'("singlesweep-cwl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL")
|
||||
'("doublesweep-pv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV")
|
||||
'("doublesweep-pd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD")
|
||||
'("doublesweep-ov" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV")
|
||||
'("doublesweep-oh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH")
|
||||
'("fan-t" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T")
|
||||
'("fan-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R")
|
||||
'("fan-b" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B")
|
||||
'("fan-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L")
|
||||
'("doublefan-fiv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV")
|
||||
'("doublefan-fih" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH")
|
||||
'("singlesweep-cwtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL")
|
||||
'("singlesweep-cwbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL")
|
||||
'("singlesweep-cwbr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR")
|
||||
'("singlesweep-cwtr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR")
|
||||
'("doublesweep-pdtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL")
|
||||
'("doublesweep-pdbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL")
|
||||
'("saloondoor-t" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T")
|
||||
'("saloondoor-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L")
|
||||
'("saloondoor-b" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B")
|
||||
'("saloondoor-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R")
|
||||
'("windshield-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R")
|
||||
'("windshield-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U")
|
||||
'("windshield-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V")
|
||||
'("windshield-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H")
|
||||
'("crossfade" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE")
|
||||
)
|
||||
)
|
||||
|
||||
(define-enum TextVAlign
|
||||
(in-module "GES")
|
||||
(c-name "GESTextVAlign")
|
||||
(gtype-id "GES_TEXT_VALIGN_TYPE")
|
||||
(values
|
||||
'("baseline" "GES_TEXT_VALIGN_BASELINE")
|
||||
'("bottom" "GES_TEXT_VALIGN_BOTTOM")
|
||||
'("top" "GES_TEXT_VALIGN_TOP")
|
||||
)
|
||||
)
|
||||
|
||||
(define-enum TextHAlign
|
||||
(in-module "GES")
|
||||
(c-name "GESTextHAlign")
|
||||
(gtype-id "GES_TEXT_HALIGN_TYPE")
|
||||
(values
|
||||
'("left" "GES_TEXT_HALIGN_LEFT")
|
||||
'("center" "GES_TEXT_HALIGN_CENTER")
|
||||
'("right" "GES_TEXT_HALIGN_RIGHT")
|
||||
)
|
||||
)
|
||||
|
||||
(define-enum VideoTestPattern
|
||||
(in-module "GES")
|
||||
(c-name "GESVideoTestPattern")
|
||||
(gtype-id "GES_VIDEO_TEST_PATTERN_TYPE")
|
||||
(values
|
||||
'("smpte" "GES_VIDEO_TEST_PATTERN_SMPTE")
|
||||
'("snow" "GES_VIDEO_TEST_PATTERN_SNOW")
|
||||
'("black" "GES_VIDEO_TEST_PATTERN_BLACK")
|
||||
'("white" "GES_VIDEO_TEST_PATTERN_WHITE")
|
||||
'("red" "GES_VIDEO_TEST_PATTERN_RED")
|
||||
'("green" "GES_VIDEO_TEST_PATTERN_GREEN")
|
||||
'("blue" "GES_VIDEO_TEST_PATTERN_BLUE")
|
||||
'("checkers1" "GES_VIDEO_TEST_PATTERN_CHECKERS1")
|
||||
'("checkers2" "GES_VIDEO_TEST_PATTERN_CHECKERS2")
|
||||
'("checkers4" "GES_VIDEO_TEST_PATTERN_CHECKERS4")
|
||||
'("checkers8" "GES_VIDEO_TEST_PATTERN_CHECKERS8")
|
||||
'("circular" "GES_VIDEO_TEST_PATTERN_CIRCULAR")
|
||||
'("blink" "GES_VIDEO_TEST_PATTERN_BLINK")
|
||||
'("smpte75" "GES_VIDEO_TEST_PATTERN_SMPTE75")
|
||||
)
|
||||
)
|
||||
|
||||
(define-flags PipelineFlags
|
||||
(in-module "GES")
|
||||
(c-name "GESPipelineFlags")
|
||||
(gtype-id "GES_TYPE_PIPELINE_FLAGS")
|
||||
(values
|
||||
'("preview-audio" "TIMELINE_MODE_PREVIEW_AUDIO")
|
||||
'("preview-video" "TIMELINE_MODE_PREVIEW_VIDEO")
|
||||
'("preview" "TIMELINE_MODE_PREVIEW")
|
||||
'("render" "TIMELINE_MODE_RENDER")
|
||||
'("smart-render" "TIMELINE_MODE_SMART_RENDER")
|
||||
)
|
||||
)
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,401 +0,0 @@
|
|||
/* -*- Mode: C; c-basic-offset: 4 -*- */
|
||||
%%
|
||||
headers
|
||||
#define NO_IMPORT_PYGOBJECT
|
||||
#include <pygobject.h>
|
||||
#include <pygst/pygst.h>
|
||||
|
||||
#include <gst/gst.h>
|
||||
#include <ges/ges.h>
|
||||
#include <pygst/pygst.h>
|
||||
|
||||
#include <glib.h>
|
||||
#include <pyglib.h>
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
/* Boonky define that allows for backwards compatibility with Python 2.4 */
|
||||
#if PY_VERSION_HEX < 0x02050000
|
||||
#define Py_ssize_t int
|
||||
#endif
|
||||
|
||||
void pyges_register_classes(PyObject *d);
|
||||
void pyges_add_constants(PyObject *module, const gchar *strip_prefix);
|
||||
|
||||
%%
|
||||
import gobject.GObject as PyGObject_Type
|
||||
import gobject.MainContext as PyGMainContext_Type
|
||||
import gobject.GObject as PyGInitiallyUnowned_Type
|
||||
import gst.Bin as PyGstBin_Type
|
||||
import gst.Pipeline as PyGstPipeline_Type
|
||||
import gst.Element as PyGstElement_Type
|
||||
import gst.Buffer as PyGstBuffer_Type
|
||||
import gst.Pad as PyGstPad_Type
|
||||
import gst.pbutils.EncodingProfile as PyGstEncodingProfile_Type
|
||||
|
||||
%%
|
||||
override ges_track_get_timeline kwargs
|
||||
static PyObject *
|
||||
_wrap_ges_track_get_timeline(PyGObject *self)
|
||||
{
|
||||
const GESTimeline *ret;
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
ret = ges_track_get_timeline(GES_TRACK(self->obj));
|
||||
pyg_end_allow_threads;
|
||||
/* pygobject_new handles NULL checking */
|
||||
return pygobject_new((GObject *)ret);
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_track_get_caps noargs
|
||||
static PyObject *
|
||||
_wrap_ges_track_get_caps(PyGObject *self, void* closure)
|
||||
{
|
||||
const GstCaps *ret;
|
||||
|
||||
ret = ges_track_get_caps(GES_TRACK(self->obj));
|
||||
|
||||
return pyg_boxed_new (GST_TYPE_CAPS, (GstCaps*) ret, TRUE, TRUE);
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_track_set_caps kwargs
|
||||
static PyObject *
|
||||
_wrap_ges_track_set_caps(PyGObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
static char *kwlist[] = { "caps", NULL };
|
||||
PyObject *py_caps;
|
||||
GstCaps *caps;
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstBuffer.set_caps", kwlist, &py_caps))
|
||||
return NULL;
|
||||
|
||||
caps = pyg_boxed_get (py_caps, GstCaps);
|
||||
if (PyErr_Occurred())
|
||||
return NULL;
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
ges_track_set_caps (GES_TRACK(self->obj), caps);
|
||||
pyg_end_allow_threads;
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
%%
|
||||
new-constructor GES_TYPE_TRACK
|
||||
%%
|
||||
override ges_track_new kwargs
|
||||
static int
|
||||
_wrap_ges_track_new(PyGObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
static char *kwlist[] = { "type", "caps", NULL };
|
||||
PyObject *py_type = NULL;
|
||||
GESTrackType type;
|
||||
GstCaps *caps;
|
||||
PyObject *py_caps;
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:GES.Track.__init__", kwlist, &py_type, &py_caps))
|
||||
return -1;
|
||||
if (pyg_flags_get_value(GES_TYPE_TRACK_TYPE, py_type, (gpointer)&type))
|
||||
return -1;
|
||||
caps = pyg_boxed_get (py_caps, GstCaps);
|
||||
self->obj = (GObject *)ges_track_new(type, caps);
|
||||
|
||||
if (!self->obj) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "could not create GESTrack object");
|
||||
return -1;
|
||||
}
|
||||
pygobject_register_wrapper((PyObject *)self);
|
||||
return 0;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_track_object_lookup_child kwargs
|
||||
static PyObject *
|
||||
_wrap_ges_track_object_lookup_child(PyGObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
static char *kwlist[] = {"name", NULL};
|
||||
char *name = NULL;
|
||||
GParamSpec *pspec;
|
||||
GstElement *element;
|
||||
gboolean ret;
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
|
||||
"z:GES.TrackObject.lookup_child", kwlist, &name))
|
||||
return FALSE;
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
ret = ges_track_object_lookup_child (GES_TRACK_OBJECT (self->obj), name, &element, &pspec);
|
||||
pyg_end_allow_threads;
|
||||
|
||||
if (!ret)
|
||||
return PyBool_FromLong(ret);
|
||||
return pygobject_new((GObject *)element);
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_timeline_parse_launch_effect_new kwargs
|
||||
static int
|
||||
_wrap_ges_timeline_parse_launch_effect_new(PyGObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
static char *kwlist[] = { "video_bin_description", "audio_bin_description", NULL };
|
||||
char *video_bin_description, *audio_bin_description = NULL;
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"zz:GES.TimelineParseLaunchEffect.__init__", kwlist, &video_bin_description, &audio_bin_description))
|
||||
return -1;
|
||||
self->obj = (GObject *)ges_timeline_parse_launch_effect_new(video_bin_description, audio_bin_description);
|
||||
|
||||
if (!self->obj) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "could not create GESTimelineParseLaunchEffect object");
|
||||
return -1;
|
||||
}
|
||||
pygobject_register_wrapper((PyObject *)self);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* I did not override ges_formatter_get_data and set_data for these functions are deprecated */
|
||||
|
||||
%%
|
||||
override ges_timeline_object_get_top_effects noargs
|
||||
static PyObject *
|
||||
_wrap_ges_timeline_object_get_top_effects(PyGObject *self)
|
||||
{
|
||||
const GList *l, *list;
|
||||
PyObject *py_list;
|
||||
|
||||
g_return_val_if_fail (GES_IS_TIMELINE_OBJECT (self->obj),PyList_New(0));
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
list = ges_timeline_object_get_top_effects(GES_TIMELINE_OBJECT(self->obj));
|
||||
pyg_end_allow_threads;
|
||||
|
||||
py_list = PyList_New(0);
|
||||
for (l = list; l; l = l->next) {
|
||||
GESTrackEffect *track_effect = (GESTrackEffect*)l->data;
|
||||
PyObject *py_track_effect = pygobject_new(G_OBJECT(track_effect));
|
||||
PyList_Append(py_list, py_track_effect);
|
||||
Py_DECREF(py_track_effect);
|
||||
}
|
||||
|
||||
return py_list;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_timeline_get_tracks noargs
|
||||
static PyObject *
|
||||
_wrap_ges_timeline_get_tracks(PyGObject *self)
|
||||
{
|
||||
const GList *l, *list;
|
||||
PyObject *py_list;
|
||||
|
||||
g_return_val_if_fail (GES_IS_TIMELINE (self->obj),PyList_New(0));
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
list = ges_timeline_get_tracks(GES_TIMELINE(self->obj));
|
||||
pyg_end_allow_threads;
|
||||
|
||||
py_list = PyList_New(0);
|
||||
for (l = list; l; l = l->next) {
|
||||
GESTrack *track = (GESTrack*)l->data;
|
||||
PyObject *py_track = pygobject_new(G_OBJECT(track));
|
||||
PyList_Append(py_list, py_track);
|
||||
Py_DECREF(py_track);
|
||||
}
|
||||
|
||||
return py_list;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_timeline_get_layers noargs
|
||||
static PyObject *
|
||||
_wrap_ges_timeline_get_layers(PyGObject *self)
|
||||
{
|
||||
const GList *l, *list;
|
||||
PyObject *py_list;
|
||||
|
||||
g_return_val_if_fail (GES_IS_TIMELINE (self->obj), PyList_New(0));
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
list = ges_timeline_get_layers(GES_TIMELINE(self->obj));
|
||||
pyg_end_allow_threads;
|
||||
|
||||
py_list = PyList_New(0);
|
||||
for (l = list; l; l = l->next) {
|
||||
GESTimelineLayer *layer = (GESTimelineLayer*)l->data;
|
||||
PyObject *py_layer = pygobject_new(G_OBJECT(layer));
|
||||
PyList_Append(py_list, py_layer);
|
||||
Py_DECREF(py_layer);
|
||||
}
|
||||
|
||||
return py_list;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_timeline_layer_get_objects noargs
|
||||
static PyObject *
|
||||
_wrap_ges_timeline_layer_get_objects(PyGObject *self)
|
||||
{
|
||||
const GList *l, *list;
|
||||
PyObject *py_list;
|
||||
|
||||
g_return_val_if_fail (GES_IS_TIMELINE_LAYER (self->obj), PyList_New(0));
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
list = ges_timeline_layer_get_objects(GES_TIMELINE_LAYER(self->obj));
|
||||
pyg_end_allow_threads;
|
||||
|
||||
py_list = PyList_New(0);
|
||||
for (l = list; l; l = l->next) {
|
||||
GESTimelineObject *object = (GESTimelineObject*)l->data;
|
||||
PyObject *py_object = pygobject_new(G_OBJECT(object));
|
||||
PyList_Append(py_list, py_object);
|
||||
Py_DECREF(py_object);
|
||||
}
|
||||
|
||||
return py_list;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_timeline_object_get_track_objects noargs
|
||||
static PyObject *
|
||||
_wrap_ges_timeline_object_get_track_objects(PyGObject *self)
|
||||
{
|
||||
const GList *l, *list;
|
||||
PyObject *py_list;
|
||||
|
||||
g_return_val_if_fail (GES_IS_TIMELINE_OBJECT (self->obj), PyList_New(0));
|
||||
|
||||
pyg_begin_allow_threads;
|
||||
list = ges_timeline_object_get_track_objects(GES_TIMELINE_OBJECT(self->obj));
|
||||
pyg_end_allow_threads;
|
||||
|
||||
py_list = PyList_New(0);
|
||||
for (l = list; l; l = l->next) {
|
||||
GESTrackObject *object = (GESTrackObject*)l->data;
|
||||
PyObject *py_object = pygobject_new(G_OBJECT(object));
|
||||
PyList_Append(py_list, py_object);
|
||||
Py_DECREF(py_object);
|
||||
}
|
||||
|
||||
return py_list;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_track_object_get_child_property kwargs
|
||||
static PyObject *
|
||||
_wrap_ges_track_object_get_child_property (PyGObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
gchar *property_name;
|
||||
GESTrackObject *obj = GES_TRACK_OBJECT (self->obj);
|
||||
|
||||
GParamSpec *pspec = NULL;
|
||||
GValue value = { 0, } ;
|
||||
PyObject *ret;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s:GESTrackObject.get_child_property",
|
||||
&property_name)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ges_track_object_lookup_child(obj, property_name, NULL, &pspec);
|
||||
if (!pspec) {
|
||||
gchar buf[512];
|
||||
g_snprintf(buf, sizeof(buf),
|
||||
"container does not support property `%s'",
|
||||
property_name);
|
||||
|
||||
PyErr_SetString(PyExc_TypeError, buf);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(pspec));
|
||||
|
||||
ges_track_object_get_child_property_by_pspec(obj,
|
||||
pspec,
|
||||
&value);
|
||||
|
||||
ret = pyg_value_as_pyobject(&value, TRUE);
|
||||
g_value_unset(&value);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_track_object_set_child_property kwargs
|
||||
static PyObject *
|
||||
_wrap_ges_track_object_set_child_property (PyGObject *self, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
gchar *property_name;
|
||||
GESTrackObject *obj = GES_TRACK_OBJECT (self->obj);
|
||||
|
||||
GParamSpec *pspec = NULL;
|
||||
PyGObject *pyvalue;
|
||||
GValue value = { 0, } ;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "sO:GESTrackObject.set_child_property",
|
||||
&property_name, &pyvalue)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ges_track_object_lookup_child(obj, property_name, NULL, &pspec);
|
||||
if (!pspec) {
|
||||
gchar buf[512];
|
||||
g_snprintf(buf, sizeof(buf),
|
||||
"container does not support property `%s'",
|
||||
property_name);
|
||||
|
||||
PyErr_SetString(PyExc_TypeError, buf);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(pspec));
|
||||
pyg_value_from_pyobject(&value, (PyObject*)pyvalue);
|
||||
|
||||
ges_track_object_set_child_property_by_pspec(obj,
|
||||
pspec,
|
||||
&value);
|
||||
|
||||
g_value_unset(&value);
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
%%
|
||||
override ges_track_object_list_children_properties noargs
|
||||
static PyObject *
|
||||
_wrap_ges_track_object_list_children_properties (PyGObject *self)
|
||||
{
|
||||
GParamSpec **specs;
|
||||
PyObject *list;
|
||||
guint nprops;
|
||||
guint i;
|
||||
|
||||
specs = ges_track_object_list_children_properties(GES_TRACK_OBJECT (self->obj), &nprops);
|
||||
list = PyTuple_New(nprops);
|
||||
if (list == NULL) {
|
||||
g_free(specs);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < nprops; i++) {
|
||||
PyTuple_SetItem(list, i, pyg_param_spec_new(specs[i]));
|
||||
}
|
||||
|
||||
g_free(specs);
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
%%
|
||||
ignore-glob
|
||||
|
||||
*_get_type
|
||||
ges_formatter_set_data
|
||||
ges_formatter_set_data
|
||||
*_valist
|
||||
*_by_pspec
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
/* -*- Mode: C; c-basic-offset: 4 -*- */
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
#include <Python.h>
|
||||
#include <pygobject.h>
|
||||
#include <pyglib.h>
|
||||
#include <pygst/pygst.h>
|
||||
|
||||
/* include any extra headers needed here */
|
||||
|
||||
void pyges_register_classes (PyObject * d);
|
||||
extern PyMethodDef pyges_functions[];
|
||||
DL_EXPORT (void)
|
||||
initges (void);
|
||||
|
||||
DL_EXPORT (void)
|
||||
initges (void)
|
||||
{
|
||||
PyObject *m, *d;
|
||||
|
||||
/* perform any initialisation required by the library here */
|
||||
|
||||
m = Py_InitModule ("ges", pyges_functions);
|
||||
d = PyModule_GetDict (m);
|
||||
|
||||
init_pygobject ();
|
||||
pygst_init ();
|
||||
|
||||
pygst_init ();
|
||||
pyges_register_classes (d);
|
||||
|
||||
/* add anything else to the module dictionary (such as constants) */
|
||||
|
||||
if (PyErr_Occurred ())
|
||||
Py_FatalError ("could not initialise module ges");
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
EXTRA_DIST = \
|
||||
common.py \
|
||||
test_timeline_pipeline.py \
|
||||
test_timeline.py \
|
||||
runtests.py \
|
||||
test_global_functions.py \
|
||||
test_timeline_test_source.py \
|
||||
test_layer.py \
|
||||
test_timeline_title_source.py \
|
||||
test_simple_layer.py \
|
||||
test_track.py \
|
||||
test_textoverlay.py \
|
||||
test_transition.py \
|
||||
test_timeline_file_source.py \
|
||||
test_timeline_parse_launch_effect.py
|
||||
|
||||
check:
|
||||
@PYTHONPATH=$(top_builddir):$(top_builddir)/bindings/python/.libs:`pwd`:$(top_srcdir):$(PYTHONPATH) $(PYTHON) $(srcdir)/runtests.py
|
||||
@rm -fr *.pyc
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
# -*- Mode: Python -*-
|
||||
# vi:si:et:sw=4:sts=4:ts=4
|
||||
#
|
||||
# gst-python - Python bindings for GStreamer
|
||||
# Copyright (C) 2002 David I. Lehn
|
||||
# Copyright (C) 2004 Johan Dahlin
|
||||
# Copyright (C) 2005 Edward Hervey
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2.1 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this library; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
import os
|
||||
import sys
|
||||
import gc
|
||||
import unittest
|
||||
import gst
|
||||
|
||||
import gobject
|
||||
try:
|
||||
gobject.threads_init()
|
||||
except:
|
||||
print "WARNING: gobject doesn't have threads_init, no threadsafety"
|
||||
|
||||
def disable_stderr():
|
||||
global _stderr
|
||||
_stderr = file('/tmp/stderr', 'w+')
|
||||
sys.stderr = os.fdopen(os.dup(2), 'w')
|
||||
os.close(2)
|
||||
os.dup(_stderr.fileno())
|
||||
|
||||
def enable_stderr():
|
||||
global _stderr
|
||||
|
||||
os.close(2)
|
||||
os.dup(sys.stderr.fileno())
|
||||
_stderr.seek(0, 0)
|
||||
data = _stderr.read()
|
||||
_stderr.close()
|
||||
os.remove('/tmp/stderr')
|
||||
return data
|
||||
|
||||
def run_silent(function, *args, **kwargs):
|
||||
disable_stderr()
|
||||
|
||||
try:
|
||||
function(*args, **kwargs)
|
||||
except Exception, exc:
|
||||
enable_stderr()
|
||||
raise exc
|
||||
|
||||
output = enable_stderr()
|
||||
|
||||
return output
|
||||
|
||||
class TestCase(unittest.TestCase):
|
||||
|
||||
_types = [gst.Object, gst.MiniObject]
|
||||
|
||||
def gccollect(self):
|
||||
# run the garbage collector
|
||||
ret = 0
|
||||
gst.debug('garbage collecting')
|
||||
while True:
|
||||
c = gc.collect()
|
||||
ret += c
|
||||
if c == 0: break
|
||||
gst.debug('done garbage collecting, %d objects' % ret)
|
||||
return ret
|
||||
|
||||
def gctrack(self):
|
||||
# store all gst objects in the gc in a tracking dict
|
||||
# call before doing any allocation in your test, from setUp
|
||||
gst.debug('tracking gc GstObjects for types %r' % self._types)
|
||||
self.gccollect()
|
||||
self._tracked = {}
|
||||
for c in self._types:
|
||||
self._tracked[c] = [o for o in gc.get_objects() if isinstance(o, c)]
|
||||
|
||||
def gcverify(self):
|
||||
# verify no new gst objects got added to the gc
|
||||
# call after doing all cleanup in your test, from tearDown
|
||||
gst.debug('verifying gc GstObjects for types %r' % self._types)
|
||||
new = []
|
||||
for c in self._types:
|
||||
objs = [o for o in gc.get_objects() if isinstance(o, c)]
|
||||
new.extend([o for o in objs if o not in self._tracked[c]])
|
||||
|
||||
self.failIf(new, new)
|
||||
#self.failIf(new, ["%r:%d" % (type(o), id(o)) for o in new])
|
||||
del self._tracked
|
||||
|
||||
def setUp(self):
|
||||
"""
|
||||
Override me by chaining up to me at the start of your setUp.
|
||||
"""
|
||||
# Using private variables is BAD ! this variable changed name in
|
||||
# python 2.5
|
||||
try:
|
||||
methodName = self.__testMethodName
|
||||
except:
|
||||
methodName = self._testMethodName
|
||||
gst.debug('%s.%s' % (self.__class__.__name__, methodName))
|
||||
self.gctrack()
|
||||
|
||||
def tearDown(self):
|
||||
"""
|
||||
Override me by chaining up to me at the end of your tearDown.
|
||||
"""
|
||||
# Using private variables is BAD ! this variable changed name in
|
||||
# python 2.5
|
||||
try:
|
||||
methodName = self.__testMethodName
|
||||
except:
|
||||
methodName = self._testMethodName
|
||||
gst.debug('%s.%s' % (self.__class__.__name__, methodName))
|
||||
self.gccollect()
|
||||
self.gcverify()
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
import glob
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
SKIP_FILES = ['common', 'runtests']
|
||||
|
||||
os.environ['LC_MESSAGES'] = 'C'
|
||||
|
||||
def gettestnames(which):
|
||||
if not which:
|
||||
dir = os.path.split(os.path.abspath(__file__))[0]
|
||||
which = [os.path.basename(p) for p in glob.glob('%s/test_*.py' % dir)]
|
||||
|
||||
names = map(lambda x: x[:-3], which)
|
||||
for f in SKIP_FILES:
|
||||
if f in names:
|
||||
names.remove(f)
|
||||
return names
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
for name in gettestnames(sys.argv[1:]):
|
||||
suite.addTest(loader.loadTestsFromName(name))
|
||||
|
||||
descriptions = 1
|
||||
verbosity = 1
|
||||
if os.environ.has_key('VERBOSE'):
|
||||
descriptions = 2
|
||||
verbosity = 2
|
||||
|
||||
testRunner = unittest.TextTestRunner(descriptions=descriptions,
|
||||
verbosity=verbosity)
|
||||
result = testRunner.run(suite)
|
||||
if result.failures or result.errors:
|
||||
sys.exit(1)
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
import glib
|
||||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class GlobalFunctions(TestCase):
|
||||
|
||||
def testGlobalFunctions(self):
|
||||
tl = ges.timeline_new_audio_video()
|
||||
tr = ges.timeline_standard_transition_new_for_nick("crossfade")
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
import glib
|
||||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class Layer(TestCase):
|
||||
|
||||
def testLayer(self):
|
||||
lyr = ges.TimelineLayer()
|
||||
tl = ges.Timeline()
|
||||
src = ges.TimelineTestSource()
|
||||
|
||||
lyr.set_timeline(tl)
|
||||
|
||||
assert (lyr.add_object(src) == True)
|
||||
self.failIf(len (lyr.get_objects()) != 1)
|
||||
assert (lyr.remove_object(src) == True)
|
||||
|
||||
lyr.set_priority(1)
|
||||
self.failIf(lyr.get_priority() != 1)
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
import glib
|
||||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class SimpleLayer(TestCase):
|
||||
|
||||
def testSimpleLayer(self):
|
||||
lyr = ges.SimpleTimelineLayer()
|
||||
tl = ges.Timeline()
|
||||
src = ges.TimelineTestSource()
|
||||
src2 = ges.TimelineTestSource()
|
||||
|
||||
lyr.set_timeline(tl)
|
||||
|
||||
assert (lyr.add_object(src, 0) == True)
|
||||
assert (lyr.add_object(src2, 1) == True)
|
||||
assert (lyr.nth(0) == src)
|
||||
assert (lyr.move_object (src, 1) == True)
|
||||
self.failIf(lyr.index(src) != 1)
|
||||
assert (lyr.is_valid() == True)
|
||||
|
|
@ -1,60 +0,0 @@
|
|||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
from time import sleep
|
||||
|
||||
class TextOverlay(TestCase):
|
||||
|
||||
def testTextOverlay(self):
|
||||
|
||||
ovrl = ges.TimelineTextOverlay()
|
||||
lyr = ges.TimelineLayer()
|
||||
tl = ges.timeline_new_audio_video()
|
||||
tck = tl.get_tracks()[0]
|
||||
|
||||
ovrl.set_text("Foo")
|
||||
self.failIf (ovrl.get_text() != "Foo")
|
||||
ovrl.set_font_desc ("Arial")
|
||||
self.failIf (ovrl.get_font_desc() != "Arial")
|
||||
ovrl.set_valign("top")
|
||||
self.failIf (ovrl.get_valignment().value_name != "top")
|
||||
ovrl.set_halign("left")
|
||||
self.failIf (ovrl.get_halignment().value_name != "left")
|
||||
|
||||
#We will test Timeline Object class functions here
|
||||
|
||||
ovrl.set_start(long(100))
|
||||
ovrl.set_inpoint(long(50))
|
||||
ovrl.set_duration(long(500))
|
||||
ovrl.set_priority(2)
|
||||
ovrl.set_layer(lyr)
|
||||
tck_obj = ovrl.create_track_object(tck)
|
||||
self.failIf (ovrl.release_track_object(tck_obj) != True)
|
||||
self.failIf (ovrl.add_track_object(tck_obj) != True)
|
||||
self.failIf (len(ovrl.get_track_objects()) != 1)
|
||||
self.failIf (ovrl.get_layer() != lyr)
|
||||
ovrl.release_track_object(tck_obj)
|
||||
|
||||
#We test TrackTextOverlay and TrackObject here
|
||||
tck_obj.set_text("Bar")
|
||||
self.failIf (tck_obj.get_text() != "Bar")
|
||||
tck_obj.set_font_desc ("Arial")
|
||||
self.failIf (tck_obj.get_font_desc() != "Arial")
|
||||
tck_obj.set_valignment("top")
|
||||
self.failIf (tck_obj.get_valignment().value_name != "top")
|
||||
tck_obj.set_halignment("left")
|
||||
self.failIf (tck_obj.get_halignment().value_name != "left")
|
||||
|
||||
tck_obj.set_locked(False)
|
||||
self.failIf (tck_obj.is_locked() != False)
|
||||
tck_obj.set_start(long(100))
|
||||
tck_obj.set_inpoint(long(50))
|
||||
tck_obj.set_duration(long(500))
|
||||
tck_obj.set_priority(2)
|
||||
self.failIf (tck_obj.get_start() != 100)
|
||||
self.failIf (tck_obj.get_inpoint() != 50)
|
||||
self.failIf (tck_obj.get_duration() != 500)
|
||||
self.failIf (tck_obj.get_priority() != 2)
|
||||
tck_obj.set_timeline_object(ovrl)
|
||||
self.failIf(tck_obj.get_timeline_object() != ovrl)
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
import glib
|
||||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class Timeline(TestCase):
|
||||
|
||||
def testTimeline(self):
|
||||
|
||||
tl = ges.timeline_new_audio_video()
|
||||
lyr = ges.SimpleTimelineLayer()
|
||||
tck = ges.track_audio_raw_new()
|
||||
|
||||
assert (tl.add_track(tck) == True)
|
||||
#We should have two tracks from the timeline_new_audio_video() function + 1
|
||||
self.failIf(len(tl.get_tracks()) != 3)
|
||||
assert (tl.remove_track(tck) == True)
|
||||
|
||||
assert (tl.add_layer(lyr) == True)
|
||||
self.failIf(len(tl.get_layers()) != 1)
|
||||
assert (tl.remove_layer(lyr) == True)
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class TimelineFileSource(TestCase):
|
||||
|
||||
def testTimelineFileSource(self):
|
||||
src = ges.TimelineFileSource("file://blahblahblah")
|
||||
|
||||
src.set_mute(True)
|
||||
src.set_max_duration(long(100))
|
||||
src.set_supported_formats("video")
|
||||
assert (src.get_supported_formats().value_nicks[0] == "video")
|
||||
src.set_is_image(True)
|
||||
assert (src.get_max_duration() == 100)
|
||||
assert (src.is_image() == True)
|
||||
assert (src.get_uri() == "file://blahblahblah")
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
from time import sleep
|
||||
|
||||
class ParseLaunchEffect(TestCase):
|
||||
|
||||
def testParseLaunchEffect(self):
|
||||
tl = ges.Timeline()
|
||||
tck = ges.track_video_raw_new()
|
||||
lyr = ges.TimelineLayer()
|
||||
efct = ges.TimelineParseLaunchEffect("agingtv", None)
|
||||
tck_efct = ges.TrackParseLaunchEffect("agingtv")
|
||||
|
||||
tl.add_layer(lyr)
|
||||
efct.add_track_object(tck_efct)
|
||||
lyr.add_object(efct)
|
||||
tck.set_timeline(tl)
|
||||
tck.add_object(tck_efct)
|
||||
tck_efct.set_child_property("GstAgingTV::scratch-lines", 17)
|
||||
self.failIf(tck_efct.get_child_property("GstAgingTV::scratch-lines") != 17)
|
||||
self.failIf(len(tck_efct.list_children_properties()) != 6)
|
||||
self.failIf (tck_efct.lookup_child ("scratch-lines") == None)
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
import glib
|
||||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class TimelinePipeline(TestCase):
|
||||
|
||||
def testTimelinePipeline(self):
|
||||
stgs = gst.pbutils.EncodingAudioProfile(gst.Caps("video/x-dirac"), "test", gst.caps_new_any(), 0)
|
||||
ppln = ges.TimelinePipeline()
|
||||
tl = ges.Timeline()
|
||||
assert (ppln.add_timeline (tl) == True)
|
||||
assert (ppln.set_mode("TIMELINE_MODE_PREVIEW_AUDIO") == True)
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
import glib
|
||||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class TimelineTestSource(TestCase):
|
||||
|
||||
def testTimelineTestSource(self):
|
||||
src = ges.TimelineTestSource()
|
||||
tck_src = ges.TrackAudioTestSource()
|
||||
src.set_mute(True)
|
||||
src.set_vpattern("snow")
|
||||
src.set_frequency(880)
|
||||
src.set_volume (1)
|
||||
assert (src.get_vpattern() != None)
|
||||
assert (src.is_muted() == True)
|
||||
assert (src.get_frequency() == 880)
|
||||
assert (src.get_volume() == 1)
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class TimelineTitleSource(TestCase):
|
||||
|
||||
def testTimelineTitleSource(self):
|
||||
src = ges.TimelineTitleSource()
|
||||
lyr = ges.TimelineLayer()
|
||||
tck = ges.track_video_raw_new()
|
||||
|
||||
src.set_text("Foo")
|
||||
self.failIf (src.get_text() != "Foo")
|
||||
src.set_font_desc ("Arial")
|
||||
self.failIf (src.get_font_desc() != "Arial")
|
||||
src.set_valignment("top")
|
||||
assert (src.get_valignment().value_name == "top")
|
||||
src.set_halignment("left")
|
||||
assert (src.get_halignment().value_name == "left")
|
||||
src.set_mute(True)
|
||||
assert (src.is_muted() == True)
|
||||
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class Track(TestCase):
|
||||
|
||||
def testTrack(self):
|
||||
tck = ges.track_video_raw_new()
|
||||
tl = ges.Timeline()
|
||||
lyr = ges.TimelineLayer()
|
||||
src = ges.TimelineTestSource()
|
||||
caps = gst.caps_from_string("image/jpeg")
|
||||
obj = ges.TrackParseLaunchEffect ("agingtv")
|
||||
|
||||
tl.add_layer(lyr)
|
||||
src.add_track_object(obj)
|
||||
lyr.add_object(src)
|
||||
tck.set_timeline(tl)
|
||||
|
||||
assert (tck.add_object(obj) == True)
|
||||
assert (tck.get_timeline() == tl)
|
||||
tck.set_caps(caps)
|
||||
assert (tck.get_caps().to_string() == "image/jpeg")
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
import glib
|
||||
import gst
|
||||
|
||||
from common import TestCase
|
||||
import ges
|
||||
|
||||
class Timeline(TestCase):
|
||||
|
||||
def testTimeline(self):
|
||||
|
||||
tl = ges.timeline_new_audio_video()
|
||||
lyr = ges.SimpleTimelineLayer()
|
||||
src = ges.TimelineTestSource()
|
||||
src2 = ges.TimelineTestSource()
|
||||
tr = ges.TimelineStandardTransition("crossfade")
|
||||
pip = ges.TimelinePipeline()
|
||||
bus = pip.get_bus()
|
||||
self.mainloop = glib.MainLoop()
|
||||
|
||||
# Let's add the layer to the timeline, and the sources
|
||||
# and transition to the layer.
|
||||
|
||||
tl.add_layer(lyr)
|
||||
src.set_duration(long(gst.SECOND * 10))
|
||||
src2.set_duration(long(gst.SECOND * 10))
|
||||
src.set_vpattern("Random (television snow)")
|
||||
tr.set_duration(long(gst.SECOND * 10))
|
||||
|
||||
lyr.add_object(src, -1)
|
||||
lyr.add_object(tr, -1)
|
||||
assert (lyr.add_object(src2, -1) == True)
|
||||
|
||||
pip.add_timeline(tl)
|
||||
bus.set_sync_handler(self.bus_handler)
|
||||
|
||||
self.pipeline = pip
|
||||
self.layer = lyr
|
||||
|
||||
#Mainloop is finished, tear down.
|
||||
self.pipeline = None
|
||||
|
||||
|
||||
def bus_handler(self, unused_bus, message):
|
||||
if message.type == gst.MESSAGE_ERROR:
|
||||
print "ERROR"
|
||||
self.mainloop.quit()
|
||||
elif message.type == gst.MESSAGE_EOS:
|
||||
print "Done"
|
||||
self.mainloop.quit()
|
||||
return gst.BUS_PASS
|
||||
54
configure.ac
54
configure.ac
|
|
@ -115,57 +115,8 @@ GOBJECT_INTROSPECTION_CHECK([0.9.6])
|
|||
dnl check for documentation tools
|
||||
AG_GST_DOCBOOK_CHECK
|
||||
GTK_DOC_CHECK([1.3])
|
||||
AS_PATH_PYTHON([2.1])
|
||||
AG_GST_PLUGIN_DOCS([1.3],[2.1])
|
||||
|
||||
dnl check for python
|
||||
AM_PATH_PYTHON
|
||||
AC_MSG_CHECKING(for python >= 2.3)
|
||||
prog="
|
||||
import sys, string
|
||||
minver = (2,3,0,'final',0)
|
||||
if sys.version_info < minver:
|
||||
sys.exit(1)
|
||||
sys.exit(0)"
|
||||
|
||||
if $PYTHON -c "$prog" 1>&AC_FD_CC 2>&AC_FD_CC
|
||||
then
|
||||
HAVE_PYTHON=yes
|
||||
AC_MSG_RESULT(okay)
|
||||
else
|
||||
HAVE_PYTHON=no
|
||||
AC_MSG_RESULT(no python)
|
||||
fi
|
||||
|
||||
AM_CHECK_PYTHON_HEADERS([HAVE_PYTHON_HEADERS=yes],[HAVE_PYTHON_HEADERS=no])
|
||||
|
||||
dnl check for pygobject (optional, used in the bindings)
|
||||
PYGOBJECT_REQ=2.11.2
|
||||
PKG_CHECK_MODULES(PYGOBJECT, pygobject-2.0 >= $PYGOBJECT_REQ,
|
||||
[HAVE_PYGOBJECT="yes"], [HAVE_PYGOBJECT="no"])
|
||||
AC_SUBST(PYGOBJECT_CFLAGS)
|
||||
|
||||
dnl check for gst-python
|
||||
PKG_CHECK_MODULES(PYGST, gst-python-0.10,
|
||||
[HAVE_PYGST="yes"], [HAVE_PYGST="no"])
|
||||
|
||||
if test "x$HAVE_PYGST" = "xyes"; then
|
||||
PYGST_DEFSDIR=`pkg-config gst-python-0.10 --variable=defsdir`
|
||||
fi
|
||||
AC_SUBST(PYGST_DEFSDIR, $PYGST_DEFSDIR)
|
||||
|
||||
if test \
|
||||
"x$HAVE_PYTHON" = "xyes" -a \
|
||||
"x$HAVE_PYTHON_HEADERS" = "xyes" -a \
|
||||
"x$HAVE_PYGOBJECT" = "xyes" -a \
|
||||
"x$HAVE_PYGST" = "xyes"; then
|
||||
HAVE_PYTHON_BINDINGS="yes"
|
||||
else
|
||||
HAVE_PYTHON_BINDINGS="no"
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(WITH_PYTHON, [test "x$HAVE_PYTHON_BINDINGS" = "xyes"])
|
||||
|
||||
dnl *** checks for libraries ***
|
||||
|
||||
dnl check for libm, for sin() etc.
|
||||
|
|
@ -350,11 +301,6 @@ common/m4/Makefile
|
|||
gst-editing-services.spec
|
||||
m4/Makefile
|
||||
ges/Makefile
|
||||
bindings/Makefile
|
||||
bindings/python/Makefile
|
||||
bindings/python/codegen/Makefile
|
||||
bindings/python/examples/Makefile
|
||||
bindings/python/testsuite/Makefile
|
||||
tests/Makefile
|
||||
tests/check/Makefile
|
||||
tests/examples/Makefile
|
||||
|
|
|
|||
Loading…
Reference in a new issue