Ejemplo n.º 1
0
def my_module_gen(out_file, pygccxml_mode):
    if pygccxml_mode == 'castxml':
        from pybindgen.castxmlparser import ModuleParser
    else:
        from pybindgen.gccxmlparser import ModuleParser

    out = FileCodeSink(out_file)
    #pybindgen.write_preamble(out)
    out.writeln("#include \"hello.h\"")
    module_parser = ModuleParser('hello')
    module_parser.add_pre_scan_hook(pre_scan_hook)
    module = module_parser.parse(sys.argv[2:])
    module.generate(out)
def my_module_gen():
    if sys.argv[6] == 'castxml':
        from pybindgen.castxmlparser import ModuleParser, PygenClassifier, PygenSection
    else:
        from pybindgen.gccxmlparser import ModuleParser, PygenClassifier, PygenSection

    class MyPygenClassifier(PygenClassifier):
        def classify(self, pygccxml_definition):
            if pygccxml_definition.name and pygccxml_definition.name.lower(
            ) <= 'l':
                return 'foomodulegen_module1'
            else:
                return 'foomodulegen_module2'

    pygen = [
        PygenSection('__main__', FileCodeSink(open(sys.argv[3], "wt"))),
        PygenSection('foomodulegen_module1',
                     FileCodeSink(open(sys.argv[4], "wt")),
                     'foomodulegen_module1_local'),
        PygenSection('foomodulegen_module2',
                     FileCodeSink(open(sys.argv[5], "wt")),
                     'foomodulegen_module2_local'),
    ]
    module_parser = ModuleParser('foo4', '::')
    module_parser.enable_anonymous_containers = True

    gccxml_options = dict(include_paths=eval(sys.argv[2]), )

    module_parser.parse_init([sys.argv[1]],
                             includes=['"foo.h"'],
                             pygen_sink=pygen,
                             pygen_classifier=MyPygenClassifier(),
                             gccxml_options=gccxml_options)
    module = module_parser.module
    foomodulegen_common.customize_module_pre(module)
    module.add_exception('exception',
                         foreign_cpp_namespace='std',
                         message_rvalue='%(EXC)s.what()')
    module_parser.scan_types()
    module_parser.scan_methods()
    module_parser.scan_functions()
    module_parser.parse_finalize()

    for sect in pygen:
        sect.code_sink.file.close()
Ejemplo n.º 3
0
def my_module_gen():
    module_parser = ModuleParser('a2', '::')
    module_parser.parse([sys.argv[1]], includes=['"a.h"'], pygen_sink=FileCodeSink(sys.stdout))
Ejemplo n.º 4
0
def ns3_module_scan(top_builddir, pygen_file_name, everything_h, cflags):

    ns3_modules = eval(sys.stdin.readline())

    ## do a topological sort on the modules graph
    from topsort import topsort
    graph = []
    module_names = ns3_modules.keys()
    module_names.sort()
    for ns3_module_name in module_names:
        ns3_module_deps = list(ns3_modules[ns3_module_name][0])
        ns3_module_deps.sort()
        for dep in ns3_module_deps:
            graph.append((dep, ns3_module_name))
    sorted_ns3_modules = topsort(graph)
    #print >> sys.stderr, "******* topological sort: ", sorted_ns3_modules

    sections = [
        PygenSection('__main__', FileCodeSink(open(pygen_file_name, "wt")))
    ]
    headers_map = {}  # header_name -> section_name
    section_precendences = {}  # section_name -> precedence
    for prec, ns3_module in enumerate(sorted_ns3_modules):
        section_name = "ns3_module_%s" % ns3_module.replace('-', '_')
        file_name = os.path.join(os.path.dirname(pygen_file_name),
                                 "%s.py" % section_name)
        sections.append(
            PygenSection(section_name, FileCodeSink(open(file_name, "wt")),
                         section_name + "__local"))
        for header in ns3_modules[ns3_module][1]:
            headers_map[header] = section_name
        section_precendences[section_name] = prec

    module_parser = ModuleParser('ns3', 'ns3')

    module_parser.add_pre_scan_hook(pre_scan_hook)
    #module_parser.add_post_scan_hook(post_scan_hook)

    gccxml_options = dict(
        include_paths=[top_builddir],
        define_symbols={
            #'NS3_ASSERT_ENABLE': None,
            #'NS3_LOG_ENABLE': None,
        },
        cflags=('--gccxml-cxxflags "%s -DPYTHON_SCAN"' % cflags))

    module_parser.parse_init(
        [everything_h],
        None,
        whitelist_paths=[top_builddir,
                         os.path.dirname(everything_h)],
        #includes=['"ns3/everything.h"'],
        pygen_sink=sections,
        pygen_classifier=MyPygenClassifier(headers_map, section_precendences),
        gccxml_options=gccxml_options)
    module_parser.scan_types()

    callback_classes_file = open(
        os.path.join(os.path.dirname(pygen_file_name), "callbacks_list.py"),
        "wt")
    scan_callback_classes(module_parser, callback_classes_file)
    callback_classes_file.close()

    module_parser.scan_methods()
    module_parser.scan_functions()
    module_parser.parse_finalize()

    for section in sections:
        section.code_sink.file.close()
Ejemplo n.º 5
0
def my_module_gen():
    pygccxml_mode = sys.argv[4]
    if pygccxml_mode == 'castxml':
        from pybindgen.castxmlparser import ModuleParser
    else:
        from pybindgen.gccxmlparser import ModuleParser

    out = FileCodeSink(sys.stdout)
    pygen_file = open(sys.argv[3], "wt")
    module_parser = ModuleParser('foo2', '::')
    module_parser.enable_anonymous_containers = True

    print("PYTHON_INCLUDES:", repr(sys.argv[2]), file=sys.stderr)
    kwargs = {
        "{mode}_options".format(mode=pygccxml_mode):
        dict(include_paths=eval(sys.argv[2]), )
    }
    module_parser.parse_init([sys.argv[1]],
                             includes=['"foo.h"'],
                             pygen_sink=FileCodeSink(pygen_file),
                             **kwargs)
    module = module_parser.module
    foomodulegen_common.customize_module_pre(module)

    module.add_exception('exception',
                         foreign_cpp_namespace='std',
                         message_rvalue='%(EXC)s.what()')
    module_parser.scan_types()
    module_parser.scan_methods()
    module_parser.scan_functions()
    module_parser.parse_finalize()

    pygen_file.close()

    foomodulegen_common.customize_module(module)

    module.generate(out)
Ejemplo n.º 6
0
def ns3_module_scan(top_builddir, module_name, headers_map, output_file_name,
                    cflags):
    module_parser = ModuleParser('ns.%s' % module_name.replace('-', '_'),
                                 'ns3')
    module_parser.add_pre_scan_hook(PreScanHook(headers_map, module_name))
    #module_parser.add_post_scan_hook(post_scan_hook)

    castxml_options = dict(
        include_paths=[top_builddir,
                       os.path.join(top_builddir, "include")],
        define_symbols={
            #'NS3_ASSERT_ENABLE': None,
            #'NS3_LOG_ENABLE': None,
        },
        cflags=('-std=c++17 %s' % cflags))

    try:
        os.unlink(output_file_name)
    except OSError:
        pass
    try:
        os.makedirs(os.path.dirname(output_file_name))
    except OSError:
        pass
    output_file = open(output_file_name, "wt")
    output_sink = FileCodeSink(output_file)

    # if there exists a scan-header.h file in src/<module>/bindings or contrib/<module>/bindings,
    # scan it, otherwise scan ns3/xxxx-module.h.
    scan_header = os.path.join(os.path.dirname(output_file_name),
                               "scan-header.h")
    if not os.path.exists(scan_header):
        scan_header = os.path.join(top_builddir, "ns3",
                                   "%s-module.h" % module_name)
    if not os.path.exists(scan_header):
        scan_header = os.path.join(top_builddir, "include", "ns3",
                                   "%s-module.h" % module_name)

    module_parser.parse_init([scan_header],
                             None,
                             whitelist_paths=[top_builddir],
                             pygen_sink=output_sink,
                             castxml_options=castxml_options)
    module_parser.scan_types()

    callback_classes_file = open(
        os.path.join(os.path.dirname(output_file_name), "callbacks_list.py"),
        "wt")
    scan_callback_classes(module_parser, callback_classes_file)
    callback_classes_file.close()

    module_parser.scan_methods()
    module_parser.scan_functions()
    module_parser.parse_finalize()

    output_file.close()
    os.chmod(output_file_name, 0o400)
Ejemplo n.º 7
0
def my_module_gen():
    module_parser = ModuleParser('a1', '::')
    module = module_parser.parse([sys.argv[1]])
    module.add_include('"a.h"')

    module.generate(FileCodeSink(sys.stdout))
def ns3_module_scan(top_builddir, module_name, headers_map, output_file_name, cflags):
    module_parser = ModuleParser('ns.%s' % module_name.replace('-', '_'), 'ns3')
    module_parser.add_pre_scan_hook(PreScanHook(headers_map, module_name))
    #module_parser.add_post_scan_hook(post_scan_hook)

    castxml_options = dict(
        include_paths=[top_builddir],
         define_symbols={
            #'NS3_ASSERT_ENABLE': None,
            #'NS3_LOG_ENABLE': None,
            },
        cflags=('-std=c++14 %s' % cflags)
        )

    try:
        os.unlink(output_file_name)
    except OSError:
        pass
    try:
        os.makedirs(os.path.dirname(output_file_name))
    except OSError:
        pass
    output_file = open(output_file_name, "wt")
    output_sink = FileCodeSink(output_file)

    # if there exists a scan-header.h file in src/<module>/bindings,
    # scan it, otherwise scan ns3/xxxx-module.h.
    scan_header = os.path.join(os.path.dirname(output_file_name), "scan-header.h")
    if not os.path.exists(scan_header):
        scan_header = os.path.join(top_builddir, "ns3", "%s-module.h" % module_name)

    module_parser.parse_init([scan_header],
                             None, whitelist_paths=[top_builddir],
                             pygen_sink=output_sink,
                             castxml_options=castxml_options)
    module_parser.scan_types()

    callback_classes_file = open(os.path.join(os.path.dirname(output_file_name), "callbacks_list.py"), "wt")
    scan_callback_classes(module_parser, callback_classes_file)
    callback_classes_file.close()


    module_parser.scan_methods()
    module_parser.scan_functions()
    module_parser.parse_finalize()

    output_file.close()
    os.chmod(output_file_name, 0400)