int execute_python_entrypoint(int argc, char **argv, const char *basename, const char *module, const char *function,
char *outr, char *errr) {
PyObject *site, *pmain, *res;
int ret = 0;
initialize_interpreter(argc, argv, outr, errr, basename, module, function);
site = PyImport_ImportModule("site");
if (site == NULL)
ret = report_python_error("Failed to import site module", 1);
else {
Py_XINCREF(site);
pmain = PyObject_GetAttrString(site, "main");
if (pmain == NULL || !PyCallable_Check(pmain))
ret = report_python_error("site module has no main function", 1);
else {
Py_XINCREF(pmain);
res = PyObject_CallObject(pmain, NULL);
if (res == NULL)
ret = report_python_error("Python function terminated unexpectedly", 1);
ret = pyobject_to_int(res);
}
}
PyErr_Clear();
Py_Finalize();
//printf("11111 Returning: %d\r\n", ret);
return ret;
}
int
main(int argc, const char *argv[])
{
int stacktop;
const char *sourcefile;
const char *execname;
Interp *interp;
int status;
int pir_argc;
const char **pir_argv;
Parrot_Run_core_t core = PARROT_SLOW_CORE;
Parrot_trace_flags trace = PARROT_NO_TRACE;
/* internationalization setup */
/* setlocale(LC_ALL, ""); */
PARROT_BINDTEXTDOMAIN(PACKAGE, LOCALEDIR);
PARROT_TEXTDOMAIN(PACKAGE);
Parrot_set_config_hash();
interp = allocate_interpreter(NULL, PARROT_NO_FLAGS);
/* We parse the arguments, but first store away the name of the Parrot
executable, since parsing destroys that and we want to make it
available. */
execname = argv[0];
/* Parse minimal subset of flags */
parseflags_minimal(interp, argc, argv);
/* Now initialize interpreter */
initialize_interpreter(interp, (void*)&stacktop);
/* Parse flags */
sourcefile = parseflags(interp, argc, argv, &pir_argc, &pir_argv, &core, &trace);
Parrot_set_trace(interp, trace);
Parrot_set_run_core(interp, (Parrot_Run_core_t) core);
Parrot_set_executable_name(interp, Parrot_str_new(interp, execname, 0));
status = imcc_run(interp, sourcefile, argc, argv);
if (status)
imcc_run_pbc(interp, interp->output_file, pir_argc, pir_argv);
/* Clean-up after ourselves */
Parrot_destroy(interp);
Parrot_exit(interp, 0);
}
Interpreter::Interpreter(int argc, const char* argv[]) : raw_interp(initialize_interpreter(argc, argv), destructor) {
eval(implementation::to_eval);
}
Interpreter::Interpreter() : raw_interp(initialize_interpreter(), destructor) {
eval(implementation::to_eval);
}
EXPORT
int
run(const char **ENV_VARS, const char **ENV_VAR_VALS, char *PROGRAM,
const char *MODULE, const char *FUNCTION, const char *PYVER,
int IS_GUI, int argc, const char **argv, const char **envp) {
char *pathPtr = NULL, *t = NULL;
char buf[3*PATH_MAX];
int ret = 0, i;
PyObject *site, *mainf, *res;
uint32_t buf_size = PATH_MAX+1;
char *ebuf = calloc(buf_size, sizeof(char));
ret = _NSGetExecutablePath(ebuf, &buf_size);
if (ret == -1) {
free(ebuf);
ebuf = calloc(buf_size, sizeof(char));
if (_NSGetExecutablePath(ebuf, &buf_size) != 0)
return report_error("Failed to find real path of executable.");
}
pathPtr = realpath(ebuf, buf);
if (pathPtr == NULL) {
return report_error(strerror(errno));
}
for (i = 0; i < 3; i++) {
t = rindex(pathPtr, '/');
if (t == NULL) return report_error("Failed to determine bundle path.");
*t = '\0';
}
if (strstr(pathPtr, "/calibre.app/Contents/") != NULL) {
// We are one of the duplicate executables created to workaround codesign's limitations
for (i = 0; i < 2; i++) {
t = rindex(pathPtr, '/');
if (t == NULL) return report_error("Failed to resolve bundle path in dummy executable");
*t = '\0';
}
}
char rpath[PATH_MAX+1], exe_path[PATH_MAX+1];
snprintf(exe_path, PATH_MAX+1, "%s/Contents", pathPtr);
snprintf(rpath, PATH_MAX+1, "%s/Resources", exe_path);
initialize_interpreter(ENV_VARS, ENV_VAR_VALS, PROGRAM, MODULE, FUNCTION, PYVER, IS_GUI,
exe_path, rpath, argc, argv);
site = PyImport_ImportModule("site");
if (site == NULL)
ret = calibre_show_python_error("Failed to import site module", -1);
else {
Py_XINCREF(site);
mainf = PyObject_GetAttrString(site, "main");
if (mainf == NULL || !PyCallable_Check(mainf))
ret = calibre_show_python_error("site module has no main function", -1);
else {
Py_XINCREF(mainf);
res = PyObject_CallObject(mainf, NULL);
if (res == NULL)
ret = calibre_show_python_error("Python function terminated unexpectedly", -1);
else {
}
}
}
PyErr_Clear();
Py_Finalize();
//printf("11111 Returning: %d\r\n", ret);
return ret;
}
