def main(defs_file, parser_file, verbose):
ffi = FFI()
with open(defs_file) as f:
ffi.embedding_api(f.read())
ffi.set_source('parser_interface', '#include "%s"' % defs_file)
with open(parser_file) as f:
ffi.embedding_init_code(f.read())
interpreter, _, _ = os.path.basename(sys.executable).partition('.')
ffi.compile(target='libplease_parser_%s.*' % interpreter, verbose=verbose)
def main(defs_file, parser_file, verbose):
ffi = FFI()
with open(defs_file) as f:
ffi.embedding_api(f.read())
ffi.set_source('parser_interface', '#include "%s"' % defs_file)
with open(parser_file) as f:
ffi.embedding_init_code(f.read())
interpreter, _, _ = os.path.basename(sys.executable).partition('.')
ffi.compile(target='libplease_parser_%s.*' % interpreter, verbose=verbose)
def main(defs_file, parser_file, verbose):
ffi = FFI()
with open(defs_file) as f:
ffi.embedding_api(f.read())
ldflags = None
if platform.python_implementation() == 'CPython' and platform.system(
) == 'Darwin':
ldflags = ['-L' + os.path.join(sys.prefix, 'lib')]
ffi.set_source('parser_interface',
'#include "%s"' % defs_file,
extra_link_args=ldflags)
with open(parser_file) as f:
ffi.embedding_init_code(f.read())
interpreter, _, _ = os.path.basename(sys.executable).partition('.')
ffi.compile(target='libplease_parser_%s.*' % interpreter, verbose=verbose)
def main(defs_file, parser_file, verbose):
ffi = FFI()
with open(defs_file) as f:
ffi.embedding_api(f.read())
ldflags = None
# Support downloading portable PyPy on Linux.
if platform.python_implementation() == 'PyPy' and platform.system(
) == 'Linux':
ldflags = ['-Wl,-rpath=./plz-out/gen/_remote/_pypy/bin']
ffi.set_source('parser_interface',
'#include "%s"' % defs_file,
extra_link_args=ldflags)
with open(parser_file) as f:
ffi.embedding_init_code(f.read())
interpreter, _, _ = os.path.basename(sys.executable).partition('.')
ffi.compile(target='libplease_parser_%s.*' % interpreter, verbose=verbose)
""" + '\n'.join(f"E({d:03X})" for d in range(0, 0xFFF)),
include_dirs=[build_xlcall.src_dir])
ffi.embedding_init_code(r"""
import sys
import os.path
from xll.output import OutputDebugStringWriter
# send all output to the debugging console
sys.stderr = sys.stdout = OutputDebugStringWriter()
# if we have a PYDEVD port set, then attach to the debugger
if 'PYDEVD_PORT' in os.environ:
import pydevd
pydevd.settrace(
host=os.getenv('PYDEVD_HOST', 'localhost'),
port=int(os.getenv('PYDEVD_PORT')),
suspend=False,
stdoutToServer=True,
stderrToServer=True
)
# defer to the python module
import xll.auto
""")
if __name__ == '__main__':
ffi.compile(target=os.path.join(os.path.dirname(__file__), 'python.xll'))
def generate_c(action):
clingo_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
ffi = FFI()
cnt = []
with open(f'{clingo_dir}/libclingo/clingo.h') as f:
for line in f:
if not re.match(r' *(#|//|extern *"C" *{|}$|$)', line):
cnt.append(
line.replace('CLINGO_VISIBILITY_DEFAULT ', '').strip())
# callbacks
cnt.append(
'extern "Python" bool pyclingo_solve_event_callback(clingo_solve_event_type_t type, void *event, void *data, bool *goon);'
)
cnt.append(
'extern "Python" void pyclingo_logger_callback(clingo_warning_t code, char const *message, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_ground_callback(clingo_location_t const *location, char const *name, clingo_symbol_t const *arguments, size_t arguments_size, void *data, clingo_symbol_callback_t symbol_callback, void *symbol_callback_data);'
)
# propagator callbacks
cnt.append(
'extern "Python" bool pyclingo_propagator_init(clingo_propagate_init_t *init, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_propagator_propagate(clingo_propagate_control_t *control, clingo_literal_t const *changes, size_t size, void *data);'
)
cnt.append(
'extern "Python" void pyclingo_propagator_undo(clingo_propagate_control_t const *control, clingo_literal_t const *changes, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_propagator_check(clingo_propagate_control_t *control, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_propagator_decide(clingo_id_t thread_id, clingo_assignment_t const *assignment, clingo_literal_t fallback, void *data, clingo_literal_t *decision);'
)
# observer callbacks
cnt.append(
'extern "Python" bool pyclingo_observer_init_program(bool incremental, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_begin_step(void *data);')
cnt.append('extern "Python" bool pyclingo_observer_end_step(void *data);')
cnt.append(
'extern "Python" bool pyclingo_observer_rule(bool choice, clingo_atom_t const *head, size_t head_size, clingo_literal_t const *body, size_t body_size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_weight_rule(bool choice, clingo_atom_t const *head, size_t head_size, clingo_weight_t lower_bound, clingo_weighted_literal_t const *body, size_t body_size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_minimize(clingo_weight_t priority, clingo_weighted_literal_t const* literals, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_project(clingo_atom_t const *atoms, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_output_atom(clingo_symbol_t symbol, clingo_atom_t atom, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_output_term(clingo_symbol_t symbol, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_output_csp(clingo_symbol_t symbol, int value, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_external(clingo_atom_t atom, clingo_external_type_t type, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_assume(clingo_literal_t const *literals, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_heuristic(clingo_atom_t atom, clingo_heuristic_type_t type, int bias, unsigned priority, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_acyc_edge(int node_u, int node_v, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_term_number(clingo_id_t term_id, int number, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_term_string(clingo_id_t term_id, char const *name, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_term_compound(clingo_id_t term_id, int name_id_or_type, clingo_id_t const *arguments, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_element(clingo_id_t element_id, clingo_id_t const *terms, size_t terms_size, clingo_literal_t const *condition, size_t condition_size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_atom(clingo_id_t atom_id_or_zero, clingo_id_t term_id, clingo_id_t const *elements, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_atom_with_guard(clingo_id_t atom_id_or_zero, clingo_id_t term_id, clingo_id_t const *elements, size_t size, clingo_id_t operator_id, clingo_id_t right_hand_side_id, void *data);'
)
# application callbacks
cnt.append(
'extern "Python" char const *pyclingo_application_program_name(void *data);'
)
cnt.append(
'extern "Python" char const *pyclingo_application_version(void *data);'
)
cnt.append(
'extern "Python" unsigned pyclingo_application_message_limit(void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_main(clingo_control_t *control, char const *const * files, size_t size, void *data);'
)
cnt.append(
'extern "Python" void pyclingo_application_logger(clingo_warning_t code, char const *message, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_print_model(clingo_model_t const *model, clingo_default_model_printer_t printer, void *printer_data, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_register_options(clingo_options_t *options, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_validate_options(void *data);'
)
# application options callbacks
cnt.append(
'extern "Python" bool pyclingo_application_options_parse(char const *value, void *data);'
)
# ast callbacks
cnt.append(
'extern "Python" bool pyclingo_ast_callback(clingo_ast_t const *, void *);'
)
if action == "embed":
ffi.embedding_api('''\
bool pyclingo_execute_(void *loc, char const *code, void *data);
bool pyclingo_call_(void *loc, char const *name, void *arguments, size_t size, void *symbol_callback, void *symbol_callback_data, void *data);
bool pyclingo_callable_(char const * name, bool *ret, void *data);
bool pyclingo_main_(void *ctl, void *data);
''')
ffi.embedding_init_code(f"""\
from collections.abc import Iterable
from traceback import format_exception
import __main__
from clingo._internal import _ffi, _handle_error, _lib
from clingo.control import Control
from clingo.symbol import Symbol
def _cb_error_top_level(exception, exc_value, traceback):
msg = "".join(format_exception(exception, exc_value, traceback))
_lib.clingo_set_error(_lib.clingo_error_runtime, msg.encode())
return False
@_ffi.def_extern(onerror=_cb_error_top_level)
def pyclingo_execute_(loc, code, data):
exec(_ffi.string(code).decode(), __main__.__dict__, __main__.__dict__)
return True
@_ffi.def_extern(onerror=_cb_error_top_level)
def pyclingo_call_(loc, name, arguments, size, symbol_callback, symbol_callback_data, data):
symbol_callback = _ffi.cast('clingo_symbol_callback_t', symbol_callback)
arguments = _ffi.cast('clingo_symbol_t*', arguments)
context = _ffi.from_handle(data).data if data != _ffi.NULL else None
py_name = _ffi.string(name).decode()
fun = getattr(__main__ if context is None else context, py_name)
args = []
for i in range(size):
args.append(Symbol(arguments[i]))
ret = fun(*args)
symbols = list(ret) if isinstance(ret, Iterable) else [ret]
c_symbols = _ffi.new('clingo_symbol_t[]', len(symbols))
for i, sym in enumerate(symbols):
c_symbols[i] = sym._rep
_handle_error(symbol_callback(c_symbols, len(symbols), symbol_callback_data))
return True
@_ffi.def_extern(onerror=_cb_error_top_level)
def pyclingo_callable_(name, ret, data):
py_name = _ffi.string(name).decode()
ret[0] = py_name in __main__.__dict__ and callable(__main__.__dict__[py_name])
return True
@_ffi.def_extern(onerror=_cb_error_top_level)
def pyclingo_main_(ctl, data):
__main__.main(Control(_ffi.cast('clingo_control_t*', ctl)))
return True
""")
if action != "header":
ffi.set_source('_clingo', '#include <clingo.h>')
ffi.cdef('\n'.join(cnt))
ffi.emit_c_code('_clingo.c')
else:
with open('_clingo.cdef', 'w') as f:
f.write(''.join(f'{line}\n' for line in cnt))
from cffi import FFI
ffi = FFI()
ffi.embedding_api("""
int factorial(int n);
""")
ffi.embedding_init_code("""
from liv2 import ffi
@ffi.def_extern()
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
""")
ffi.set_source("liv2", "")
ffi.compile()
def generate_c(action):
clingo_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
ffi = FFI()
cnt = []
with open(f'{clingo_dir}/libclingo/clingo.h') as f:
for line in f:
if not re.match(r' *(#|//|extern *"C" *{|}$|$)', line):
cnt.append(
line.replace('CLINGO_VISIBILITY_DEFAULT ', '').strip())
# callbacks
cnt.append(
'extern "Python" bool pyclingo_solve_event_callback(clingo_solve_event_type_t type, void *event, void *data, bool *goon);'
)
cnt.append(
'extern "Python" void pyclingo_logger_callback(clingo_warning_t code, char const *message, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_ground_callback(clingo_location_t const *location, char const *name, clingo_symbol_t const *arguments, size_t arguments_size, void *data, clingo_symbol_callback_t symbol_callback, void *symbol_callback_data);'
)
# propagator callbacks
cnt.append(
'extern "Python" bool pyclingo_propagator_init(clingo_propagate_init_t *init, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_propagator_propagate(clingo_propagate_control_t *control, clingo_literal_t const *changes, size_t size, void *data);'
)
cnt.append(
'extern "Python" void pyclingo_propagator_undo(clingo_propagate_control_t const *control, clingo_literal_t const *changes, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_propagator_check(clingo_propagate_control_t *control, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_propagator_decide(clingo_id_t thread_id, clingo_assignment_t const *assignment, clingo_literal_t fallback, void *data, clingo_literal_t *decision);'
)
# observer callbacks
cnt.append(
'extern "Python" bool pyclingo_observer_init_program(bool incremental, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_begin_step(void *data);')
cnt.append('extern "Python" bool pyclingo_observer_end_step(void *data);')
cnt.append(
'extern "Python" bool pyclingo_observer_rule(bool choice, clingo_atom_t const *head, size_t head_size, clingo_literal_t const *body, size_t body_size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_weight_rule(bool choice, clingo_atom_t const *head, size_t head_size, clingo_weight_t lower_bound, clingo_weighted_literal_t const *body, size_t body_size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_minimize(clingo_weight_t priority, clingo_weighted_literal_t const* literals, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_project(clingo_atom_t const *atoms, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_output_atom(clingo_symbol_t symbol, clingo_atom_t atom, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_output_term(clingo_symbol_t symbol, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_output_csp(clingo_symbol_t symbol, int value, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_external(clingo_atom_t atom, clingo_external_type_t type, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_assume(clingo_literal_t const *literals, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_heuristic(clingo_atom_t atom, clingo_heuristic_type_t type, int bias, unsigned priority, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_acyc_edge(int node_u, int node_v, clingo_literal_t const *condition, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_term_number(clingo_id_t term_id, int number, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_term_string(clingo_id_t term_id, char const *name, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_term_compound(clingo_id_t term_id, int name_id_or_type, clingo_id_t const *arguments, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_element(clingo_id_t element_id, clingo_id_t const *terms, size_t terms_size, clingo_literal_t const *condition, size_t condition_size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_atom(clingo_id_t atom_id_or_zero, clingo_id_t term_id, clingo_id_t const *elements, size_t size, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_observer_theory_atom_with_guard(clingo_id_t atom_id_or_zero, clingo_id_t term_id, clingo_id_t const *elements, size_t size, clingo_id_t operator_id, clingo_id_t right_hand_side_id, void *data);'
)
# application callbacks
cnt.append(
'extern "Python" char const *pyclingo_application_program_name(void *data);'
)
cnt.append(
'extern "Python" char const *pyclingo_application_version(void *data);'
)
cnt.append(
'extern "Python" unsigned pyclingo_application_message_limit(void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_main(clingo_control_t *control, char const *const * files, size_t size, void *data);'
)
cnt.append(
'extern "Python" void pyclingo_application_logger(clingo_warning_t code, char const *message, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_print_model(clingo_model_t const *model, clingo_default_model_printer_t printer, void *printer_data, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_register_options(clingo_options_t *options, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_application_validate_options(void *data);'
)
# application options callbacks
cnt.append(
'extern "Python" bool pyclingo_application_options_parse(char const *value, void *data);'
)
# ast callbacks
cnt.append(
'extern "Python" bool pyclingo_ast_callback(clingo_ast_t const *, void *);'
)
# script callbacks
cnt.append(
'extern "Python" bool pyclingo_script_execute(clingo_location_t *loc, char const *code, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_script_call(clingo_location_t *loc, char const *name, void *arguments, size_t size, void *symbol_callback, void *symbol_callback_data, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_script_callable(char const * name, bool *ret, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_script_main(clingo_control_t *ctl, void *data);'
)
code = ''
if action == "embed":
ffi.embedding_api('''\
bool pyclingo_execute(void *loc, char const *code, void *data);
bool pyclingo_call(void *loc, char const *name, void *arguments, size_t size, void *symbol_callback, void *symbol_callback_data, void *data);
bool pyclingo_callable(char const * name, bool *ret, void *data);
bool pyclingo_main(void *ctl, void *data);
''')
ffi.embedding_init_code(f"""\
import os
import sys
import clingo.script
sys.path.insert(0, os.getcwd())
""")
code = '''\
#ifdef CFFI_DLLEXPORT
#undef CFFI_DLLEXPORT
#define CFFI_DLLEXPORT
#endif
#ifdef PYPY_VERSION
void pyclingo_finalize() { }
#else
void pyclingo_finalize() {
if (Py_IsInitialized()) {
PyGILState_Ensure();
Py_Finalize();
}
}
#endif
'''
else:
cnt.append(
'extern "Python" bool pyclingo_execute(void *loc, char const *code, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_call(void *loc, char const *name, void *arguments, size_t size, void *symbol_callback, void *symbol_callback_data, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_callable(char const * name, bool *ret, void *data);'
)
cnt.append(
'extern "Python" bool pyclingo_main(void *ctl, void *data);')
if action != "header":
ffi.set_source('_clingo', f'''\
#include <clingo.h>
{code}
''')
ffi.cdef('\n'.join(cnt))
ffi.emit_c_code('_clingo.c')
else:
with open('_clingo.cdef', 'w') as f:
f.write(''.join(f'{line}\n' for line in cnt))
extra_link_args = ['/DEBUG']
)
ffi.embedding_init_code('''
from test_xll import ffi
from xlcall._xlcall import ffi as xlcall
xlcall = xlcall.dlopen('XLCALL32')
# we should look for the module we want to expose, and def_extern all of them here?
# then the xlAutoOpen implementation needs to loop over all the def_externs..
@ffi.def_extern(error=0)
def xlAutoOpen():
import os
for key, value in os.environ.items():
print('{key:<32s} {value}'.format(key=key, value=value))
import sys
print(sys.path)
print(sys.prefix)
print(sys.executable)
print('XlCallVer: {:d}'.format(xlcall.XLCallVer()))
return 1
@ffi.def_extern(error=0)
def xlAutoClose():
return 1
''')
if __name__ == '__main__':
from cffi import FFI
includes = open('./Py_code/liv.h').read()
source = open('./Py_code/liv.py').read()
ffi = FFI()
ffi.embedding_api(includes)
ffi.set_source('liv4', includes)
ffi.embedding_init_code(source)
ffi.compile()
assert(pNtHeaders32->Signature == 0x4550);
assert(pNtHeaders32->OptionalHeader.DataDirectory[0].VirtualAddress != 0);
assert(pNtHeaders32->OptionalHeader.DataDirectory[0].Size != 0);
pExportDirectory =
(IMAGE_EXPORT_DIRECTORY*)
(pNtHeaders32->OptionalHeader.DataDirectory[0].VirtualAddress + pRVABase);
_cffi_initialize_python();
return TRUE;
}
""")
ffi.embedding_init_code(open("scratch-init.py", "r").read())
ffi.compile(target="scratch.dll", verbose=True)
def test_it():
ffi = FFI()
ffi.cdef("""
int _0(int, int);
""")
api = ffi.dlopen('scratch.dll')
# why no api call here?
print(api._0(1, 10))
""",
include_dirs=['src'],
extra_link_args=['/DEF:_xll.def'],
#extra_compile_args=['/FAc'],
sources=['src/DllMain.cpp'],
)
ffi.embedding_api('''
extern "Python" int __stdcall xlAutoOpen(void);
extern "Python" int __stdcall xlAutoClose(void);
extern "Python" void __stdcall xlAutoFree12(LPXLOPER12);
extern "Python" int __stdcall xlAutoAdd(void);
extern "Python" int __stdcall xlAutoRemove(void);
extern "Python" double __stdcall TheNumberOneInPy();
extern "Python" LPXLOPER12 __stdcall test_c_string(wchar_t*);
extern "Python" LPXLOPER12 __stdcall os_environ(LPXLOPER12);
''')
ffi.embedding_init_code('''
import sys
try:
import xll.addin
except:
sys.excepthook(*sys.exc_info())
raise
''')
if __name__ == '__main__':
ffi.compile(target='python.xll')
