mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-06 01:16:17 +01:00
013980d839
The python interpreter found by `/usr/bin/env python3` is not
necessarily the same installation as the one that's found by meson's
`pymod.find_installation('python')`. This means that even though meson
is checking that the python installation it found includes the
'packaging' module, the scripts might not have access to that module
when run.
For distribution packaging, it's usually desirable to have python script
interpreters be fully specified paths, rather than use `/usr/bin/env`,
to ensure the scripts run using the expected python installation (i.e.
the one where the python 'packaging' dependency is installed).
The easiest way to fix this is to set the script interpreter to the
`full_path()` of the python interpreter found by meson. The specific
python interpreter that will be used can be selected through the use of
a meson machine file by overriding the "python" program. Many
distributions already have this set up using meson packaging helpers.
1081 lines
40 KiB
Plaintext
Executable File
1081 lines
40 KiB
Plaintext
Executable File
#!@PYTHON@
|
|
|
|
# pylint: disable=too-many-lines, missing-docstring, invalid-name
|
|
|
|
# This file is part of GLib
|
|
#
|
|
# 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, see <http://www.gnu.org/licenses/>.
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
VERSION_STR = '''glib-genmarshal version @VERSION@
|
|
glib-genmarshal comes with ABSOLUTELY NO WARRANTY.
|
|
You may redistribute copies of glib-genmarshal under the terms of
|
|
the GNU General Public License which can be found in the
|
|
GLib source package. Sources, examples and contact
|
|
information are available at http://www.gtk.org'''
|
|
|
|
GETTERS_STR = '''#ifdef G_ENABLE_DEBUG
|
|
#define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
|
|
#define g_marshal_value_peek_char(v) g_value_get_schar (v)
|
|
#define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
|
|
#define g_marshal_value_peek_int(v) g_value_get_int (v)
|
|
#define g_marshal_value_peek_uint(v) g_value_get_uint (v)
|
|
#define g_marshal_value_peek_long(v) g_value_get_long (v)
|
|
#define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
|
|
#define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
|
|
#define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
|
|
#define g_marshal_value_peek_enum(v) g_value_get_enum (v)
|
|
#define g_marshal_value_peek_flags(v) g_value_get_flags (v)
|
|
#define g_marshal_value_peek_float(v) g_value_get_float (v)
|
|
#define g_marshal_value_peek_double(v) g_value_get_double (v)
|
|
#define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
|
|
#define g_marshal_value_peek_param(v) g_value_get_param (v)
|
|
#define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
|
|
#define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
|
|
#define g_marshal_value_peek_object(v) g_value_get_object (v)
|
|
#define g_marshal_value_peek_variant(v) g_value_get_variant (v)
|
|
#else /* !G_ENABLE_DEBUG */
|
|
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
|
|
* Do not access GValues directly in your code. Instead, use the
|
|
* g_value_get_*() functions
|
|
*/
|
|
#define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
|
|
#define g_marshal_value_peek_char(v) (v)->data[0].v_int
|
|
#define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
|
|
#define g_marshal_value_peek_int(v) (v)->data[0].v_int
|
|
#define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
|
|
#define g_marshal_value_peek_long(v) (v)->data[0].v_long
|
|
#define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
|
|
#define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
|
|
#define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
|
|
#define g_marshal_value_peek_enum(v) (v)->data[0].v_long
|
|
#define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong
|
|
#define g_marshal_value_peek_float(v) (v)->data[0].v_float
|
|
#define g_marshal_value_peek_double(v) (v)->data[0].v_double
|
|
#define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
|
|
#define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
|
|
#define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
|
|
#define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
|
|
#define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
|
|
#define g_marshal_value_peek_variant(v) (v)->data[0].v_pointer
|
|
#endif /* !G_ENABLE_DEBUG */'''
|
|
|
|
DEPRECATED_MSG_STR = 'The token "{}" is deprecated; use "{}" instead'
|
|
|
|
VA_ARG_STR = \
|
|
' arg{:d} = ({:s}) va_arg (args_copy, {:s});'
|
|
STATIC_CHECK_STR = \
|
|
'(param_types[{:d}] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && '
|
|
BOX_TYPED_STR = \
|
|
' arg{idx:d} = {box_func} (param_types[{idx:d}] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg{idx:d});'
|
|
BOX_UNTYPED_STR = \
|
|
' arg{idx:d} = {box_func} (arg{idx:d});'
|
|
UNBOX_TYPED_STR = \
|
|
' {unbox_func} (param_types[{idx:d}] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg{idx:d});'
|
|
UNBOX_UNTYPED_STR = \
|
|
' {unbox_func} (arg{idx:d});'
|
|
|
|
STD_PREFIX = 'g_cclosure_marshal'
|
|
|
|
# These are part of our ABI; keep this in sync with gmarshal.h
|
|
GOBJECT_MARSHALLERS = {
|
|
'g_cclosure_marshal_VOID__VOID',
|
|
'g_cclosure_marshal_VOID__BOOLEAN',
|
|
'g_cclosure_marshal_VOID__CHAR',
|
|
'g_cclosure_marshal_VOID__UCHAR',
|
|
'g_cclosure_marshal_VOID__INT',
|
|
'g_cclosure_marshal_VOID__UINT',
|
|
'g_cclosure_marshal_VOID__LONG',
|
|
'g_cclosure_marshal_VOID__ULONG',
|
|
'g_cclosure_marshal_VOID__ENUM',
|
|
'g_cclosure_marshal_VOID__FLAGS',
|
|
'g_cclosure_marshal_VOID__FLOAT',
|
|
'g_cclosure_marshal_VOID__DOUBLE',
|
|
'g_cclosure_marshal_VOID__STRING',
|
|
'g_cclosure_marshal_VOID__PARAM',
|
|
'g_cclosure_marshal_VOID__BOXED',
|
|
'g_cclosure_marshal_VOID__POINTER',
|
|
'g_cclosure_marshal_VOID__OBJECT',
|
|
'g_cclosure_marshal_VOID__VARIANT',
|
|
'g_cclosure_marshal_VOID__UINT_POINTER',
|
|
'g_cclosure_marshal_BOOLEAN__FLAGS',
|
|
'g_cclosure_marshal_STRING__OBJECT_POINTER',
|
|
'g_cclosure_marshal_BOOLEAN__BOXED_BOXED',
|
|
}
|
|
|
|
|
|
# pylint: disable=too-few-public-methods
|
|
class Color:
|
|
'''ANSI Terminal colors'''
|
|
GREEN = '\033[1;32m'
|
|
BLUE = '\033[1;34m'
|
|
YELLOW = '\033[1;33m'
|
|
RED = '\033[1;31m'
|
|
END = '\033[0m'
|
|
|
|
|
|
def print_color(msg, color=Color.END, prefix='MESSAGE'):
|
|
'''Print a string with a color prefix'''
|
|
if os.isatty(sys.stderr.fileno()):
|
|
real_prefix = '{start}{prefix}{end}'.format(start=color, prefix=prefix, end=Color.END)
|
|
else:
|
|
real_prefix = prefix
|
|
sys.stderr.write('{prefix}: {msg}\n'.format(prefix=real_prefix, msg=msg))
|
|
|
|
|
|
def print_error(msg):
|
|
'''Print an error, and terminate'''
|
|
print_color(msg, color=Color.RED, prefix='ERROR')
|
|
sys.exit(1)
|
|
|
|
|
|
def print_warning(msg, fatal=False):
|
|
'''Print a warning, and optionally terminate'''
|
|
if fatal:
|
|
color = Color.RED
|
|
prefix = 'ERROR'
|
|
else:
|
|
color = Color.YELLOW
|
|
prefix = 'WARNING'
|
|
print_color(msg, color, prefix)
|
|
if fatal:
|
|
sys.exit(1)
|
|
|
|
|
|
def print_info(msg):
|
|
'''Print a message'''
|
|
print_color(msg, color=Color.GREEN, prefix='INFO')
|
|
|
|
|
|
def generate_licensing_comment(outfile):
|
|
outfile.write('/* This file is generated by glib-genmarshal, do not '
|
|
'modify it. This code is licensed under the same license as '
|
|
'the containing project. Note that it links to GLib, so '
|
|
'must comply with the LGPL linking clauses. */\n')
|
|
|
|
|
|
def generate_header_preamble(outfile, prefix='', std_includes=True, use_pragma=False):
|
|
'''Generate the preamble for the marshallers header file'''
|
|
generate_licensing_comment(outfile)
|
|
|
|
if use_pragma:
|
|
outfile.write('#pragma once\n')
|
|
outfile.write('\n')
|
|
else:
|
|
outfile.write('#ifndef __{}_MARSHAL_H__\n'.format(prefix.upper()))
|
|
outfile.write('#define __{}_MARSHAL_H__\n'.format(prefix.upper()))
|
|
outfile.write('\n')
|
|
# Maintain compatibility with the old C-based tool
|
|
if std_includes:
|
|
outfile.write('#include <glib-object.h>\n')
|
|
outfile.write('\n')
|
|
|
|
outfile.write('G_BEGIN_DECLS\n')
|
|
outfile.write('\n')
|
|
|
|
|
|
def generate_header_postamble(outfile, prefix='', use_pragma=False):
|
|
'''Generate the postamble for the marshallers header file'''
|
|
outfile.write('\n')
|
|
outfile.write('G_END_DECLS\n')
|
|
|
|
if not use_pragma:
|
|
outfile.write('\n')
|
|
outfile.write('#endif /* __{}_MARSHAL_H__ */\n'.format(prefix.upper()))
|
|
|
|
|
|
def generate_body_preamble(outfile, std_includes=True, include_headers=None, cpp_defines=None, cpp_undefines=None):
|
|
'''Generate the preamble for the marshallers source file'''
|
|
generate_licensing_comment(outfile)
|
|
|
|
for header in (include_headers or []):
|
|
outfile.write('#include "{}"\n'.format(header))
|
|
if include_headers:
|
|
outfile.write('\n')
|
|
|
|
for define in (cpp_defines or []):
|
|
s = define.split('=')
|
|
symbol = s[0]
|
|
value = s[1] if len(s) > 1 else '1'
|
|
outfile.write('#define {} {}\n'.format(symbol, value))
|
|
if cpp_defines:
|
|
outfile.write('\n')
|
|
|
|
for undefine in (cpp_undefines or []):
|
|
outfile.write('#undef {}\n'.format(undefine))
|
|
if cpp_undefines:
|
|
outfile.write('\n')
|
|
|
|
if std_includes:
|
|
outfile.write('#include <glib-object.h>\n')
|
|
outfile.write('\n')
|
|
|
|
outfile.write(GETTERS_STR)
|
|
outfile.write('\n\n')
|
|
|
|
|
|
# Marshaller arguments, as a dictionary where the key is the token used in
|
|
# the source file, and the value is another dictionary with the following
|
|
# keys:
|
|
#
|
|
# - signal: the token used in the marshaller prototype (mandatory)
|
|
# - ctype: the C type for the marshaller argument (mandatory)
|
|
# - getter: the function used to retrieve the argument from the GValue
|
|
# array when invoking the callback (optional)
|
|
# - promoted: the C type used by va_arg() to retrieve the argument from
|
|
# the va_list when invoking the callback (optional, only used when
|
|
# generating va_list marshallers)
|
|
# - box: an array of two elements, containing the boxing and unboxing
|
|
# functions for the given type (optional, only used when generating
|
|
# va_list marshallers)
|
|
# - static-check: a boolean value, if the given type should perform
|
|
# a static type check before boxing or unboxing the argument (optional,
|
|
# only used when generating va_list marshallers)
|
|
# - takes-type: a boolean value, if the boxing and unboxing functions
|
|
# for the given type require the type (optional, only used when
|
|
# generating va_list marshallers)
|
|
# - deprecated: whether the token has been deprecated (optional)
|
|
# - replaced-by: the token used to replace a deprecated token (optional,
|
|
# only used if deprecated is True)
|
|
IN_ARGS = {
|
|
'VOID': {
|
|
'signal': 'VOID',
|
|
'ctype': 'void',
|
|
},
|
|
'BOOLEAN': {
|
|
'signal': 'BOOLEAN',
|
|
'ctype': 'gboolean',
|
|
'getter': 'g_marshal_value_peek_boolean',
|
|
},
|
|
'CHAR': {
|
|
'signal': 'CHAR',
|
|
'ctype': 'gchar',
|
|
'promoted': 'gint',
|
|
'getter': 'g_marshal_value_peek_char',
|
|
},
|
|
'UCHAR': {
|
|
'signal': 'UCHAR',
|
|
'ctype': 'guchar',
|
|
'promoted': 'guint',
|
|
'getter': 'g_marshal_value_peek_uchar',
|
|
},
|
|
'INT': {
|
|
'signal': 'INT',
|
|
'ctype': 'gint',
|
|
'getter': 'g_marshal_value_peek_int',
|
|
},
|
|
'UINT': {
|
|
'signal': 'UINT',
|
|
'ctype': 'guint',
|
|
'getter': 'g_marshal_value_peek_uint',
|
|
},
|
|
'LONG': {
|
|
'signal': 'LONG',
|
|
'ctype': 'glong',
|
|
'getter': 'g_marshal_value_peek_long',
|
|
},
|
|
'ULONG': {
|
|
'signal': 'ULONG',
|
|
'ctype': 'gulong',
|
|
'getter': 'g_marshal_value_peek_ulong',
|
|
},
|
|
'INT64': {
|
|
'signal': 'INT64',
|
|
'ctype': 'gint64',
|
|
'getter': 'g_marshal_value_peek_int64',
|
|
},
|
|
'UINT64': {
|
|
'signal': 'UINT64',
|
|
'ctype': 'guint64',
|
|
'getter': 'g_marshal_value_peek_uint64',
|
|
},
|
|
'ENUM': {
|
|
'signal': 'ENUM',
|
|
'ctype': 'gint',
|
|
'getter': 'g_marshal_value_peek_enum',
|
|
},
|
|
'FLAGS': {
|
|
'signal': 'FLAGS',
|
|
'ctype': 'guint',
|
|
'getter': 'g_marshal_value_peek_flags',
|
|
},
|
|
'FLOAT': {
|
|
'signal': 'FLOAT',
|
|
'ctype': 'gfloat',
|
|
'promoted': 'gdouble',
|
|
'getter': 'g_marshal_value_peek_float',
|
|
},
|
|
'DOUBLE': {
|
|
'signal': 'DOUBLE',
|
|
'ctype': 'gdouble',
|
|
'getter': 'g_marshal_value_peek_double',
|
|
},
|
|
'STRING': {
|
|
'signal': 'STRING',
|
|
'ctype': 'gpointer',
|
|
'getter': 'g_marshal_value_peek_string',
|
|
'box': ['g_strdup', 'g_free'],
|
|
'static-check': True,
|
|
},
|
|
'PARAM': {
|
|
'signal': 'PARAM',
|
|
'ctype': 'gpointer',
|
|
'getter': 'g_marshal_value_peek_param',
|
|
'box': ['g_param_spec_ref', 'g_param_spec_unref'],
|
|
'static-check': True,
|
|
},
|
|
'BOXED': {
|
|
'signal': 'BOXED',
|
|
'ctype': 'gpointer',
|
|
'getter': 'g_marshal_value_peek_boxed',
|
|
'box': ['g_boxed_copy', 'g_boxed_free'],
|
|
'static-check': True,
|
|
'takes-type': True,
|
|
},
|
|
'POINTER': {
|
|
'signal': 'POINTER',
|
|
'ctype': 'gpointer',
|
|
'getter': 'g_marshal_value_peek_pointer',
|
|
},
|
|
'OBJECT': {
|
|
'signal': 'OBJECT',
|
|
'ctype': 'gpointer',
|
|
'getter': 'g_marshal_value_peek_object',
|
|
'box': ['g_object_ref', 'g_object_unref'],
|
|
},
|
|
'VARIANT': {
|
|
'signal': 'VARIANT',
|
|
'ctype': 'gpointer',
|
|
'getter': 'g_marshal_value_peek_variant',
|
|
'box': ['g_variant_ref_sink', 'g_variant_unref'],
|
|
'static-check': True,
|
|
'takes-type': False,
|
|
},
|
|
|
|
# Deprecated tokens
|
|
'NONE': {
|
|
'signal': 'VOID',
|
|
'ctype': 'void',
|
|
'deprecated': True,
|
|
'replaced_by': 'VOID'
|
|
},
|
|
'BOOL': {
|
|
'signal': 'BOOLEAN',
|
|
'ctype': 'gboolean',
|
|
'getter': 'g_marshal_value_peek_boolean',
|
|
'deprecated': True,
|
|
'replaced_by': 'BOOLEAN'
|
|
}
|
|
}
|
|
|
|
|
|
# Marshaller return values, as a dictionary where the key is the token used
|
|
# in the source file, and the value is another dictionary with the following
|
|
# keys:
|
|
#
|
|
# - signal: the token used in the marshaller prototype (mandatory)
|
|
# - ctype: the C type for the marshaller argument (mandatory)
|
|
# - setter: the function used to set the return value of the callback
|
|
# into a GValue (optional)
|
|
# - deprecated: whether the token has been deprecated (optional)
|
|
# - replaced-by: the token used to replace a deprecated token (optional,
|
|
# only used if deprecated is True)
|
|
OUT_ARGS = {
|
|
'VOID': {
|
|
'signal': 'VOID',
|
|
'ctype': 'void',
|
|
},
|
|
'BOOLEAN': {
|
|
'signal': 'BOOLEAN',
|
|
'ctype': 'gboolean',
|
|
'setter': 'g_value_set_boolean',
|
|
},
|
|
'CHAR': {
|
|
'signal': 'CHAR',
|
|
'ctype': 'gchar',
|
|
'setter': 'g_value_set_char',
|
|
},
|
|
'UCHAR': {
|
|
'signal': 'UCHAR',
|
|
'ctype': 'guchar',
|
|
'setter': 'g_value_set_uchar',
|
|
},
|
|
'INT': {
|
|
'signal': 'INT',
|
|
'ctype': 'gint',
|
|
'setter': 'g_value_set_int',
|
|
},
|
|
'UINT': {
|
|
'signal': 'UINT',
|
|
'ctype': 'guint',
|
|
'setter': 'g_value_set_uint',
|
|
},
|
|
'LONG': {
|
|
'signal': 'LONG',
|
|
'ctype': 'glong',
|
|
'setter': 'g_value_set_long',
|
|
},
|
|
'ULONG': {
|
|
'signal': 'ULONG',
|
|
'ctype': 'gulong',
|
|
'setter': 'g_value_set_ulong',
|
|
},
|
|
'INT64': {
|
|
'signal': 'INT64',
|
|
'ctype': 'gint64',
|
|
'setter': 'g_value_set_int64',
|
|
},
|
|
'UINT64': {
|
|
'signal': 'UINT64',
|
|
'ctype': 'guint64',
|
|
'setter': 'g_value_set_uint64',
|
|
},
|
|
'ENUM': {
|
|
'signal': 'ENUM',
|
|
'ctype': 'gint',
|
|
'setter': 'g_value_set_enum',
|
|
},
|
|
'FLAGS': {
|
|
'signal': 'FLAGS',
|
|
'ctype': 'guint',
|
|
'setter': 'g_value_set_flags',
|
|
},
|
|
'FLOAT': {
|
|
'signal': 'FLOAT',
|
|
'ctype': 'gfloat',
|
|
'setter': 'g_value_set_float',
|
|
},
|
|
'DOUBLE': {
|
|
'signal': 'DOUBLE',
|
|
'ctype': 'gdouble',
|
|
'setter': 'g_value_set_double',
|
|
},
|
|
'STRING': {
|
|
'signal': 'STRING',
|
|
'ctype': 'gchar*',
|
|
'setter': 'g_value_take_string',
|
|
},
|
|
'PARAM': {
|
|
'signal': 'PARAM',
|
|
'ctype': 'GParamSpec*',
|
|
'setter': 'g_value_take_param',
|
|
},
|
|
'BOXED': {
|
|
'signal': 'BOXED',
|
|
'ctype': 'gpointer',
|
|
'setter': 'g_value_take_boxed',
|
|
},
|
|
'POINTER': {
|
|
'signal': 'POINTER',
|
|
'ctype': 'gpointer',
|
|
'setter': 'g_value_set_pointer',
|
|
},
|
|
'OBJECT': {
|
|
'signal': 'OBJECT',
|
|
'ctype': 'GObject*',
|
|
'setter': 'g_value_take_object',
|
|
},
|
|
'VARIANT': {
|
|
'signal': 'VARIANT',
|
|
'ctype': 'GVariant*',
|
|
'setter': 'g_value_take_variant',
|
|
},
|
|
|
|
# Deprecated tokens
|
|
'NONE': {
|
|
'signal': 'VOID',
|
|
'ctype': 'void',
|
|
'setter': None,
|
|
'deprecated': True,
|
|
'replaced_by': 'VOID',
|
|
},
|
|
'BOOL': {
|
|
'signal': 'BOOLEAN',
|
|
'ctype': 'gboolean',
|
|
'setter': 'g_value_set_boolean',
|
|
'deprecated': True,
|
|
'replaced_by': 'BOOLEAN',
|
|
},
|
|
}
|
|
|
|
|
|
def check_args(retval, params, fatal_warnings=False):
|
|
'''Check the @retval and @params tokens for invalid and deprecated symbols.'''
|
|
if retval not in OUT_ARGS:
|
|
print_error('Unknown return value type "{}"'.format(retval))
|
|
|
|
if OUT_ARGS[retval].get('deprecated', False):
|
|
replaced_by = OUT_ARGS[retval]['replaced_by']
|
|
print_warning(DEPRECATED_MSG_STR.format(retval, replaced_by), fatal_warnings)
|
|
|
|
for param in params:
|
|
if param not in IN_ARGS:
|
|
print_error('Unknown parameter type "{}"'.format(param))
|
|
else:
|
|
if IN_ARGS[param].get('deprecated', False):
|
|
replaced_by = IN_ARGS[param]['replaced_by']
|
|
print_warning(DEPRECATED_MSG_STR.format(param, replaced_by), fatal_warnings)
|
|
|
|
|
|
def indent(text, level=0, fill=' '):
|
|
'''Indent @text by @level columns, using the @fill character'''
|
|
return ''.join([fill for x in range(level)]) + text
|
|
|
|
|
|
# pylint: disable=too-few-public-methods
|
|
class Visibility:
|
|
'''Symbol visibility options'''
|
|
NONE = 0
|
|
INTERNAL = 1
|
|
EXTERN = 2
|
|
|
|
|
|
def generate_marshaller_name(prefix, retval, params, replace_deprecated=True):
|
|
'''Generate a marshaller name for the given @prefix, @retval, and @params.
|
|
If @replace_deprecated is True, the generated name will replace deprecated
|
|
tokens.'''
|
|
if replace_deprecated:
|
|
real_retval = OUT_ARGS[retval]['signal']
|
|
real_params = []
|
|
for param in params:
|
|
real_params.append(IN_ARGS[param]['signal'])
|
|
else:
|
|
real_retval = retval
|
|
real_params = params
|
|
return '{prefix}_{retval}__{args}'.format(prefix=prefix,
|
|
retval=real_retval,
|
|
args='_'.join(real_params))
|
|
|
|
|
|
def generate_prototype(retval, params,
|
|
prefix='g_cclosure_user_marshal',
|
|
visibility=Visibility.NONE,
|
|
va_marshal=False):
|
|
'''Generate a marshaller declaration with the given @visibility. If @va_marshal
|
|
is True, the marshaller will use variadic arguments in place of a GValue array.'''
|
|
signature = []
|
|
|
|
if visibility == Visibility.INTERNAL:
|
|
signature += ['G_GNUC_INTERNAL']
|
|
elif visibility == Visibility.EXTERN:
|
|
signature += ['extern']
|
|
|
|
function_name = generate_marshaller_name(prefix, retval, params)
|
|
|
|
if not va_marshal:
|
|
signature += ['void ' + function_name + ' (GClosure *closure,']
|
|
width = len('void ') + len(function_name) + 2
|
|
|
|
signature += [indent('GValue *return_value,', level=width, fill=' ')]
|
|
signature += [indent('guint n_param_values,', level=width, fill=' ')]
|
|
signature += [indent('const GValue *param_values,', level=width, fill=' ')]
|
|
signature += [indent('gpointer invocation_hint,', level=width, fill=' ')]
|
|
signature += [indent('gpointer marshal_data);', level=width, fill=' ')]
|
|
else:
|
|
signature += ['void ' + function_name + 'v (GClosure *closure,']
|
|
width = len('void ') + len(function_name) + 3
|
|
|
|
signature += [indent('GValue *return_value,', level=width, fill=' ')]
|
|
signature += [indent('gpointer instance,', level=width, fill=' ')]
|
|
signature += [indent('va_list args,', level=width, fill=' ')]
|
|
signature += [indent('gpointer marshal_data,', level=width, fill=' ')]
|
|
signature += [indent('int n_params,', level=width, fill=' ')]
|
|
signature += [indent('GType *param_types);', level=width, fill=' ')]
|
|
|
|
return signature
|
|
|
|
|
|
# pylint: disable=too-many-statements, too-many-locals, too-many-branches
|
|
def generate_body(retval, params, prefix, va_marshal=False):
|
|
'''Generate a marshaller definition. If @va_marshal is True, the marshaller
|
|
will use va_list and variadic arguments in place of a GValue array.'''
|
|
retval_setter = OUT_ARGS[retval].get('setter', None)
|
|
# If there's no return value then we can mark the retval argument as unused
|
|
# and get a minor optimisation, as well as avoid a compiler warning
|
|
if not retval_setter:
|
|
unused = ' G_GNUC_UNUSED'
|
|
else:
|
|
unused = ''
|
|
|
|
body = ['void']
|
|
|
|
function_name = generate_marshaller_name(prefix, retval, params)
|
|
|
|
if not va_marshal:
|
|
body += [function_name + ' (GClosure *closure,']
|
|
width = len(function_name) + 2
|
|
|
|
body += [indent('GValue *return_value{},'.format(unused), level=width, fill=' ')]
|
|
body += [indent('guint n_param_values,', level=width, fill=' ')]
|
|
body += [indent('const GValue *param_values,', level=width, fill=' ')]
|
|
body += [indent('gpointer invocation_hint G_GNUC_UNUSED,', level=width, fill=' ')]
|
|
body += [indent('gpointer marshal_data)', level=width, fill=' ')]
|
|
else:
|
|
body += [function_name + 'v (GClosure *closure,']
|
|
width = len(function_name) + 3
|
|
|
|
body += [indent('GValue *return_value{},'.format(unused), level=width, fill=' ')]
|
|
body += [indent('gpointer instance,', level=width, fill=' ')]
|
|
body += [indent('va_list args,', level=width, fill=' ')]
|
|
body += [indent('gpointer marshal_data,', level=width, fill=' ')]
|
|
body += [indent('int n_params,', level=width, fill=' ')]
|
|
body += [indent('GType *param_types)', level=width, fill=' ')]
|
|
|
|
# Filter the arguments that have a getter
|
|
get_args = [x for x in params if IN_ARGS[x].get('getter', None) is not None]
|
|
|
|
body += ['{']
|
|
|
|
# Generate the type of the marshaller function
|
|
typedef_marshal = generate_marshaller_name('GMarshalFunc', retval, params)
|
|
|
|
typedef = ' typedef {ctype} (*{func_name}) ('.format(ctype=OUT_ARGS[retval]['ctype'],
|
|
func_name=typedef_marshal)
|
|
pad = len(typedef)
|
|
typedef += 'gpointer data1,'
|
|
body += [typedef]
|
|
|
|
for idx, in_arg in enumerate(get_args):
|
|
body += [indent('{} arg{:d},'.format(IN_ARGS[in_arg]['ctype'], idx + 1), level=pad)]
|
|
|
|
body += [indent('gpointer data2);', level=pad)]
|
|
|
|
# Variable declarations
|
|
body += [' GCClosure *cc = (GCClosure *) closure;']
|
|
body += [' gpointer data1, data2;']
|
|
body += [' {} callback;'.format(typedef_marshal)]
|
|
|
|
if retval_setter:
|
|
body += [' {} v_return;'.format(OUT_ARGS[retval]['ctype'])]
|
|
|
|
if va_marshal:
|
|
for idx, arg in enumerate(get_args):
|
|
body += [' {} arg{:d};'.format(IN_ARGS[arg]['ctype'], idx)]
|
|
|
|
if get_args:
|
|
body += [' va_list args_copy;']
|
|
body += ['']
|
|
|
|
body += [' va_copy (args_copy, args);']
|
|
|
|
for idx, arg in enumerate(get_args):
|
|
ctype = IN_ARGS[arg]['ctype']
|
|
promoted_ctype = IN_ARGS[arg].get('promoted', ctype)
|
|
body += [VA_ARG_STR.format(idx, ctype, promoted_ctype)]
|
|
if IN_ARGS[arg].get('box', None):
|
|
box_func = IN_ARGS[arg]['box'][0]
|
|
if IN_ARGS[arg].get('static-check', False):
|
|
static_check = STATIC_CHECK_STR.format(idx)
|
|
else:
|
|
static_check = ''
|
|
arg_check = 'arg{:d} != NULL'.format(idx)
|
|
body += [' if ({}{})'.format(static_check, arg_check)]
|
|
if IN_ARGS[arg].get('takes-type', False):
|
|
body += [BOX_TYPED_STR.format(idx=idx, box_func=box_func)]
|
|
else:
|
|
body += [BOX_UNTYPED_STR.format(idx=idx, box_func=box_func)]
|
|
|
|
body += [' va_end (args_copy);']
|
|
|
|
body += ['']
|
|
|
|
# Preconditions check
|
|
if retval_setter:
|
|
body += [' g_return_if_fail (return_value != NULL);']
|
|
|
|
if not va_marshal:
|
|
body += [' g_return_if_fail (n_param_values == {:d});'.format(len(get_args) + 1)]
|
|
|
|
body += ['']
|
|
|
|
# Marshal instance, data, and callback set up
|
|
body += [' if (G_CCLOSURE_SWAP_DATA (closure))']
|
|
body += [' {']
|
|
body += [' data1 = closure->data;']
|
|
if va_marshal:
|
|
body += [' data2 = instance;']
|
|
else:
|
|
body += [' data2 = g_value_peek_pointer (param_values + 0);']
|
|
body += [' }']
|
|
body += [' else']
|
|
body += [' {']
|
|
if va_marshal:
|
|
body += [' data1 = instance;']
|
|
else:
|
|
body += [' data1 = g_value_peek_pointer (param_values + 0);']
|
|
body += [' data2 = closure->data;']
|
|
body += [' }']
|
|
# pylint: disable=line-too-long
|
|
body += [' callback = ({}) (marshal_data ? marshal_data : cc->callback);'.format(typedef_marshal)]
|
|
body += ['']
|
|
|
|
# Marshal callback action
|
|
if retval_setter:
|
|
callback = ' {} callback ('.format(' v_return =')
|
|
else:
|
|
callback = ' callback ('
|
|
|
|
pad = len(callback)
|
|
body += [callback + 'data1,']
|
|
|
|
if va_marshal:
|
|
for idx, arg in enumerate(get_args):
|
|
body += [indent('arg{:d},'.format(idx), level=pad)]
|
|
else:
|
|
for idx, arg in enumerate(get_args):
|
|
arg_getter = IN_ARGS[arg]['getter']
|
|
body += [indent('{} (param_values + {:d}),'.format(arg_getter, idx + 1), level=pad)]
|
|
|
|
body += [indent('data2);', level=pad)]
|
|
|
|
if va_marshal:
|
|
boxed_args = [x for x in get_args if IN_ARGS[x].get('box', None) is not None]
|
|
if not boxed_args:
|
|
body += ['']
|
|
else:
|
|
for idx, arg in enumerate(get_args):
|
|
if not IN_ARGS[arg].get('box', None):
|
|
continue
|
|
unbox_func = IN_ARGS[arg]['box'][1]
|
|
if IN_ARGS[arg].get('static-check', False):
|
|
static_check = STATIC_CHECK_STR.format(idx)
|
|
else:
|
|
static_check = ''
|
|
arg_check = 'arg{:d} != NULL'.format(idx)
|
|
body += [' if ({}{})'.format(static_check, arg_check)]
|
|
if IN_ARGS[arg].get('takes-type', False):
|
|
body += [UNBOX_TYPED_STR.format(idx=idx, unbox_func=unbox_func)]
|
|
else:
|
|
body += [UNBOX_UNTYPED_STR.format(idx=idx, unbox_func=unbox_func)]
|
|
|
|
if retval_setter:
|
|
body += ['']
|
|
body += [' {} (return_value, v_return);'.format(retval_setter)]
|
|
|
|
body += ['}']
|
|
|
|
return body
|
|
|
|
|
|
def generate_marshaller_alias(outfile, marshaller, real_marshaller,
|
|
include_va=False,
|
|
source_location=None):
|
|
'''Generate an alias between @marshaller and @real_marshaller, including
|
|
an optional alias for va_list marshallers'''
|
|
if source_location:
|
|
outfile.write('/* {} */\n'.format(source_location))
|
|
|
|
outfile.write('#define {}\t{}\n'.format(marshaller, real_marshaller))
|
|
|
|
if include_va:
|
|
outfile.write('#define {}v\t{}v\n'.format(marshaller, real_marshaller))
|
|
|
|
outfile.write('\n')
|
|
|
|
|
|
def generate_marshallers_header(outfile, retval, params,
|
|
prefix='g_cclosure_user_marshal',
|
|
internal=False,
|
|
include_va=False, source_location=None):
|
|
'''Generate a declaration for a marshaller function, to be used in the header,
|
|
with the given @retval, @params, and @prefix. An optional va_list marshaller
|
|
for the same arguments is also generated. The generated buffer is written to
|
|
the @outfile stream object.'''
|
|
if source_location:
|
|
outfile.write('/* {} */\n'.format(source_location))
|
|
|
|
if internal:
|
|
visibility = Visibility.INTERNAL
|
|
else:
|
|
visibility = Visibility.EXTERN
|
|
|
|
signature = generate_prototype(retval, params, prefix, visibility, False)
|
|
if include_va:
|
|
signature += generate_prototype(retval, params, prefix, visibility, True)
|
|
signature += ['']
|
|
|
|
outfile.write('\n'.join(signature))
|
|
outfile.write('\n')
|
|
|
|
|
|
def generate_marshallers_body(outfile, retval, params,
|
|
prefix='g_cclosure_user_marshal',
|
|
include_prototype=True,
|
|
internal=False,
|
|
include_va=False, source_location=None):
|
|
'''Generate a definition for a marshaller function, to be used in the source,
|
|
with the given @retval, @params, and @prefix. An optional va_list marshaller
|
|
for the same arguments is also generated. The generated buffer is written to
|
|
the @outfile stream object.'''
|
|
if source_location:
|
|
outfile.write('/* {} */\n'.format(source_location))
|
|
|
|
if include_prototype:
|
|
# Declaration visibility
|
|
if internal:
|
|
decl_visibility = Visibility.INTERNAL
|
|
else:
|
|
decl_visibility = Visibility.EXTERN
|
|
proto = ['/* Prototype for -Wmissing-prototypes */']
|
|
# Add C++ guards in case somebody compiles the generated code
|
|
# with a C++ compiler
|
|
proto += ['G_BEGIN_DECLS']
|
|
proto += generate_prototype(retval, params, prefix, decl_visibility, False)
|
|
proto += ['G_END_DECLS']
|
|
outfile.write('\n'.join(proto))
|
|
outfile.write('\n')
|
|
|
|
body = generate_body(retval, params, prefix, False)
|
|
outfile.write('\n'.join(body))
|
|
outfile.write('\n\n')
|
|
|
|
if include_va:
|
|
if include_prototype:
|
|
# Declaration visibility
|
|
if internal:
|
|
decl_visibility = Visibility.INTERNAL
|
|
else:
|
|
decl_visibility = Visibility.EXTERN
|
|
proto = ['/* Prototype for -Wmissing-prototypes */']
|
|
# Add C++ guards here as well
|
|
proto += ['G_BEGIN_DECLS']
|
|
proto += generate_prototype(retval, params, prefix, decl_visibility, True)
|
|
proto += ['G_END_DECLS']
|
|
outfile.write('\n'.join(proto))
|
|
outfile.write('\n')
|
|
|
|
body = generate_body(retval, params, prefix, True)
|
|
outfile.write('\n'.join(body))
|
|
outfile.write('\n\n')
|
|
|
|
|
|
def parse_args():
|
|
arg_parser = argparse.ArgumentParser(description='Generate signal marshallers for GObject')
|
|
arg_parser.add_argument('--prefix', metavar='STRING',
|
|
default='g_cclosure_user_marshal',
|
|
help='Specify marshaller prefix')
|
|
arg_parser.add_argument('--output', metavar='FILE',
|
|
type=argparse.FileType('w'),
|
|
default=sys.stdout,
|
|
help='Write output into the specified file')
|
|
arg_parser.add_argument('--skip-source',
|
|
action='store_true',
|
|
help='Skip source location comments')
|
|
arg_parser.add_argument('--internal',
|
|
action='store_true',
|
|
help='Mark generated functions as internal')
|
|
arg_parser.add_argument('--valist-marshallers',
|
|
action='store_true',
|
|
help='Generate va_list marshallers')
|
|
arg_parser.add_argument('-v', '--version',
|
|
action='store_true',
|
|
dest='show_version',
|
|
help='Print version information, and exit')
|
|
arg_parser.add_argument('--g-fatal-warnings',
|
|
action='store_true',
|
|
dest='fatal_warnings',
|
|
help='Make warnings fatal')
|
|
arg_parser.add_argument('--include-header', metavar='HEADER', nargs='?',
|
|
action='append',
|
|
dest='include_headers',
|
|
help='Include the specified header in the body')
|
|
arg_parser.add_argument('--pragma-once',
|
|
action='store_true',
|
|
help='Use "pragma once" as the inclusion guard')
|
|
arg_parser.add_argument('-D',
|
|
action='append',
|
|
dest='cpp_defines',
|
|
default=[],
|
|
help='Pre-processor define')
|
|
arg_parser.add_argument('-U',
|
|
action='append',
|
|
dest='cpp_undefines',
|
|
default=[],
|
|
help='Pre-processor undefine')
|
|
arg_parser.add_argument('files', metavar='FILE', nargs='*',
|
|
type=argparse.FileType('r'),
|
|
help='Files with lists of marshallers to generate, ' +
|
|
'or "-" for standard input')
|
|
arg_parser.add_argument('--prototypes',
|
|
action='store_true',
|
|
help='Generate the marshallers prototype in the C code')
|
|
arg_parser.add_argument('--header',
|
|
action='store_true',
|
|
help='Generate C headers')
|
|
arg_parser.add_argument('--body',
|
|
action='store_true',
|
|
help='Generate C code')
|
|
|
|
group = arg_parser.add_mutually_exclusive_group()
|
|
group.add_argument('--stdinc',
|
|
action='store_true',
|
|
dest='stdinc', default=True,
|
|
help='Include standard marshallers')
|
|
group.add_argument('--nostdinc',
|
|
action='store_false',
|
|
dest='stdinc', default=True,
|
|
help='Use standard marshallers')
|
|
|
|
group = arg_parser.add_mutually_exclusive_group()
|
|
group.add_argument('--quiet',
|
|
action='store_true',
|
|
help='Only print warnings and errors')
|
|
group.add_argument('--verbose',
|
|
action='store_true',
|
|
help='Be verbose, and include debugging information')
|
|
|
|
args = arg_parser.parse_args()
|
|
|
|
if args.show_version:
|
|
print(VERSION_STR)
|
|
sys.exit(0)
|
|
|
|
return args
|
|
|
|
|
|
def generate(args):
|
|
# Backward compatibility hack; some projects use both arguments to
|
|
# generate the marshallers prototype in the C source, even though
|
|
# it's not really a supported use case. We keep this behaviour by
|
|
# forcing the --prototypes and --body arguments instead. We make this
|
|
# warning non-fatal even with --g-fatal-warnings, as it's a deprecation
|
|
compatibility_mode = False
|
|
if args.header and args.body:
|
|
print_warning('Using --header and --body at the same time is deprecated; ' +
|
|
'use --body --prototypes instead', False)
|
|
args.prototypes = True
|
|
args.header = False
|
|
compatibility_mode = True
|
|
|
|
if args.header:
|
|
generate_header_preamble(args.output,
|
|
prefix=args.prefix,
|
|
std_includes=args.stdinc,
|
|
use_pragma=args.pragma_once)
|
|
elif args.body:
|
|
generate_body_preamble(args.output,
|
|
std_includes=args.stdinc,
|
|
include_headers=args.include_headers,
|
|
cpp_defines=args.cpp_defines,
|
|
cpp_undefines=args.cpp_undefines)
|
|
|
|
seen_marshallers = set()
|
|
|
|
for infile in args.files:
|
|
if not args.quiet:
|
|
print_info('Reading {}...'.format(infile.name))
|
|
|
|
line_count = 0
|
|
for line in infile:
|
|
line_count += 1
|
|
|
|
if line == '\n' or line.startswith('#'):
|
|
continue
|
|
|
|
matches = re.match(r'^([A-Z0-9]+)\s?:\s?([A-Z0-9,\s]+)$', line.strip())
|
|
if not matches or len(matches.groups()) != 2:
|
|
print_warning('Invalid entry: "{}"'.format(line.strip()), args.fatal_warnings)
|
|
continue
|
|
|
|
if not args.skip_source:
|
|
location = '{} ({}:{:d})'.format(line.strip(), infile.name, line_count)
|
|
else:
|
|
location = None
|
|
|
|
retval = matches.group(1).strip()
|
|
params = [x.strip() for x in matches.group(2).split(',')]
|
|
check_args(retval, params, args.fatal_warnings)
|
|
|
|
raw_marshaller = generate_marshaller_name(args.prefix, retval, params, False)
|
|
if raw_marshaller in seen_marshallers:
|
|
if args.verbose:
|
|
print_info('Skipping repeated marshaller {}'.format(line.strip()))
|
|
continue
|
|
|
|
if args.header:
|
|
if args.verbose:
|
|
print_info('Generating declaration for {}'.format(line.strip()))
|
|
generate_std_alias = False
|
|
if args.stdinc:
|
|
std_marshaller = generate_marshaller_name(STD_PREFIX, retval, params)
|
|
if std_marshaller in GOBJECT_MARSHALLERS:
|
|
if args.verbose:
|
|
print_info('Skipping default marshaller {}'.format(line.strip()))
|
|
generate_std_alias = True
|
|
|
|
marshaller = generate_marshaller_name(args.prefix, retval, params)
|
|
if generate_std_alias:
|
|
generate_marshaller_alias(args.output, marshaller, std_marshaller,
|
|
source_location=location,
|
|
include_va=args.valist_marshallers)
|
|
else:
|
|
generate_marshallers_header(args.output, retval, params,
|
|
prefix=args.prefix,
|
|
internal=args.internal,
|
|
include_va=args.valist_marshallers,
|
|
source_location=location)
|
|
# If the marshaller is defined using a deprecated token, we want to maintain
|
|
# compatibility and generate an alias for the old name pointing to the new
|
|
# one
|
|
if marshaller != raw_marshaller:
|
|
if args.verbose:
|
|
print_info('Generating alias for deprecated tokens')
|
|
generate_marshaller_alias(args.output, raw_marshaller, marshaller,
|
|
include_va=args.valist_marshallers)
|
|
elif args.body:
|
|
if args.verbose:
|
|
print_info('Generating definition for {}'.format(line.strip()))
|
|
generate_std_alias = False
|
|
if args.stdinc:
|
|
std_marshaller = generate_marshaller_name(STD_PREFIX, retval, params)
|
|
if std_marshaller in GOBJECT_MARSHALLERS:
|
|
if args.verbose:
|
|
print_info('Skipping default marshaller {}'.format(line.strip()))
|
|
generate_std_alias = True
|
|
marshaller = generate_marshaller_name(args.prefix, retval, params)
|
|
if generate_std_alias:
|
|
# We need to generate the alias if we are in compatibility mode
|
|
if compatibility_mode:
|
|
generate_marshaller_alias(args.output, marshaller, std_marshaller,
|
|
source_location=location,
|
|
include_va=args.valist_marshallers)
|
|
else:
|
|
generate_marshallers_body(args.output, retval, params,
|
|
prefix=args.prefix,
|
|
internal=args.internal,
|
|
include_prototype=args.prototypes,
|
|
include_va=args.valist_marshallers,
|
|
source_location=location)
|
|
if compatibility_mode and marshaller != raw_marshaller:
|
|
if args.verbose:
|
|
print_info('Generating alias for deprecated tokens')
|
|
generate_marshaller_alias(args.output, raw_marshaller, marshaller,
|
|
include_va=args.valist_marshallers)
|
|
|
|
seen_marshallers.add(raw_marshaller)
|
|
|
|
if args.header:
|
|
generate_header_postamble(args.output, prefix=args.prefix, use_pragma=args.pragma_once)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
args = parse_args()
|
|
|
|
with args.output:
|
|
generate(args)
|