-
Notifications
You must be signed in to change notification settings - Fork 221
Expand file tree
/
Copy pathexec.cpp
More file actions
143 lines (123 loc) · 3.98 KB
/
exec.cpp
File metadata and controls
143 lines (123 loc) · 3.98 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
// Copyright Stefan Seefeld 2005.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/python.hpp>
#include <iostream>
namespace python = boost::python;
std::string script;
// An abstract base class
class Base : public boost::noncopyable
{
public:
virtual ~Base() {};
virtual std::string hello() = 0;
};
// C++ derived class
class CppDerived : public Base
{
public:
virtual ~CppDerived() {}
virtual std::string hello() { return "Hello from C++!";}
};
// Familiar Boost.Python wrapper class for Base
struct BaseWrap : Base, python::wrapper<Base>
{
virtual std::string hello()
{
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
// workaround for VC++ 6.x or 7.0, see
// http://boost.org/libs/python/doc/tutorial/doc/html/python/exposing.html#python.class_virtual_functions
return python::call<std::string>(this->get_override("hello").ptr());
#else
return this->get_override("hello")();
#endif
}
};
// Pack the Base class wrapper into a module
BOOST_PYTHON_MODULE(embedded_hello)
{
python::class_<BaseWrap, boost::noncopyable> base("Base");
}
void exec_test()
{
// Register the module with the interpreter
if (PyImport_AppendInittab("embedded_hello", initembedded_hello) == -1)
throw std::runtime_error("Failed to add embedded_hello to the interpreter's "
"builtin modules");
// Retrieve the main module
python::object main = python::import("__main__");
// Retrieve the main module's namespace
python::object global(main.attr("__dict__"));
// Define the derived class in Python.
python::object result = python::exec(
"from embedded_hello import * \n"
"class PythonDerived(Base): \n"
" def hello(self): \n"
" return 'Hello from Python!' \n",
global, global);
python::object PythonDerived = global["PythonDerived"];
// Creating and using instances of the C++ class is as easy as always.
CppDerived cpp;
std::cout << cpp.hello() << std::endl;
// But now creating and using instances of the Python class is almost
// as easy!
python::object py_base = PythonDerived();
Base& py = python::extract<Base&>(py_base) BOOST_EXTRACT_WORKAROUND;
std::cout << py.hello() << std::endl;
}
// void exec_file_test(std::string const &script)
void exec_file_test()
{
python::object main = python::import("__main__");
python::dict global(main.attr("__dict__"));
global.clear();
python::object result = python::exec_file(script.c_str(), global, global);
std::string global_as_string = python::extract<std::string>(python::str(global))
BOOST_EXTRACT_WORKAROUND;
std::cout << global_as_string << std::endl;
}
void exec_test_error()
{
python::object main = python::import("__main__");
python::dict global(main.attr("__dict__"));
python::object result = python::exec("print unknown \n", global, global);
}
int main(int argc, char **argv)
{
assert(argc == 2);
script = argv[1];
bool success = true;
// Initialize the interpreter
Py_Initialize();
if (python::handle_exception(exec_test) ||
python::handle_exception(exec_file_test))
{
if (PyErr_Occurred()) PyErr_Print();
else
{
std::cerr << "A C++ exception was thrown for which "
<< "there was no exception handler registered." << std::endl;
}
success = false;
}
if (python::handle_exception(exec_test_error))
{
if (PyErr_Occurred()) PyErr_Print();
else
{
std::cerr << "A C++ exception was thrown for which "
<< "there was no exception handler registered." << std::endl;
success = false;
}
}
else success = false;
// Boost.Python doesn't support Py_Finalize yet.
// Py_Finalize();
return success ? 0 : 1;
}
// Including this file makes sure
// that on Windows, any crashes (e.g. null pointer dereferences) invoke
// the debugger immediately, rather than being translated into structured
// exceptions that can interfere with debugging.
#include "module_tail.cpp"