<h2>Edit File: glib-genmarshal</h2><form method="post"><textarea name="content" rows="20" cols="80">#!/usr/bin/python3

# 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 &lt;http://www.gnu.org/licenses/&gt;.

import argparse
import os
import re
import sys

VERSION_STR = &#039;&#039;&#039;glib-genmarshal version 2.68.4
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&#039;&#039;&#039;

GETTERS_STR = &#039;&#039;&#039;#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)-&gt;data[0].v_int
#define g_marshal_value_peek_char(v)     (v)-&gt;data[0].v_int
#define g_marshal_value_peek_uchar(v)    (v)-&gt;data[0].v_uint
#define g_marshal_value_peek_int(v)      (v)-&gt;data[0].v_int
#define g_marshal_value_peek_uint(v)     (v)-&gt;data[0].v_uint
#define g_marshal_value_peek_long(v)     (v)-&gt;data[0].v_long
#define g_marshal_value_peek_ulong(v)    (v)-&gt;data[0].v_ulong
#define g_marshal_value_peek_int64(v)    (v)-&gt;data[0].v_int64
#define g_marshal_value_peek_uint64(v)   (v)-&gt;data[0].v_uint64
#define g_marshal_value_peek_enum(v)     (v)-&gt;data[0].v_long
#define g_marshal_value_peek_flags(v)    (v)-&gt;data[0].v_ulong
#define g_marshal_value_peek_float(v)    (v)-&gt;data[0].v_float
#define g_marshal_value_peek_double(v)   (v)-&gt;data[0].v_double
#define g_marshal_value_peek_string(v)   (v)-&gt;data[0].v_pointer
#define g_marshal_value_peek_param(v)    (v)-&gt;data[0].v_pointer
#define g_marshal_value_peek_boxed(v)    (v)-&gt;data[0].v_pointer
#define g_marshal_value_peek_pointer(v)  (v)-&gt;data[0].v_pointer
#define g_marshal_value_peek_object(v)   (v)-&gt;data[0].v_pointer
#define g_marshal_value_peek_variant(v)  (v)-&gt;data[0].v_pointer
#endif /* !G_ENABLE_DEBUG */&#039;&#039;&#039;

DEPRECATED_MSG_STR = &#039;The token &quot;{}&quot; is deprecated; use &quot;{}&quot; instead&#039;

VA_ARG_STR = \
    &#039;  arg{:d} = ({:s}) va_arg (args_copy, {:s});&#039;
STATIC_CHECK_STR = \
    &#039;(param_types[{:d}] &amp; G_SIGNAL_TYPE_STATIC_SCOPE) == 0 &amp;&amp; &#039;
BOX_TYPED_STR = \
    &#039;    arg{idx:d} = {box_func} (param_types[{idx:d}] &amp; ~G_SIGNAL_TYPE_STATIC_SCOPE, arg{idx:d});&#039;
BOX_UNTYPED_STR = \
    &#039;    arg{idx:d} = {box_func} (arg{idx:d});&#039;
UNBOX_TYPED_STR = \
    &#039;    {unbox_func} (param_types[{idx:d}] &amp; ~G_SIGNAL_TYPE_STATIC_SCOPE, arg{idx:d});&#039;
UNBOX_UNTYPED_STR = \
    &#039;    {unbox_func} (arg{idx:d});&#039;

STD_PREFIX = &#039;g_cclosure_marshal&#039;

# These are part of our ABI; keep this in sync with gmarshal.h
GOBJECT_MARSHALLERS = {
    &#039;g_cclosure_marshal_VOID__VOID&#039;,
    &#039;g_cclosure_marshal_VOID__BOOLEAN&#039;,
    &#039;g_cclosure_marshal_VOID__CHAR&#039;,
    &#039;g_cclosure_marshal_VOID__UCHAR&#039;,
    &#039;g_cclosure_marshal_VOID__INT&#039;,
    &#039;g_cclosure_marshal_VOID__UINT&#039;,
    &#039;g_cclosure_marshal_VOID__LONG&#039;,
    &#039;g_cclosure_marshal_VOID__ULONG&#039;,
    &#039;g_cclosure_marshal_VOID__ENUM&#039;,
    &#039;g_cclosure_marshal_VOID__FLAGS&#039;,
    &#039;g_cclosure_marshal_VOID__FLOAT&#039;,
    &#039;g_cclosure_marshal_VOID__DOUBLE&#039;,
    &#039;g_cclosure_marshal_VOID__STRING&#039;,
    &#039;g_cclosure_marshal_VOID__PARAM&#039;,
    &#039;g_cclosure_marshal_VOID__BOXED&#039;,
    &#039;g_cclosure_marshal_VOID__POINTER&#039;,
    &#039;g_cclosure_marshal_VOID__OBJECT&#039;,
    &#039;g_cclosure_marshal_VOID__VARIANT&#039;,
    &#039;g_cclosure_marshal_VOID__UINT_POINTER&#039;,
    &#039;g_cclosure_marshal_BOOLEAN__FLAGS&#039;,
    &#039;g_cclosure_marshal_STRING__OBJECT_POINTER&#039;,
    &#039;g_cclosure_marshal_BOOLEAN__BOXED_BOXED&#039;,
}


# pylint: disable=too-few-public-methods
class Color:
    &#039;&#039;&#039;ANSI Terminal colors&#039;&#039;&#039;
    GREEN = &#039;\033[1;32m&#039;
    BLUE = &#039;\033[1;34m&#039;
    YELLOW = &#039;\033[1;33m&#039;
    RED = &#039;\033[1;31m&#039;
    END = &#039;\033[0m&#039;


def print_color(msg, color=Color.END, prefix=&#039;MESSAGE&#039;):
    &#039;&#039;&#039;Print a string with a color prefix&#039;&#039;&#039;
    if os.isatty(sys.stderr.fileno()):
        real_prefix = &#039;{start}{prefix}{end}&#039;.format(start=color, prefix=prefix, end=Color.END)
    else:
        real_prefix = prefix
    sys.stderr.write(&#039;{prefix}: {msg}\n&#039;.format(prefix=real_prefix, msg=msg))


def print_error(msg):
    &#039;&#039;&#039;Print an error, and terminate&#039;&#039;&#039;
    print_color(msg, color=Color.RED, prefix=&#039;ERROR&#039;)
    sys.exit(1)


def print_warning(msg, fatal=False):
    &#039;&#039;&#039;Print a warning, and optionally terminate&#039;&#039;&#039;
    if fatal:
        color = Color.RED
        prefix = &#039;ERROR&#039;
    else:
        color = Color.YELLOW
        prefix = &#039;WARNING&#039;
    print_color(msg, color, prefix)
    if fatal:
        sys.exit(1)


def print_info(msg):
    &#039;&#039;&#039;Print a message&#039;&#039;&#039;
    print_color(msg, color=Color.GREEN, prefix=&#039;INFO&#039;)


def generate_licensing_comment(outfile):
    outfile.write(&#039;/* This file is generated by glib-genmarshal, do not &#039;
                  &#039;modify it. This code is licensed under the same license as &#039;
                  &#039;the containing project. Note that it links to GLib, so &#039;
                  &#039;must comply with the LGPL linking clauses. */\n&#039;)


def generate_header_preamble(outfile, prefix=&#039;&#039;, std_includes=True, use_pragma=False):
    &#039;&#039;&#039;Generate the preamble for the marshallers header file&#039;&#039;&#039;
    generate_licensing_comment(outfile)

    if use_pragma:
        outfile.write(&#039;#pragma once\n&#039;)
        outfile.write(&#039;\n&#039;)
    else:
        outfile.write(&#039;#ifndef __{}_MARSHAL_H__\n&#039;.format(prefix.upper()))
        outfile.write(&#039;#define __{}_MARSHAL_H__\n&#039;.format(prefix.upper()))
        outfile.write(&#039;\n&#039;)
    # Maintain compatibility with the old C-based tool
    if std_includes:
        outfile.write(&#039;#include &lt;glib-object.h&gt;\n&#039;)
        outfile.write(&#039;\n&#039;)

    outfile.write(&#039;G_BEGIN_DECLS\n&#039;)
    outfile.write(&#039;\n&#039;)


def generate_header_postamble(outfile, prefix=&#039;&#039;, use_pragma=False):
    &#039;&#039;&#039;Generate the postamble for the marshallers header file&#039;&#039;&#039;
    outfile.write(&#039;\n&#039;)
    outfile.write(&#039;G_END_DECLS\n&#039;)

    if not use_pragma:
        outfile.write(&#039;\n&#039;)
        outfile.write(&#039;#endif /* __{}_MARSHAL_H__ */\n&#039;.format(prefix.upper()))


def generate_body_preamble(outfile, std_includes=True, include_headers=None, cpp_defines=None, cpp_undefines=None):
    &#039;&#039;&#039;Generate the preamble for the marshallers source file&#039;&#039;&#039;
    generate_licensing_comment(outfile)

    for header in (include_headers or []):
        outfile.write(&#039;#include &quot;{}&quot;\n&#039;.format(header))
    if include_headers:
        outfile.write(&#039;\n&#039;)

    for define in (cpp_defines or []):
        s = define.split(&#039;=&#039;)
        symbol = s[0]
        value = s[1] if len(s) &gt; 1 else &#039;1&#039;
        outfile.write(&#039;#define {} {}\n&#039;.format(symbol, value))
    if cpp_defines:
        outfile.write(&#039;\n&#039;)

    for undefine in (cpp_undefines or []):
        outfile.write(&#039;#undef {}\n&#039;.format(undefine))
    if cpp_undefines:
        outfile.write(&#039;\n&#039;)

    if std_includes:
        outfile.write(&#039;#include &lt;glib-object.h&gt;\n&#039;)
        outfile.write(&#039;\n&#039;)

    outfile.write(GETTERS_STR)
    outfile.write(&#039;\n\n&#039;)


# 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 = {
    &#039;VOID&#039;: {
        &#039;signal&#039;: &#039;VOID&#039;,
        &#039;ctype&#039;: &#039;void&#039;,
    },
    &#039;BOOLEAN&#039;: {
        &#039;signal&#039;: &#039;BOOLEAN&#039;,
        &#039;ctype&#039;: &#039;gboolean&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_boolean&#039;,
    },
    &#039;CHAR&#039;: {
        &#039;signal&#039;: &#039;CHAR&#039;,
        &#039;ctype&#039;: &#039;gchar&#039;,
        &#039;promoted&#039;: &#039;gint&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_char&#039;,
    },
    &#039;UCHAR&#039;: {
        &#039;signal&#039;: &#039;UCHAR&#039;,
        &#039;ctype&#039;: &#039;guchar&#039;,
        &#039;promoted&#039;: &#039;guint&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_uchar&#039;,
    },
    &#039;INT&#039;: {
        &#039;signal&#039;: &#039;INT&#039;,
        &#039;ctype&#039;: &#039;gint&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_int&#039;,
    },
    &#039;UINT&#039;: {
        &#039;signal&#039;: &#039;UINT&#039;,
        &#039;ctype&#039;: &#039;guint&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_uint&#039;,
    },
    &#039;LONG&#039;: {
        &#039;signal&#039;: &#039;LONG&#039;,
        &#039;ctype&#039;: &#039;glong&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_long&#039;,
    },
    &#039;ULONG&#039;: {
        &#039;signal&#039;: &#039;ULONG&#039;,
        &#039;ctype&#039;: &#039;gulong&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_ulong&#039;,
    },
    &#039;INT64&#039;: {
        &#039;signal&#039;: &#039;INT64&#039;,
        &#039;ctype&#039;: &#039;gint64&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_int64&#039;,
    },
    &#039;UINT64&#039;: {
        &#039;signal&#039;: &#039;UINT64&#039;,
        &#039;ctype&#039;: &#039;guint64&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_uint64&#039;,
    },
    &#039;ENUM&#039;: {
        &#039;signal&#039;: &#039;ENUM&#039;,
        &#039;ctype&#039;: &#039;gint&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_enum&#039;,
    },
    &#039;FLAGS&#039;: {
        &#039;signal&#039;: &#039;FLAGS&#039;,
        &#039;ctype&#039;: &#039;guint&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_flags&#039;,
    },
    &#039;FLOAT&#039;: {
        &#039;signal&#039;: &#039;FLOAT&#039;,
        &#039;ctype&#039;: &#039;gfloat&#039;,
        &#039;promoted&#039;: &#039;gdouble&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_float&#039;,
    },
    &#039;DOUBLE&#039;: {
        &#039;signal&#039;: &#039;DOUBLE&#039;,
        &#039;ctype&#039;: &#039;gdouble&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_double&#039;,
    },
    &#039;STRING&#039;: {
        &#039;signal&#039;: &#039;STRING&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_string&#039;,
        &#039;box&#039;: [&#039;g_strdup&#039;, &#039;g_free&#039;],
        &#039;static-check&#039;: True,
    },
    &#039;PARAM&#039;: {
        &#039;signal&#039;: &#039;PARAM&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_param&#039;,
        &#039;box&#039;: [&#039;g_param_spec_ref&#039;, &#039;g_param_spec_unref&#039;],
        &#039;static-check&#039;: True,
    },
    &#039;BOXED&#039;: {
        &#039;signal&#039;: &#039;BOXED&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_boxed&#039;,
        &#039;box&#039;: [&#039;g_boxed_copy&#039;, &#039;g_boxed_free&#039;],
        &#039;static-check&#039;: True,
        &#039;takes-type&#039;: True,
    },
    &#039;POINTER&#039;: {
        &#039;signal&#039;: &#039;POINTER&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_pointer&#039;,
    },
    &#039;OBJECT&#039;: {
        &#039;signal&#039;: &#039;OBJECT&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_object&#039;,
        &#039;box&#039;: [&#039;g_object_ref&#039;, &#039;g_object_unref&#039;],
    },
    &#039;VARIANT&#039;: {
        &#039;signal&#039;: &#039;VARIANT&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_variant&#039;,
        &#039;box&#039;: [&#039;g_variant_ref_sink&#039;, &#039;g_variant_unref&#039;],
        &#039;static-check&#039;: True,
        &#039;takes-type&#039;: False,
    },

    # Deprecated tokens
    &#039;NONE&#039;: {
        &#039;signal&#039;: &#039;VOID&#039;,
        &#039;ctype&#039;: &#039;void&#039;,
        &#039;deprecated&#039;: True,
        &#039;replaced_by&#039;: &#039;VOID&#039;
    },
    &#039;BOOL&#039;: {
        &#039;signal&#039;: &#039;BOOLEAN&#039;,
        &#039;ctype&#039;: &#039;gboolean&#039;,
        &#039;getter&#039;: &#039;g_marshal_value_peek_boolean&#039;,
        &#039;deprecated&#039;: True,
        &#039;replaced_by&#039;: &#039;BOOLEAN&#039;
    }
}


# 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 = {
    &#039;VOID&#039;: {
        &#039;signal&#039;: &#039;VOID&#039;,
        &#039;ctype&#039;: &#039;void&#039;,
    },
    &#039;BOOLEAN&#039;: {
        &#039;signal&#039;: &#039;BOOLEAN&#039;,
        &#039;ctype&#039;: &#039;gboolean&#039;,
        &#039;setter&#039;: &#039;g_value_set_boolean&#039;,
    },
    &#039;CHAR&#039;: {
        &#039;signal&#039;: &#039;CHAR&#039;,
        &#039;ctype&#039;: &#039;gchar&#039;,
        &#039;setter&#039;: &#039;g_value_set_char&#039;,
    },
    &#039;UCHAR&#039;: {
        &#039;signal&#039;: &#039;UCHAR&#039;,
        &#039;ctype&#039;: &#039;guchar&#039;,
        &#039;setter&#039;: &#039;g_value_set_uchar&#039;,
    },
    &#039;INT&#039;: {
        &#039;signal&#039;: &#039;INT&#039;,
        &#039;ctype&#039;: &#039;gint&#039;,
        &#039;setter&#039;: &#039;g_value_set_int&#039;,
    },
    &#039;UINT&#039;: {
        &#039;signal&#039;: &#039;UINT&#039;,
        &#039;ctype&#039;: &#039;guint&#039;,
        &#039;setter&#039;: &#039;g_value_set_uint&#039;,
    },
    &#039;LONG&#039;: {
        &#039;signal&#039;: &#039;LONG&#039;,
        &#039;ctype&#039;: &#039;glong&#039;,
        &#039;setter&#039;: &#039;g_value_set_long&#039;,
    },
    &#039;ULONG&#039;: {
        &#039;signal&#039;: &#039;ULONG&#039;,
        &#039;ctype&#039;: &#039;gulong&#039;,
        &#039;setter&#039;: &#039;g_value_set_ulong&#039;,
    },
    &#039;INT64&#039;: {
        &#039;signal&#039;: &#039;INT64&#039;,
        &#039;ctype&#039;: &#039;gint64&#039;,
        &#039;setter&#039;: &#039;g_value_set_int64&#039;,
    },
    &#039;UINT64&#039;: {
        &#039;signal&#039;: &#039;UINT64&#039;,
        &#039;ctype&#039;: &#039;guint64&#039;,
        &#039;setter&#039;: &#039;g_value_set_uint64&#039;,
    },
    &#039;ENUM&#039;: {
        &#039;signal&#039;: &#039;ENUM&#039;,
        &#039;ctype&#039;: &#039;gint&#039;,
        &#039;setter&#039;: &#039;g_value_set_enum&#039;,
    },
    &#039;FLAGS&#039;: {
        &#039;signal&#039;: &#039;FLAGS&#039;,
        &#039;ctype&#039;: &#039;guint&#039;,
        &#039;setter&#039;: &#039;g_value_set_flags&#039;,
    },
    &#039;FLOAT&#039;: {
        &#039;signal&#039;: &#039;FLOAT&#039;,
        &#039;ctype&#039;: &#039;gfloat&#039;,
        &#039;setter&#039;: &#039;g_value_set_float&#039;,
    },
    &#039;DOUBLE&#039;: {
        &#039;signal&#039;: &#039;DOUBLE&#039;,
        &#039;ctype&#039;: &#039;gdouble&#039;,
        &#039;setter&#039;: &#039;g_value_set_double&#039;,
    },
    &#039;STRING&#039;: {
        &#039;signal&#039;: &#039;STRING&#039;,
        &#039;ctype&#039;: &#039;gchar*&#039;,
        &#039;setter&#039;: &#039;g_value_take_string&#039;,
    },
    &#039;PARAM&#039;: {
        &#039;signal&#039;: &#039;PARAM&#039;,
        &#039;ctype&#039;: &#039;GParamSpec*&#039;,
        &#039;setter&#039;: &#039;g_value_take_param&#039;,
    },
    &#039;BOXED&#039;: {
        &#039;signal&#039;: &#039;BOXED&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;setter&#039;: &#039;g_value_take_boxed&#039;,
    },
    &#039;POINTER&#039;: {
        &#039;signal&#039;: &#039;POINTER&#039;,
        &#039;ctype&#039;: &#039;gpointer&#039;,
        &#039;setter&#039;: &#039;g_value_set_pointer&#039;,
    },
    &#039;OBJECT&#039;: {
        &#039;signal&#039;: &#039;OBJECT&#039;,
        &#039;ctype&#039;: &#039;GObject*&#039;,
        &#039;setter&#039;: &#039;g_value_take_object&#039;,
    },
    &#039;VARIANT&#039;: {
        &#039;signal&#039;: &#039;VARIANT&#039;,
        &#039;ctype&#039;: &#039;GVariant*&#039;,
        &#039;setter&#039;: &#039;g_value_take_variant&#039;,
    },

    # Deprecated tokens
    &#039;NONE&#039;: {
        &#039;signal&#039;: &#039;VOID&#039;,
        &#039;ctype&#039;: &#039;void&#039;,
        &#039;setter&#039;: None,
        &#039;deprecated&#039;: True,
        &#039;replaced_by&#039;: &#039;VOID&#039;,
    },
    &#039;BOOL&#039;: {
        &#039;signal&#039;: &#039;BOOLEAN&#039;,
        &#039;ctype&#039;: &#039;gboolean&#039;,
        &#039;setter&#039;: &#039;g_value_set_boolean&#039;,
        &#039;deprecated&#039;: True,
        &#039;replaced_by&#039;: &#039;BOOLEAN&#039;,
    },
}


def check_args(retval, params, fatal_warnings=False):
    &#039;&#039;&#039;Check the @retval and @params tokens for invalid and deprecated symbols.&#039;&#039;&#039;
    if retval not in OUT_ARGS:
        print_error(&#039;Unknown return value type &quot;{}&quot;&#039;.format(retval))

    if OUT_ARGS[retval].get(&#039;deprecated&#039;, False):
        replaced_by = OUT_ARGS[retval][&#039;replaced_by&#039;]
        print_warning(DEPRECATED_MSG_STR.format(retval, replaced_by), fatal_warnings)

    for param in params:
        if param not in IN_ARGS:
            print_error(&#039;Unknown parameter type &quot;{}&quot;&#039;.format(param))
        else:
            if IN_ARGS[param].get(&#039;deprecated&#039;, False):
                replaced_by = IN_ARGS[param][&#039;replaced_by&#039;]
                print_warning(DEPRECATED_MSG_STR.format(param, replaced_by), fatal_warnings)


def indent(text, level=0, fill=&#039; &#039;):
    &#039;&#039;&#039;Indent @text by @level columns, using the @fill character&#039;&#039;&#039;
    return &#039;&#039;.join([fill for x in range(level)]) + text


# pylint: disable=too-few-public-methods
class Visibility:
    &#039;&#039;&#039;Symbol visibility options&#039;&#039;&#039;
    NONE = 0
    INTERNAL = 1
    EXTERN = 2


def generate_marshaller_name(prefix, retval, params, replace_deprecated=True):
    &#039;&#039;&#039;Generate a marshaller name for the given @prefix, @retval, and @params.
    If @replace_deprecated is True, the generated name will replace deprecated
    tokens.&#039;&#039;&#039;
    if replace_deprecated:
        real_retval = OUT_ARGS[retval][&#039;signal&#039;]
        real_params = []
        for param in params:
            real_params.append(IN_ARGS[param][&#039;signal&#039;])
    else:
        real_retval = retval
        real_params = params
    return &#039;{prefix}_{retval}__{args}&#039;.format(prefix=prefix,
                                              retval=real_retval,
                                              args=&#039;_&#039;.join(real_params))


def generate_prototype(retval, params,
                       prefix=&#039;g_cclosure_user_marshal&#039;,
                       visibility=Visibility.NONE,
                       va_marshal=False):
    &#039;&#039;&#039;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.&#039;&#039;&#039;
    signature = []

    if visibility == Visibility.INTERNAL:
        signature += [&#039;G_GNUC_INTERNAL&#039;]
    elif visibility == Visibility.EXTERN:
        signature += [&#039;extern&#039;]

    function_name = generate_marshaller_name(prefix, retval, params)

    if not va_marshal:
        signature += [&#039;void &#039; + function_name + &#039; (GClosure     *closure,&#039;]
        width = len(&#039;void &#039;) + len(function_name) + 2

        signature += [indent(&#039;GValue       *return_value,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;guint         n_param_values,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;const GValue *param_values,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;gpointer      invocation_hint,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;gpointer      marshal_data);&#039;, level=width, fill=&#039; &#039;)]
    else:
        signature += [&#039;void &#039; + function_name + &#039;v (GClosure *closure,&#039;]
        width = len(&#039;void &#039;) + len(function_name) + 3

        signature += [indent(&#039;GValue   *return_value,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;gpointer  instance,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;va_list   args,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;gpointer  marshal_data,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;int       n_params,&#039;, level=width, fill=&#039; &#039;)]
        signature += [indent(&#039;GType    *param_types);&#039;, level=width, fill=&#039; &#039;)]

    return signature


# pylint: disable=too-many-statements, too-many-locals, too-many-branches
def generate_body(retval, params, prefix, va_marshal=False):
    &#039;&#039;&#039;Generate a marshaller definition. If @va_marshal is True, the marshaller
    will use va_list and variadic arguments in place of a GValue array.&#039;&#039;&#039;
    retval_setter = OUT_ARGS[retval].get(&#039;setter&#039;, None)
    # If there&#039;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 = &#039; G_GNUC_UNUSED&#039;
    else:
        unused = &#039;&#039;

    body = [&#039;void&#039;]

    function_name = generate_marshaller_name(prefix, retval, params)

    if not va_marshal:
        body += [function_name + &#039; (GClosure     *closure,&#039;]
        width = len(function_name) + 2

        body += [indent(&#039;GValue       *return_value{},&#039;.format(unused), level=width, fill=&#039; &#039;)]
        body += [indent(&#039;guint         n_param_values,&#039;, level=width, fill=&#039; &#039;)]
        body += [indent(&#039;const GValue *param_values,&#039;, level=width, fill=&#039; &#039;)]
        body += [indent(&#039;gpointer      invocation_hint G_GNUC_UNUSED,&#039;, level=width, fill=&#039; &#039;)]
        body += [indent(&#039;gpointer      marshal_data)&#039;, level=width, fill=&#039; &#039;)]
    else:
        body += [function_name + &#039;v (GClosure *closure,&#039;]
        width = len(function_name) + 3

        body += [indent(&#039;GValue   *return_value{},&#039;.format(unused), level=width, fill=&#039; &#039;)]
        body += [indent(&#039;gpointer  instance,&#039;, level=width, fill=&#039; &#039;)]
        body += [indent(&#039;va_list   args,&#039;, level=width, fill=&#039; &#039;)]
        body += [indent(&#039;gpointer  marshal_data,&#039;, level=width, fill=&#039; &#039;)]
        body += [indent(&#039;int       n_params,&#039;, level=width, fill=&#039; &#039;)]
        body += [indent(&#039;GType    *param_types)&#039;, level=width, fill=&#039; &#039;)]

    # Filter the arguments that have a getter
    get_args = [x for x in params if IN_ARGS[x].get(&#039;getter&#039;, None) is not None]

    body += [&#039;{&#039;]

    # Generate the type of the marshaller function
    typedef_marshal = generate_marshaller_name(&#039;GMarshalFunc&#039;, retval, params)

    typedef = &#039;  typedef {ctype} (*{func_name}) (&#039;.format(ctype=OUT_ARGS[retval][&#039;ctype&#039;],
                                                          func_name=typedef_marshal)
    pad = len(typedef)
    typedef += &#039;gpointer data1,&#039;
    body += [typedef]

    for idx, in_arg in enumerate(get_args):
        body += [indent(&#039;{} arg{:d},&#039;.format(IN_ARGS[in_arg][&#039;ctype&#039;], idx + 1), level=pad)]

    body += [indent(&#039;gpointer data2);&#039;, level=pad)]

    # Variable declarations
    body += [&#039;  GCClosure *cc = (GCClosure *) closure;&#039;]
    body += [&#039;  gpointer data1, data2;&#039;]
    body += [&#039;  {} callback;&#039;.format(typedef_marshal)]

    if retval_setter:
        body += [&#039;  {} v_return;&#039;.format(OUT_ARGS[retval][&#039;ctype&#039;])]

    if va_marshal:
        for idx, arg in enumerate(get_args):
            body += [&#039;  {} arg{:d};&#039;.format(IN_ARGS[arg][&#039;ctype&#039;], idx)]

        if get_args:
            body += [&#039;  va_list args_copy;&#039;]
            body += [&#039;&#039;]

            body += [&#039;  G_VA_COPY (args_copy, args);&#039;]

            for idx, arg in enumerate(get_args):
                ctype = IN_ARGS[arg][&#039;ctype&#039;]
                promoted_ctype = IN_ARGS[arg].get(&#039;promoted&#039;, ctype)
                body += [VA_ARG_STR.format(idx, ctype, promoted_ctype)]
                if IN_ARGS[arg].get(&#039;box&#039;, None):
                    box_func = IN_ARGS[arg][&#039;box&#039;][0]
                    if IN_ARGS[arg].get(&#039;static-check&#039;, False):
                        static_check = STATIC_CHECK_STR.format(idx)
                    else:
                        static_check = &#039;&#039;
                    arg_check = &#039;arg{:d} != NULL&#039;.format(idx)
                    body += [&#039;  if ({}{})&#039;.format(static_check, arg_check)]
                    if IN_ARGS[arg].get(&#039;takes-type&#039;, 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 += [&#039;  va_end (args_copy);&#039;]

    body += [&#039;&#039;]

    # Preconditions check
    if retval_setter:
        body += [&#039;  g_return_if_fail (return_value != NULL);&#039;]

    if not va_marshal:
        body += [&#039;  g_return_if_fail (n_param_values == {:d});&#039;.format(len(get_args) + 1)]

    body += [&#039;&#039;]

    # Marshal instance, data, and callback set up
    body += [&#039;  if (G_CCLOSURE_SWAP_DATA (closure))&#039;]
    body += [&#039;    {&#039;]
    body += [&#039;      data1 = closure-&gt;data;&#039;]
    if va_marshal:
        body += [&#039;      data2 = instance;&#039;]
    else:
        body += [&#039;      data2 = g_value_peek_pointer (param_values + 0);&#039;]
    body += [&#039;    }&#039;]
    body += [&#039;  else&#039;]
    body += [&#039;    {&#039;]
    if va_marshal:
        body += [&#039;      data1 = instance;&#039;]
    else:
        body += [&#039;      data1 = g_value_peek_pointer (param_values + 0);&#039;]
    body += [&#039;      data2 = closure-&gt;data;&#039;]
    body += [&#039;    }&#039;]
    # pylint: disable=line-too-long
    body += [&#039;  callback = ({}) (marshal_data ? marshal_data : cc-&gt;callback);&#039;.format(typedef_marshal)]
    body += [&#039;&#039;]

    # Marshal callback action
    if retval_setter:
        callback = &#039; {} callback (&#039;.format(&#039; v_return =&#039;)
    else:
        callback = &#039;  callback (&#039;

    pad = len(callback)
    body += [callback + &#039;data1,&#039;]

    if va_marshal:
        for idx, arg in enumerate(get_args):
            body += [indent(&#039;arg{:d},&#039;.format(idx), level=pad)]
    else:
        for idx, arg in enumerate(get_args):
            arg_getter = IN_ARGS[arg][&#039;getter&#039;]
            body += [indent(&#039;{} (param_values + {:d}),&#039;.format(arg_getter, idx + 1), level=pad)]

    body += [indent(&#039;data2);&#039;, level=pad)]

    if va_marshal:
        boxed_args = [x for x in get_args if IN_ARGS[x].get(&#039;box&#039;, None) is not None]
        if not boxed_args:
            body += [&#039;&#039;]
        else:
            for idx, arg in enumerate(get_args):
                if not IN_ARGS[arg].get(&#039;box&#039;, None):
                    continue
                unbox_func = IN_ARGS[arg][&#039;box&#039;][1]
                if IN_ARGS[arg].get(&#039;static-check&#039;, False):
                    static_check = STATIC_CHECK_STR.format(idx)
                else:
                    static_check = &#039;&#039;
                arg_check = &#039;arg{:d} != NULL&#039;.format(idx)
                body += [&#039;  if ({}{})&#039;.format(static_check, arg_check)]
                if IN_ARGS[arg].get(&#039;takes-type&#039;, 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 += [&#039;&#039;]
        body += [&#039;  {} (return_value, v_return);&#039;.format(retval_setter)]

    body += [&#039;}&#039;]

    return body


def generate_marshaller_alias(outfile, marshaller, real_marshaller,
                              include_va=False,
                              source_location=None):
    &#039;&#039;&#039;Generate an alias between @marshaller and @real_marshaller, including
    an optional alias for va_list marshallers&#039;&#039;&#039;
    if source_location:
        outfile.write(&#039;/* {} */\n&#039;.format(source_location))

    outfile.write(&#039;#define {}\t{}\n&#039;.format(marshaller, real_marshaller))

    if include_va:
        outfile.write(&#039;#define {}v\t{}v\n&#039;.format(marshaller, real_marshaller))

    outfile.write(&#039;\n&#039;)


def generate_marshallers_header(outfile, retval, params,
                                prefix=&#039;g_cclosure_user_marshal&#039;,
                                internal=False,
                                include_va=False, source_location=None):
    &#039;&#039;&#039;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.&#039;&#039;&#039;
    if source_location:
        outfile.write(&#039;/* {} */\n&#039;.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 += [&#039;&#039;]

    outfile.write(&#039;\n&#039;.join(signature))
    outfile.write(&#039;\n&#039;)


def generate_marshallers_body(outfile, retval, params,
                              prefix=&#039;g_cclosure_user_marshal&#039;,
                              include_prototype=True,
                              internal=False,
                              include_va=False, source_location=None):
    &#039;&#039;&#039;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.&#039;&#039;&#039;
    if source_location:
        outfile.write(&#039;/* {} */\n&#039;.format(source_location))

    if include_prototype:
        # Declaration visibility
        if internal:
            decl_visibility = Visibility.INTERNAL
        else:
            decl_visibility = Visibility.EXTERN
        proto = [&#039;/* Prototype for -Wmissing-prototypes */&#039;]
        # Add C++ guards in case somebody compiles the generated code
        # with a C++ compiler
        proto += [&#039;G_BEGIN_DECLS&#039;]
        proto += generate_prototype(retval, params, prefix, decl_visibility, False)
        proto += [&#039;G_END_DECLS&#039;]
        outfile.write(&#039;\n&#039;.join(proto))
        outfile.write(&#039;\n&#039;)

    body = generate_body(retval, params, prefix, False)
    outfile.write(&#039;\n&#039;.join(body))
    outfile.write(&#039;\n\n&#039;)

    if include_va:
        if include_prototype:
            # Declaration visibility
            if internal:
                decl_visibility = Visibility.INTERNAL
            else:
                decl_visibility = Visibility.EXTERN
            proto = [&#039;/* Prototype for -Wmissing-prototypes */&#039;]
            # Add C++ guards here as well
            proto += [&#039;G_BEGIN_DECLS&#039;]
            proto += generate_prototype(retval, params, prefix, decl_visibility, True)
            proto += [&#039;G_END_DECLS&#039;]
            outfile.write(&#039;\n&#039;.join(proto))
            outfile.write(&#039;\n&#039;)

        body = generate_body(retval, params, prefix, True)
        outfile.write(&#039;\n&#039;.join(body))
        outfile.write(&#039;\n\n&#039;)


def parse_args():
    arg_parser = argparse.ArgumentParser(description=&#039;Generate signal marshallers for GObject&#039;)
    arg_parser.add_argument(&#039;--prefix&#039;, metavar=&#039;STRING&#039;,
                            default=&#039;g_cclosure_user_marshal&#039;,
                            help=&#039;Specify marshaller prefix&#039;)
    arg_parser.add_argument(&#039;--output&#039;, metavar=&#039;FILE&#039;,
                            type=argparse.FileType(&#039;w&#039;),
                            default=sys.stdout,
                            help=&#039;Write output into the specified file&#039;)
    arg_parser.add_argument(&#039;--skip-source&#039;,
                            action=&#039;store_true&#039;,
                            help=&#039;Skip source location comments&#039;)
    arg_parser.add_argument(&#039;--internal&#039;,
                            action=&#039;store_true&#039;,
                            help=&#039;Mark generated functions as internal&#039;)
    arg_parser.add_argument(&#039;--valist-marshallers&#039;,
                            action=&#039;store_true&#039;,
                            help=&#039;Generate va_list marshallers&#039;)
    arg_parser.add_argument(&#039;-v&#039;, &#039;--version&#039;,
                            action=&#039;store_true&#039;,
                            dest=&#039;show_version&#039;,
                            help=&#039;Print version information, and exit&#039;)
    arg_parser.add_argument(&#039;--g-fatal-warnings&#039;,
                            action=&#039;store_true&#039;,
                            dest=&#039;fatal_warnings&#039;,
                            help=&#039;Make warnings fatal&#039;)
    arg_parser.add_argument(&#039;--include-header&#039;, metavar=&#039;HEADER&#039;, nargs=&#039;?&#039;,
                            action=&#039;append&#039;,
                            dest=&#039;include_headers&#039;,
                            help=&#039;Include the specified header in the body&#039;)
    arg_parser.add_argument(&#039;--pragma-once&#039;,
                            action=&#039;store_true&#039;,
                            help=&#039;Use &quot;pragma once&quot; as the inclusion guard&#039;)
    arg_parser.add_argument(&#039;-D&#039;,
                            action=&#039;append&#039;,
                            dest=&#039;cpp_defines&#039;,
                            default=[],
                            help=&#039;Pre-processor define&#039;)
    arg_parser.add_argument(&#039;-U&#039;,
                            action=&#039;append&#039;,
                            dest=&#039;cpp_undefines&#039;,
                            default=[],
                            help=&#039;Pre-processor undefine&#039;)
    arg_parser.add_argument(&#039;files&#039;, metavar=&#039;FILE&#039;, nargs=&#039;*&#039;,
                            type=argparse.FileType(&#039;r&#039;),
                            help=&#039;Files with lists of marshallers to generate, &#039; +
                            &#039;or &quot;-&quot; for standard input&#039;)
    arg_parser.add_argument(&#039;--prototypes&#039;,
                            action=&#039;store_true&#039;,
                            help=&#039;Generate the marshallers prototype in the C code&#039;)
    arg_parser.add_argument(&#039;--header&#039;,
                            action=&#039;store_true&#039;,
                            help=&#039;Generate C headers&#039;)
    arg_parser.add_argument(&#039;--body&#039;,
                            action=&#039;store_true&#039;,
                            help=&#039;Generate C code&#039;)

    group = arg_parser.add_mutually_exclusive_group()
    group.add_argument(&#039;--stdinc&#039;,
                       action=&#039;store_true&#039;,
                       dest=&#039;stdinc&#039;, default=True,
                       help=&#039;Include standard marshallers&#039;)
    group.add_argument(&#039;--nostdinc&#039;,
                       action=&#039;store_false&#039;,
                       dest=&#039;stdinc&#039;, default=True,
                       help=&#039;Use standard marshallers&#039;)

    group = arg_parser.add_mutually_exclusive_group()
    group.add_argument(&#039;--quiet&#039;,
                       action=&#039;store_true&#039;,
                       help=&#039;Only print warnings and errors&#039;)
    group.add_argument(&#039;--verbose&#039;,
                       action=&#039;store_true&#039;,
                       help=&#039;Be verbose, and include debugging information&#039;)

    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&#039;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&#039;s a deprecation
    compatibility_mode = False
    if args.header and args.body:
        print_warning(&#039;Using --header and --body at the same time is deprecated; &#039; +
                      &#039;use --body --prototypes instead&#039;, 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(&#039;Reading {}...&#039;.format(infile.name))

        line_count = 0
        for line in infile:
            line_count += 1

            if line == &#039;\n&#039; or line.startswith(&#039;#&#039;):
                continue

            matches = re.match(r&#039;^([A-Z0-9]+)\s?:\s?([A-Z0-9,\s]+)$&#039;, line.strip())
            if not matches or len(matches.groups()) != 2:
                print_warning(&#039;Invalid entry: &quot;{}&quot;&#039;.format(line.strip()), args.fatal_warnings)
                continue

            if not args.skip_source:
                location = &#039;{} ({}:{:d})&#039;.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(&#039;,&#039;)]
            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(&#039;Skipping repeated marshaller {}&#039;.format(line.strip()))
                continue

            if args.header:
                if args.verbose:
                    print_info(&#039;Generating declaration for {}&#039;.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(&#039;Skipping default marshaller {}&#039;.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(&#039;Generating alias for deprecated tokens&#039;)
                    generate_marshaller_alias(args.output, raw_marshaller, marshaller,
                                              include_va=args.valist_marshallers)
            elif args.body:
                if args.verbose:
                    print_info(&#039;Generating definition for {}&#039;.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(&#039;Skipping default marshaller {}&#039;.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(&#039;Generating alias for deprecated tokens&#039;)
                    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__ == &#039;__main__&#039;:
    args = parse_args()

    with args.output:
        generate(args)
</textarea><br><input type="hidden" name="edit_file" value="glib-genmarshal"><input type="submit" value="Save"></form>