<h2>Edit File: codegen_main.py</h2><form method="post"><textarea name="content" rows="20" cols="80"># -*- Mode: Python -*-
# coding=utf-8

# GDBus - GLib D-Bus Library
#
# Copyright (C) 2008-2011 Red Hat, Inc.
# Copyright (C) 2018 Iñigo Martínez &lt;inigomartinez@gmail.com&gt;
#
# 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;.
#
# Author: David Zeuthen &lt;davidz@redhat.com&gt;

import argparse
import os
import sys

from . import config
from . import dbustypes
from . import parser
from . import codegen
from . import codegen_docbook
from .utils import print_error, print_warning


def find_arg(arg_list, arg_name):
    for a in arg_list:
        if a.name == arg_name:
            return a
    return None


def find_method(iface, method):
    for m in iface.methods:
        if m.name == method:
            return m
    return None


def find_signal(iface, signal):
    for m in iface.signals:
        if m.name == signal:
            return m
    return None


def find_prop(iface, prop):
    for m in iface.properties:
        if m.name == prop:
            return m
    return None


def apply_annotation(iface_list, iface, method, signal, prop, arg, key, value):
    iface_obj = None
    for i in iface_list:
        if i.name == iface:
            iface_obj = i
            break

    if iface_obj is None:
        print_error(&#039;No interface &quot;{}&quot;&#039;.format(iface))

    target_obj = None

    if method:
        method_obj = find_method(iface_obj, method)
        if method_obj is None:
            print_error(&#039;No method &quot;{}&quot; on interface &quot;{}&quot;&#039;.format(method, iface))
        if arg:
            arg_obj = find_arg(method_obj.in_args, arg)
            if arg_obj is None:
                arg_obj = find_arg(method_obj.out_args, arg)
                if arg_obj is None:
                    print_error(
                        &#039;No arg &quot;{}&quot; on method &quot;{}&quot; on interface &quot;{}&quot;&#039;.format(
                            arg, method, iface
                        )
                    )
            target_obj = arg_obj
        else:
            target_obj = method_obj
    elif signal:
        signal_obj = find_signal(iface_obj, signal)
        if signal_obj is None:
            print_error(&#039;No signal &quot;{}&quot; on interface &quot;{}&quot;&#039;.format(signal, iface))
        if arg:
            arg_obj = find_arg(signal_obj.args, arg)
            if arg_obj is None:
                print_error(
                    &#039;No arg &quot;{}&quot; on signal &quot;{}&quot; on interface &quot;{}&quot;&#039;.format(
                        arg, signal, iface
                    )
                )
            target_obj = arg_obj
        else:
            target_obj = signal_obj
    elif prop:
        prop_obj = find_prop(iface_obj, prop)
        if prop_obj is None:
            print_error(&#039;No property &quot;{}&quot; on interface &quot;{}&quot;&#039;.format(prop, iface))
        target_obj = prop_obj
    else:
        target_obj = iface_obj
    target_obj.annotations.insert(0, dbustypes.Annotation(key, value))


def apply_annotations(iface_list, annotation_list):
    # apply annotations given on the command line
    for (what, key, value) in annotation_list:
        pos = what.find(&quot;::&quot;)
        if pos != -1:
            # signal
            iface = what[0:pos]
            signal = what[pos + 2 :]
            pos = signal.find(&quot;[&quot;)
            if pos != -1:
                arg = signal[pos + 1 :]
                signal = signal[0:pos]
                pos = arg.find(&quot;]&quot;)
                arg = arg[0:pos]
                apply_annotation(iface_list, iface, None, signal, None, arg, key, value)
            else:
                apply_annotation(
                    iface_list, iface, None, signal, None, None, key, value
                )
        else:
            pos = what.find(&quot;:&quot;)
            if pos != -1:
                # property
                iface = what[0:pos]
                prop = what[pos + 1 :]
                apply_annotation(iface_list, iface, None, None, prop, None, key, value)
            else:
                pos = what.find(&quot;()&quot;)
                if pos != -1:
                    # method
                    combined = what[0:pos]
                    pos = combined.rfind(&quot;.&quot;)
                    iface = combined[0:pos]
                    method = combined[pos + 1 :]
                    pos = what.find(&quot;[&quot;)
                    if pos != -1:
                        arg = what[pos + 1 :]
                        pos = arg.find(&quot;]&quot;)
                        arg = arg[0:pos]
                        apply_annotation(
                            iface_list, iface, method, None, None, arg, key, value
                        )
                    else:
                        apply_annotation(
                            iface_list, iface, method, None, None, None, key, value
                        )
                else:
                    # must be an interface
                    iface = what
                    apply_annotation(
                        iface_list, iface, None, None, None, None, key, value
                    )


def codegen_main():
    arg_parser = argparse.ArgumentParser(
        description=&quot;D-Bus code and documentation generator&quot;
    )
    arg_parser.add_argument(
        &quot;files&quot;, metavar=&quot;FILE&quot;, nargs=&quot;+&quot;, help=&quot;D-Bus introspection XML file&quot;
    )
    arg_parser.add_argument(
        &quot;--xml-files&quot;,
        metavar=&quot;FILE&quot;,
        action=&quot;append&quot;,
        default=[],
        help=argparse.SUPPRESS,
    )
    arg_parser.add_argument(
        &quot;--interface-prefix&quot;,
        metavar=&quot;PREFIX&quot;,
        default=&quot;&quot;,
        help=&quot;String to strip from D-Bus interface names for code and docs&quot;,
    )
    arg_parser.add_argument(
        &quot;--c-namespace&quot;,
        metavar=&quot;NAMESPACE&quot;,
        default=&quot;&quot;,
        help=&quot;The namespace to use for generated C code&quot;,
    )
    arg_parser.add_argument(
        &quot;--c-generate-object-manager&quot;,
        action=&quot;store_true&quot;,
        help=&quot;Generate a GDBusObjectManagerClient subclass when generating C code&quot;,
    )
    arg_parser.add_argument(
        &quot;--c-generate-autocleanup&quot;,
        choices=[&quot;none&quot;, &quot;objects&quot;, &quot;all&quot;],
        default=&quot;objects&quot;,
        help=&quot;Generate autocleanup support&quot;,
    )
    arg_parser.add_argument(
        &quot;--generate-docbook&quot;,
        metavar=&quot;OUTFILES&quot;,
        help=&quot;Generate Docbook in OUTFILES-org.Project.IFace.xml&quot;,
    )
    arg_parser.add_argument(
        &quot;--pragma-once&quot;,
        action=&quot;store_true&quot;,
        help=&#039;Use &quot;pragma once&quot; as the inclusion guard&#039;,
    )
    arg_parser.add_argument(
        &quot;--annotate&quot;,
        nargs=3,
        action=&quot;append&quot;,
        metavar=&quot;WHAT KEY VALUE&quot;,
        help=&quot;Add annotation (may be used several times)&quot;,
    )
    arg_parser.add_argument(
        &quot;--glib-min-required&quot;,
        metavar=&quot;VERSION&quot;,
        help=&quot;Minimum version of GLib to be supported by the outputted code &quot;
        &quot;(default: 2.30)&quot;,
    )
    arg_parser.add_argument(
        &quot;--glib-max-allowed&quot;,
        metavar=&quot;VERSION&quot;,
        help=&quot;Maximum version of GLib to be used by the outputted code &quot;
        &quot;(default: current GLib version)&quot;,
    )
    arg_parser.add_argument(
        &quot;--symbol-decorator&quot;,
        help=&quot;Macro used to decorate a symbol in the outputted header, &quot;
        &quot;possibly to export symbols&quot;,
    )
    arg_parser.add_argument(
        &quot;--symbol-decorator-header&quot;,
        help=&quot;Additional header required for decorator specified by &quot;
        &quot;--symbol-decorator&quot;,
    )
    arg_parser.add_argument(
        &quot;--symbol-decorator-define&quot;,
        help=&quot;Additional define required for decorator specified by &quot;
        &quot;--symbol-decorator&quot;,
    )

    group = arg_parser.add_mutually_exclusive_group()
    group.add_argument(
        &quot;--generate-c-code&quot;, metavar=&quot;OUTFILES&quot;, help=&quot;Generate C code in OUTFILES.[ch]&quot;
    )
    group.add_argument(&quot;--header&quot;, action=&quot;store_true&quot;, help=&quot;Generate C headers&quot;)
    group.add_argument(&quot;--body&quot;, action=&quot;store_true&quot;, help=&quot;Generate C code&quot;)
    group.add_argument(
        &quot;--interface-info-header&quot;,
        action=&quot;store_true&quot;,
        help=&quot;Generate GDBusInterfaceInfo C header&quot;,
    )
    group.add_argument(
        &quot;--interface-info-body&quot;,
        action=&quot;store_true&quot;,
        help=&quot;Generate GDBusInterfaceInfo C code&quot;,
    )

    group = arg_parser.add_mutually_exclusive_group()
    group.add_argument(
        &quot;--output&quot;, metavar=&quot;FILE&quot;, help=&quot;Write output into the specified file&quot;
    )
    group.add_argument(
        &quot;--output-directory&quot;,
        metavar=&quot;OUTDIR&quot;,
        default=&quot;&quot;,
        help=&quot;Location to output generated files&quot;,
    )

    args = arg_parser.parse_args()

    if len(args.xml_files) &gt; 0:
        print_warning(
            &#039;The &quot;--xml-files&quot; option is deprecated; use positional arguments instead&#039;
        )

    if (
        args.generate_c_code is not None or args.generate_docbook is not None
    ) and args.output is not None:
        print_error(
            &quot;Using --generate-c-code or --generate-docbook and &quot;
            &quot;--output at the same time is not allowed&quot;
        )

    if args.generate_c_code:
        header_name = args.generate_c_code + &quot;.h&quot;
        h_file = os.path.join(args.output_directory, header_name)
        args.header = True
        c_file = os.path.join(args.output_directory, args.generate_c_code + &quot;.c&quot;)
        args.body = True
    elif args.header:
        if args.output is None:
            print_error(&quot;Using --header requires --output&quot;)

        h_file = args.output
        header_name = os.path.basename(h_file)
    elif args.body:
        if args.output is None:
            print_error(&quot;Using --body requires --output&quot;)

        c_file = args.output
        header_name = os.path.splitext(os.path.basename(c_file))[0] + &quot;.h&quot;
    elif args.interface_info_header:
        if args.output is None:
            print_error(&quot;Using --interface-info-header requires --output&quot;)
        if args.c_generate_object_manager:
            print_error(
                &quot;--c-generate-object-manager is incompatible with &quot;
                &quot;--interface-info-header&quot;
            )

        h_file = args.output
        header_name = os.path.basename(h_file)
    elif args.interface_info_body:
        if args.output is None:
            print_error(&quot;Using --interface-info-body requires --output&quot;)
        if args.c_generate_object_manager:
            print_error(
                &quot;--c-generate-object-manager is incompatible with &quot;
                &quot;--interface-info-body&quot;
            )

        c_file = args.output
        header_name = os.path.splitext(os.path.basename(c_file))[0] + &quot;.h&quot;

    # Check the minimum GLib version. The minimum --glib-min-required is 2.30,
    # because that’s when gdbus-codegen was introduced. Support 1, 2 or 3
    # component versions, but ignore the micro component if it’s present.
    if args.glib_min_required:
        try:
            parts = args.glib_min_required.split(&quot;.&quot;, 3)
            glib_min_required = (int(parts[0]), int(parts[1] if len(parts) &gt; 1 else 0))
            # Ignore micro component, but still validate it:
            _ = int(parts[2] if len(parts) &gt; 2 else 0)  # noqa: F841
        except (ValueError, IndexError):
            print_error(
                &quot;Unrecognized --glib-min-required string ‘{}’&quot;.format(
                    args.glib_min_required
                )
            )

        if glib_min_required &lt; (2, 30):
            print_error(
                &quot;Invalid --glib-min-required string ‘{}’: minimum &quot;
                &quot;version is 2.30&quot;.format(args.glib_min_required)
            )
    else:
        glib_min_required = (2, 30)

    # And the maximum GLib version.
    if args.glib_max_allowed:
        try:
            parts = args.glib_max_allowed.split(&quot;.&quot;, 3)
            glib_max_allowed = (int(parts[0]), int(parts[1] if len(parts) &gt; 1 else 0))
            # Ignore micro component, but still validate it:
            _ = int(parts[2] if len(parts) &gt; 2 else 0)  # noqa: F841
        except (ValueError, IndexError):
            print_error(
                &quot;Unrecognized --glib-max-allowed string ‘{}’&quot;.format(
                    args.glib_max_allowed
                )
            )
    else:
        glib_max_allowed = (config.MAJOR_VERSION, config.MINOR_VERSION)

    # Only allow --symbol-decorator-define and --symbol-decorator-header if
    # --symbol-decorator is used
    if args.symbol_decorator is None:
        if args.symbol_decorator_header or args.symbol_decorator_define:
            print_error(
                &quot;--symbol-decorator-define and --symbol-decorator-header must &quot;
                &quot;be used with --symbol-decorator&quot;
            )

    # Round --glib-max-allowed up to the next stable release.
    glib_max_allowed = (
        glib_max_allowed[0],
        glib_max_allowed[1] + (glib_max_allowed[1] % 2),
    )

    if glib_max_allowed &lt; glib_min_required:
        print_error(
            &quot;Invalid versions: --glib-min-required ({}) must be &quot;
            &quot;less than or equal to --glib-max-allowed ({})&quot;.format(
                glib_min_required, glib_max_allowed
            )
        )

    all_ifaces = []
    input_files_basenames = []
    for fname in sorted(args.files + args.xml_files):
        with open(fname, &quot;rb&quot;) as f:
            xml_data = f.read()
        parsed_ifaces = parser.parse_dbus_xml(
            xml_data, h_type_implies_unix_fd=(glib_min_required &gt;= (2, 64))
        )
        all_ifaces.extend(parsed_ifaces)
        input_files_basenames.append(os.path.basename(fname))

    if args.annotate is not None:
        apply_annotations(all_ifaces, args.annotate)

    for i in all_ifaces:
        i.post_process(args.interface_prefix, args.c_namespace)

    docbook = args.generate_docbook
    docbook_gen = codegen_docbook.DocbookCodeGenerator(all_ifaces)
    if docbook:
        docbook_gen.generate(docbook, args.output_directory)

    if args.header:
        with open(h_file, &quot;w&quot;) as outfile:
            gen = codegen.HeaderCodeGenerator(
                all_ifaces,
                args.c_namespace,
                args.c_generate_object_manager,
                args.c_generate_autocleanup,
                header_name,
                input_files_basenames,
                args.pragma_once,
                glib_min_required,
                args.symbol_decorator,
                args.symbol_decorator_header,
                outfile,
            )
            gen.generate()

    if args.body:
        with open(c_file, &quot;w&quot;) as outfile:
            gen = codegen.CodeGenerator(
                all_ifaces,
                args.c_namespace,
                args.c_generate_object_manager,
                header_name,
                input_files_basenames,
                docbook_gen,
                glib_min_required,
                args.symbol_decorator_define,
                outfile,
            )
            gen.generate()

    if args.interface_info_header:
        with open(h_file, &quot;w&quot;) as outfile:
            gen = codegen.InterfaceInfoHeaderCodeGenerator(
                all_ifaces,
                args.c_namespace,
                header_name,
                input_files_basenames,
                args.pragma_once,
                glib_min_required,
                args.symbol_decorator,
                args.symbol_decorator_header,
                outfile,
            )
            gen.generate()

    if args.interface_info_body:
        with open(c_file, &quot;w&quot;) as outfile:
            gen = codegen.InterfaceInfoBodyCodeGenerator(
                all_ifaces,
                args.c_namespace,
                header_name,
                input_files_basenames,
                glib_min_required,
                args.symbol_decorator_define,
                outfile,
            )
            gen.generate()

    sys.exit(0)


if __name__ == &quot;__main__&quot;:
    codegen_main()
</textarea><br><input type="hidden" name="edit_file" value="codegen_main.py"><input type="submit" value="Save"></form>