Example #1
0
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)
Example #2
0
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)
Example #3
0
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)
Example #4
0
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)
Example #5
0
        DWORD	AddressOfNameOrdinals;
    } IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY;
    
    DWORD                   pRVABase;
    IMAGE_EXPORT_DIRECTORY* pExportDirectory;
    
    void* PointerFromAddress(DWORD Address);    
    DWORD AddressFromPointer(void* Pointer);          
''')

ffi.embedding_api('''      
    extern "Python" int __stdcall xlAutoOpen(void);
    extern "Python" int __stdcall xlAutoClose(void);
    extern "Python" int __stdcall xlAutoAdd(void);
    extern "Python" int __stdcall xlAutoRemove(void);
    
    extern "Python" void __stdcall xlAutoFree12(LPXLOPER12);
    
    extern "Python" LPXLOPER12 __stdcall _xlfCaller();
    extern "Python" LPXLOPER12 __stdcall py_eval(const char* expression);             
''')

ffi.set_source("_python_xll",
               r"""
#include <assert.h>
#include <WINDOWS.H>
#include <XLCALL.H>

#pragma comment(linker, "/export:xlAutoOpen=_xlAutoOpen@0")
#pragma comment(linker, "/export:xlAutoClose=_xlAutoClose@0")
#pragma comment(linker, "/export:xlAutoAdd=_xlAutoAdd@0")
Example #6
0
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()
Example #8
0
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))
Example #9
0
from cffi import FFI
from pathlib import Path

sdk_dir = (Path(__file__).parent / '..' / '..' / 'Excel2013XLLSDK' ).resolve()


ffi = FFI()

# note need cffi 1.5.1 in order to support __stdcall
ffi.embedding_api('''
    extern int __stdcall xlAutoOpen(void);
    extern int __stdcall xlAutoClose(void);
'''
)

# office 2016 seems to break AttachConsole/AllocConsole. Nasty
# works in office 2013.
# but how do we pick up the right virtualenv?
# if we are in develop mode it's a problem: need to find the base of the tree for PYTHONPATH?
# need to find the location of python.dll, and insall the right virtualenv PATH around it
# not sure that the embedded install does that? or are we just picking upt he wrong one.

# VIRTUAL_ENV can specify where, if not we use the

ffi.set_source('test_xll',
'''
#include <WINDOWS.H>
#include <XLCALL.H>

#include <stdio.h>
Example #10
0
     push _callback_types[{i}]
     push _callback_codes[{i}]
     
     // invoke the callback
     call _callback_funcs[{i}]      
                    
     // restore stack pointers stored in the pre-amble by msvc 
     mov	 esp, ebp
     pop	 ebp
     
     // get original return location from the stack
     pop ecx
     
     // remove all the arguments, according to the size calculated
     add esp, _callback_sizes[{i}]
     
     // jmp to the  location, no need to RET
     jmp ecx         
  }}
}}      
""" for i in range(0, MAX_CALLBACKS)),
    include_dirs=['src']
)

# for some reason we need this to trigger windows.h...
ffi.embedding_api('')

if __name__ == '__main__':
    ffi.compile(target='xlcall.pyd')

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()
Example #12
0
ffi.set_source(
    '_xll',
    f"""     
   #include <XLCALLDEF.h> 
   """,
    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
''')