def __init__(self, main_file_name):
self.main_file_name = main_file_name
self.main_sink = FileCodeSink(open(main_file_name, "wt"))
self.header_name = "foomodule4.h"
header_file_name = os.path.join(os.path.dirname(self.main_file_name), self.header_name)
self.header_sink = FileCodeSink(open(header_file_name, "wt"))
self.section_sinks = {}
def my_module_gen():
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)
gccxml_options = dict(
include_paths=eval(sys.argv[2]),
)
module_parser.parse_init([sys.argv[1]], includes=['"foo.h"'], pygen_sink=FileCodeSink(pygen_file),
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()
pygen_file.close()
foomodulegen_common.customize_module(module)
module.generate(out)
def my_module_gen():
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
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()
def __init__(self, dir):
self.main_file_name = os.path.join(dir, "foomodule4.cc")
self.main_sink = FileCodeSink(open(self.main_file_name, "wt"))
self.header_name = "foomodule4.h"
header_file_name = os.path.join(dir, self.header_name)
self.header_sink = FileCodeSink(open(header_file_name, "wt"))
self.section_sinks = {}
def __init__(self, main_file_name):
super(MyMultiSectionFactory, self).__init__()
self.main_file_name = main_file_name
self.main_sink = FileCodeSink(open(main_file_name, "wt"))
self.header_name = "ns3module.h"
header_file_name = os.path.join(os.path.dirname(self.main_file_name), self.header_name)
#print >> sys.stderr, ">>>>>>>>>>>>>>>>>", header_file_name, main_file_name
self.header_sink = FileCodeSink(open(header_file_name, "wt"))
def my_module_gen(out_file):
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[1:])
module.generate(out)
def my_module_gen(out_file):
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[1:])
module.generate(out)
def __init__(self, main_file_name):
self.main_file_name = main_file_name
self.main_sink = FileCodeSink(open("src/" + main_file_name, "wt"))
self.header_name = "tr_module.h"
header_file_name = os.path.join(os.path.dirname(self.main_file_name), self.header_name)
self.header_sink = FileCodeSink(open("src/" + header_file_name, "wt"))
self.section_sinks = {}
self.main_sink.writeln(self._header)
self.header_sink.writeln(self._header)
def get_section_code_sink(self, section_name):
if section_name == "__main__":
return self.main_sink
try:
return self.section_sinks[section_name]
except KeyError:
file_name = os.path.join(os.path.dirname(self.main_file_name), "src/%s.cc" % section_name)
sink = FileCodeSink(open(file_name, "wt"))
self.section_sinks[section_name] = sink
sink.writeln(self._header)
return sink
def __init__(self, main_file_name):
self.main_file_name = main_file_name
self.main_sink = FileCodeSink(open('src/' + main_file_name, "wt"))
self.header_name = "tr_module.h"
header_file_name = os.path.join(os.path.dirname(self.main_file_name),
self.header_name)
self.header_sink = FileCodeSink(open('src/' + header_file_name, "wt"))
self.section_sinks = {}
self.main_sink.writeln(self._header)
self.header_sink.writeln(self._header)
def get_section_code_sink(self, section_name):
if section_name == '__main__':
return self.main_sink
try:
return self.section_sinks[section_name]
except KeyError:
file_name = os.path.join(os.path.dirname(self.main_file_name),
"src/%s.cc" % section_name)
sink = FileCodeSink(open(file_name, "wt"))
self.section_sinks[section_name] = sink
sink.writeln(self._header)
return sink
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 module_gen():
os.chdir('/home/trevorsweetnam/Dropbox/notebooks/eef/emxarr/codegen/dll/emx_test')
#module_parser = ModuleParser('emx_test_emxAPI', '::')
#module = module_parser.parse(['emx_test_emxAPI.h'])
#module.add_include('"emx_test_emxAPI.h"')
module_parser = ModuleParser('emx_test', '::')
module = module_parser.parse(['emx_test.h'])
module.add_include('"rt_noninfite.h"')
module.add_include('"emx_test_emxutil.h"')
pybindgen.write_preamble(FileCodeSink(sys.stdout))
module.generate(FileCodeSink(sys.stdout))
def __init__(self, main_file_name, modules):
super(MyMultiSectionFactory, self).__init__()
self.main_file_name = main_file_name
self.main_sink = FileCodeSink(open(main_file_name, "wt"))
self.header_name = "ns3module.h"
header_file_name = os.path.join(os.path.dirname(self.main_file_name), self.header_name)
self.header_sink = FileCodeSink(open(header_file_name, "wt"))
self.section_sinks = {'__main__': self.main_sink}
for module in modules:
section_name = 'ns3_module_%s' % module.replace('-', '_')
file_name = os.path.join(os.path.dirname(self.main_file_name), "%s.cc" % section_name)
sink = FileCodeSink(open(file_name, "wt"))
self.section_sinks[section_name] = sink
def my_module_gen(out_file):
mod = Module('g')
mod.add_include('"g.h"')
mod.add_function('GDoA', None, [])
G = mod.add_cpp_namespace("G")
G.add_function('GDoB', None, [])
GInner = G.add_cpp_namespace("GInner")
GInner.add_function('GDoC', None, [])
G.add_include('<fstream>')
ofstream = G.add_class('ofstream', foreign_cpp_namespace='::std')
ofstream.add_enum('openmode', [
('app', 'std::ios_base::app'),
('ate', 'std::ios_base::ate'),
('binary', 'std::ios_base::binary'),
('in', 'std::ios_base::in'),
('out', 'std::ios_base::out'),
('trunc', 'std::ios_base::trunc'),
])
ofstream.add_constructor([
Parameter.new("const char *", 'filename'),
Parameter.new("::std::ofstream::openmode",
'mode',
default_value="std::ios_base::out")
])
ofstream.add_method('close', None, [])
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
pybindgen.settings.deprecated_virtuals = False
mod = Module('testapi_pybindgen')
mod.add_include('"testapi.h"')
mod.add_function('func1', None, [])
mod.add_function('func2', 'double', [
param('double', 'x'),
param('double', 'y'),
param('double', 'z'),
])
Multiplier = mod.add_class('Multiplier', allow_subclassing=True)
Multiplier.add_constructor([])
Multiplier.add_constructor([param('double', 'factor')])
Multiplier.add_method('GetFactor', 'double', [], is_const=True)
Multiplier.add_method('SetFactor',
'void', [param('double', 'f')],
is_const=True)
Multiplier.add_method('SetFactor', 'void', [], is_const=True)
Multiplier.add_method('Multiply',
'double', [param('double', 'value')],
is_virtual=True,
is_const=True)
mod.add_function(
'call_virtual_from_cpp', 'double',
[param('Multiplier const *', 'obj'),
param('double', 'value')])
mod.generate(FileCodeSink(out_file))
def main():
out = FileCodeSink(sys.stdout)
root_module = module_init()
register_types(root_module)
register_methods(root_module)
register_functions(root_module)
root_module.generate(out)
def my_module_gen():
libName = 'libPy' + sys.argv[2]
className = sys.argv[2] + '.hh'
includeFile = sys.argv[1] + '/' + className
module_parser = ModuleParser(libName, '::')
module_parser.parse([includeFile],
includes=['"' + includeFile + '"'],
pygen_sink=FileCodeSink(sys.stdout))
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()
def my_module_gen(out_file):
mod = Module('a')
mod.add_include('"a.h"')
mod.add_function('ADoA', None, [])
mod.add_function('ADoB', None, [Parameter.new('uint32_t', 'b')])
mod.add_function('ADoC', ReturnValue.new('uint32_t'), [])
mod.generate(FileCodeSink(out_file) )
def my_module_gen(out_file):
mod = Module('c')
mod.add_include('"c.h"')
mod.add_function("GetBuffer",
BufferReturn("unsigned short int*", "GetBufferLen()"), [])
mod.add_function("GetBufferLen", ReturnValue.new("int"), [])
mod.add_function("GetBufferChecksum", ReturnValue.new("unsigned short"),
[])
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('f')
mod.add_include('"f.h"')
FBase = mod.add_class('FBase', allow_subclassing=True)
FBase.add_constructor([])
FBase.add_method('DoA', None, [], is_virtual=True, is_pure_virtual=True)
FBase.add_method('PrivDoB', None, [], is_virtual=True, is_pure_virtual=True, visibility='private')
FBase.add_method('DoB', None, [])
mod.generate(FileCodeSink(out_file) )
def my_module_gen(out_file):
mod = Module('bar')
mod.add_include('"bar.h"')
Foo = mod.add_class('Foo',
automatic_type_narrowing=True,
memory_policy=cppclass.BoostSharedPtr('::Foo'))
Foo.add_static_attribute('instance_count', ReturnValue.new('int'))
Foo.add_constructor([Parameter.new('std::string', 'datum')])
Foo.add_constructor([])
Foo.add_method('get_datum', ReturnValue.new('const std::string'), [])
Foo.add_method('is_initialized',
ReturnValue.new('bool'), [],
is_const=True)
Foo.add_output_stream_operator()
mod.add_function('function_that_takes_foo', ReturnValue.new('void'),
[param('boost::shared_ptr<Foo>', 'foo')])
mod.add_function('function_that_returns_foo',
retval('boost::shared_ptr<Foo>'), [])
cls = mod.add_class('ClassThatTakesFoo', allow_subclassing=True)
cls.add_constructor([Parameter.new('boost::shared_ptr<Foo>', 'foo')])
cls.add_method('get_foo', ReturnValue.new('boost::shared_ptr<Foo>'), [])
cls.add_method('get_modified_foo',
retval('boost::shared_ptr<Foo>'),
[param('boost::shared_ptr<Foo>', 'foo')],
is_virtual=True,
is_const=True)
#### --- error handler ---
class MyErrorHandler(pybindgen.settings.ErrorHandler):
def __init__(self):
super(MyErrorHandler, self).__init__()
self.num_errors = 0
def handle_error(self, wrapper, exception, traceback_):
print >> sys.stderr, "exception %s in wrapper %s" % (exception,
wrapper)
self.num_errors += 1
if 0: # verbose?
import traceback
traceback.print_tb(traceback_)
return True
pybindgen.settings.error_handler = MyErrorHandler()
## ---- finally, generate the whole thing ----
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('b')
mod.add_include('"b.h"')
B = mod.add_class('B')
B.add_constructor([])
B.add_instance_attribute('b_a', ReturnValue.new('uint32_t'))
B.add_instance_attribute('b_b', ReturnValue.new('uint32_t'))
mod.add_function('BDoA', None, [Parameter.new('B', 'b')])
mod.add_function('BDoB', ReturnValue.new('B'), [])
mod.generate(FileCodeSink(out_file) )
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)
def my_module_gen(out_file):
mod = Module('d')
mod.add_include('"d.h"')
D = mod.add_class('D', memory_policy=cppclass.FreeFunctionPolicy('DDestroy'))
D.add_instance_attribute('d', ReturnValue.new('bool'))
D.add_function_as_constructor("DCreate", ReturnValue.new("D*", caller_owns_return=True), [])
mod.add_function('DDoA', None, [Parameter.new('D*', 'd', transfer_ownership=False)])
mod.add_function('DDoB', None, [Parameter.new('D&', 'd', direction=Parameter.DIRECTION_IN)])
mod.add_function('DDoC', None, [Parameter.new('const D&', 'd',
direction=Parameter.DIRECTION_IN)])
mod.generate(FileCodeSink(out_file) )
def my_module_gen(out_file):
mod = Module('c')
mod.add_include('"c.h"')
C = mod.add_class('C')
C.add_constructor([])
C.add_constructor([Parameter.new('uint32_t', 'c')])
C.add_method('DoA', None, [], is_static=True)
C.add_method('DoB', None, [])
C.add_method('DoC', None, [Parameter.new('uint32_t', 'c')])
C.add_method('DoD', ReturnValue.new('uint32_t'), [])
C.add_method('DoE', None, [], is_virtual=True)
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('b')
mod.add_include('"b.h"')
# Base
Base = mod.add_class("Base",
allow_subclassing=True,
import_from_module='a')
Base.add_constructor([])
Base.add_method("do_something", None, [], is_virtual=True)
# Derived
Derived = mod.add_class("Derived", allow_subclassing=True, parent=Base)
Derived.add_constructor([])
Derived.add_method("do_something", None, [], is_virtual=True)
mod.generate(FileCodeSink(out_file))
def my_module_gen():
out = FileCodeSink(sys.stdout)
root_module = foomodulegen_generated.module_init()
root_module.add_exception('exception', foreign_cpp_namespace='std', message_rvalue='%(EXC)s.what()')
foomodulegen_common.customize_module_pre(root_module)
## this is a very special case when we want to change the name of
## the python module to allow parallel testing of the same basic
## module 'foo' generated by 3 different code paths; normally
## users don't need this.
root_module.name = 'foo3'
foomodulegen_generated.register_types(root_module)
foomodulegen_generated.register_methods(root_module)
foomodulegen_generated.register_functions(root_module)
foomodulegen_common.customize_module(root_module)
root_module.generate(out)
def my_module_gen(out_file):
mod = Module('h')
mod.add_include('"h.h"')
H = mod.add_class('H')
H.add_constructor([])
H.add_method('Do', None, [])
Inner = mod.add_class('Inner', outer_class=H)
Inner.add_constructor([])
Inner.add_method('Do', None, [])
MostInner = mod.add_class('MostInner', outer_class=Inner)
MostInner.add_constructor([])
MostInner.add_method('Do', None, [])
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('e')
mod.add_include('"e.h"')
E = mod.add_class('E',
memory_policy=cppclass.ReferenceCountingMethodsPolicy(
decref_method='Unref', incref_method='Ref'))
if 1:
E.add_function_as_constructor(
"E::CreateWithRef", ReturnValue.new("E*", caller_owns_return=True),
[])
else:
## alternative:
E.add_function_as_constructor(
"E::CreateWithoutRef",
ReturnValue.new("E*", caller_owns_return=False), [])
E.add_method("Do", None, [])
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('sp')
mod.add_include('"sp.h"')
Foo = mod.add_class('Foo', memory_policy=StdSharedPtr('::Foo'))
Foo.add_constructor([param('std::string', 'datum')])
Foo.add_constructor([])
Foo.add_method('get_datum', retval('const std::string'), [])
Foo.add_method('set_datum', None, [param('const std::string', 'datum')])
mod.add_function('function_that_takes_foo', None,
[param('std::shared_ptr<Foo>', 'foo')])
mod.add_function('function_that_returns_foo',
retval('std::shared_ptr<Foo>'), [])
## ---- finally, generate the whole thing ----
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('c')
mod.add_include('"c.h"')
mod.header.writeln("""void _wrap_Visit(int value, void *data);""")
mod.body.writeln("""
void _wrap_Visit(int value, void *data)
{
PyObject *callback = (PyObject*) data;
PyObject_CallFunction(callback, (char*) "i", value);
}
""")
mod.add_function(
"visit", None, [Parameter.new("Visitor", "visitor")]
# the 'data' parameter is inserted automatically
# by the custom callback type handler
)
mod.generate(FileCodeSink(out_file))
class TrMultiSectionFactory(MultiSectionFactory):
_header = (
"/* ** GENERATED CODE -- DO NOT EDIT **\n"
" *\n"
" * Copyright (c) 2012 Dan Eicher\n"
" *\n"
" * Permission is hereby granted, free of charge, to any person obtaining a\n"
' * copy of this software and associated documentation files (the "Software"),\n'
" * to deal in the Software without restriction, including without limitation\n"
" * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
" * and/or sell copies of the Software, and to permit persons to whom the\n"
" * Software is furnished to do so, subject to the following conditions:\n"
" *\n"
" * The above copyright notice and this permission notice shall be included in\n"
" * all copies or substantial portions of the Software.\n"
" *\n"
' * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n'
" * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
" * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n"
" * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n"
" * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
" * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n"
" * DEALINGS IN THE SOFTWARE.\n"
" *\n"
" */\n"
)
def __init__(self, main_file_name):
self.main_file_name = main_file_name
self.main_sink = FileCodeSink(open("src/" + main_file_name, "wt"))
self.header_name = "tr_module.h"
header_file_name = os.path.join(os.path.dirname(self.main_file_name), self.header_name)
self.header_sink = FileCodeSink(open("src/" + header_file_name, "wt"))
self.section_sinks = {}
self.main_sink.writeln(self._header)
self.header_sink.writeln(self._header)
def get_section_code_sink(self, section_name):
if section_name == "__main__":
return self.main_sink
try:
return self.section_sinks[section_name]
except KeyError:
file_name = os.path.join(os.path.dirname(self.main_file_name), "src/%s.cc" % section_name)
sink = FileCodeSink(open(file_name, "wt"))
self.section_sinks[section_name] = sink
sink.writeln(self._header)
return sink
def get_main_code_sink(self):
return self.main_sink
def get_common_header_code_sink(self):
return self.header_sink
def get_common_header_include(self):
return '"%s"' % self.header_name
def close(self):
self.header_sink.file.close()
self.main_sink.file.close()
for sink in self.section_sinks.itervalues():
sink.file.close()
