int main(void) {
scheme *sc;
// Init Scheme interpreter
sc = scheme_init_new();
scheme_set_output_port_file(sc, stdout);
// Load init.scm
FILE *finit = fopen("../tinyscheme/init.scm", "r");
scheme_load_file(sc, finit);
fclose(finit);
SDECL("machine-create",sc_machine_create);
SDECL("machine-peek",sc_machine_peek);
SDECL("machine-poke",sc_machine_poke);
SDECL("machine-run",sc_machine_run);
SDECL("machine-say",sc_machine_say);
SDECL("machine-start",sc_machine_start);
SDECL("machine-say-addr",sc_machine_say_addr);
SDECL("machine-say-size",sc_machine_say_size);
FILE *fus = fopen("reactor.scm", "r");
scheme_load_file(sc, fus);
fclose(fus);
// Bye!
scheme_deinit(sc);
return 0;
}
scheme *edelib_scheme_init(void) {
scheme *s;
pointer sym;
s = scheme_init_new();
scheme_set_input_port_file(s, stdin);
scheme_set_output_port_file(s, stdout);
sym = edelib_scheme_mk_symbol(s, "*edelib-dir-separator*");
edelib_scheme_define(s, EDELIB_SCHEME_GLOBAL_ENV(s), sym, edelib_scheme_mk_string(s, E_DIR_SEPARATOR_STR));
sym = edelib_scheme_mk_symbol(s, "*edelib-version*");
edelib_scheme_define(s, EDELIB_SCHEME_GLOBAL_ENV(s), sym, edelib_scheme_mk_string(s, EDELIB_VERSION));
EDELIB_SCHEME_DEFINE(s, edelib_scheme_clock, "edelib-clock");
EDELIB_SCHEME_DEFINE(s, edelib_scheme_clock_diff, "edelib-clock-diff");
/* load init files; it is a list of files separated with ':' */
char *paths = getenv("EDELIB_SCHEME_INIT");
if(paths) {
char *tmp = edelib_strndup(paths, 256);
FILE *fd = NULL;
for(char *p = strtok(tmp, ":"); p; p = strtok(NULL, ":")) {
fd = fopen(p, "r");
if(!fd) {
E_WARNING(E_STRLOC ": unable to open '%s'. Skipping...\n", p);
continue;
}
edelib_scheme_load_file(s, fd);
fclose(fd);
fd = NULL;
}
free(tmp);
} else {
FILE *fd;
char path[PATH_MAX];
const char *init_files[] = {"init.ss", "init-2.ss", 0};
bool found_files = false;
for(int i = 0; init_files[i]; i++) {
snprintf(path, sizeof(path), "%s/%s", EDELIB_SCHEME_DEFAULT_LIB_PATH, init_files[i]);
fd = fopen(path, "r");
if(fd) {
found_files = true;
edelib_scheme_load_file(s, fd);
fclose(fd);
}
}
if(!found_files)
E_WARNING(E_STRLOC ": EDELIB_SCHEME_INIT wasn't set. Interpreter will be loaded without init files\n");
}
return s;
}
void Theme::init_interpreter(void) {
if(priv->sc) return;
scheme *ss = edelib_scheme_init_raw();
if(!ss) {
E_WARNING(E_STRLOC ": Unable to init interpreter\n");
return;
}
priv->sc = ss;
/* must be called */
scheme_set_input_port_file(ss, stdin);
scheme_set_output_port_file(ss, stdout);
/* install user supplied error handler first, if given */
if(priv->err_func) {
ss->vptr->scheme_define(ss,
ss->global_env,
ss->vptr->mk_symbol(ss, "private:theme.error_hook"),
ss->vptr->mk_foreign_func(ss, theme_error_hook));
/* make sure interpreter does not use this function at all */
scheme_set_external_data(ss, (void*)priv);
}
/* load init stuff */
scheme_load_string(ss, init_ss_content);
/* load theme stuff */
scheme_load_string(ss, theme_ss_content);
/*
* Set (or override) common variables before actual script was loaded.
* Variables are static and can't be changed.
*/
pointer sym;
sym = mk_symbol(ss, "*edelib-dir-separator*");
scheme_define(ss, ss->global_env, sym, mk_string(ss, E_DIR_SEPARATOR_STR));
ss->vptr->setimmutable(sym);
sym = mk_symbol(ss, "*edelib-version*");
scheme_define(ss, ss->global_env, sym, mk_string(ss, EDELIB_VERSION));
ss->vptr->setimmutable(sym);
}
int main(int argc, char *argv[])
{
void *sc;
sc = malloc(1024 * 1024 * 4);
void *h = dlopen("/usr/lib/libsandbox.dylib", RTLD_LAZY);
printf("h = %p\n", h);
void *loaded_base = dlsym(h, "sandbox_compile_file");
printf("sandbox_compile_file = %p\n", loaded_base);
unsigned int static_base = get_offset("_sandbox_compile_file");
base = (unsigned int) loaded_base - static_base;
int (*scheme_init)(void *) =
(int (*)(void *)) hidden_dlsym("_scheme_init");
void (*scheme_set_input_port_file)(void *, FILE *) =
(void (*)(void *, FILE *)) hidden_dlsym("_scheme_set_input_port_file");
void (*scheme_set_output_port_file)(void *, FILE *) =
(void (*)(void *, FILE *)) hidden_dlsym("_scheme_set_output_port_file");
void (*scheme_load_file)(void *, FILE *) =
(void (*)(void *, FILE *)) hidden_dlsym("_scheme_load_file");
void (*scheme_deinit)(void *) =
(void (*)(void *)) hidden_dlsym("_scheme_deinit");
if (!scheme_init(sc)) {
fprintf(stderr, "Uh ohz!\n");
} else {
scheme_set_input_port_file(sc, stdin);
scheme_set_output_port_file(sc, stdout);
scheme_load_file(sc, stdin);
scheme_deinit(sc);
}
dlclose(h);
free(sc);
return 0;
}
ShellService::ShellService()
: d(new Impl)
{
if (d->m_Scheme == nullptr)
{
throw std::runtime_error("Could not initialize Scheme interpreter");
}
scheme_set_output_port_file(d->m_Scheme, stdout);
BundleResource schemeInitRes = GetBundleContext().GetBundle().GetResource("tinyscheme/init.scm");
if (schemeInitRes)
{
this->LoadSchemeResource(schemeInitRes);
}
else
{
std::cerr << "Scheme file init.scm not found";
}
std::vector<BundleResource> schemeResources = GetBundleContext().GetBundle().FindResources("/", "*.scm", false);
for (std::vector<BundleResource>::iterator iter = schemeResources.begin(),
iterEnd = schemeResources.end(); iter != iterEnd; ++iter)
{
if (*iter)
{
this->LoadSchemeResource(*iter);
}
}
scheme_define(d->m_Scheme, d->m_Scheme->global_env, mk_symbol(d->m_Scheme, "us-bundle-ids"), mk_foreign_func(d->m_Scheme, us_bundle_ids));
scheme_define(d->m_Scheme, d->m_Scheme->global_env, mk_symbol(d->m_Scheme, "us-bundle-info"), mk_foreign_func(d->m_Scheme, us_bundle_info));
scheme_define(d->m_Scheme, d->m_Scheme->global_env, mk_symbol(d->m_Scheme, "us-display-bundle-info"), mk_foreign_func(d->m_Scheme, us_display_bundle_info));
scheme_define(d->m_Scheme, d->m_Scheme->global_env, mk_symbol(d->m_Scheme, "us-bundle-start"), mk_foreign_func(d->m_Scheme, us_bundle_start));
scheme_define(d->m_Scheme, d->m_Scheme->global_env, mk_symbol(d->m_Scheme, "us-bundle-stop"), mk_foreign_func(d->m_Scheme, us_bundle_stop));
scheme_define(d->m_Scheme, d->m_Scheme->global_env, mk_symbol(d->m_Scheme, "us-install"), mk_foreign_func(d->m_Scheme, us_install));
}
int main(int argc, char **argv) {
FILE *fin = NULL;
const char *expr = NULL;
scheme sc;
if(argc > 1) {
if(argv[1][0] == '-') {
if((strcmp(argv[1], "--help") == 0) || (strcmp(argv[1], "-h") == 0)) {
help();
return 0;
} else if((strcmp(argv[1], "--expression") == 0) || (strcmp(argv[1], "-e") == 0)) {
if(!argv[2]) {
printf("This option requires a parameter\n");
return 1;
}
expr = argv[2];
} else {
printf("Unrecognized option. Use 'ede-scriptbus --help' for options\n");
return 1;
}
}
if(!expr) {
fin = fopen(argv[1], "r");
if(!fin) {
fprintf(stderr, "Unable to load '%s' file!\n", argv[1]);
return 1;
}
}
}
if(!scheme_init(&sc)) {
fprintf(stderr, "Fatal: Unable to initialize interpreter!\n");
return 1;
}
scheme_set_input_port_file(&sc, stdin);
scheme_set_output_port_file(&sc, stdout);
/* load basic stuff */
scheme_load_string(&sc, init_scm_content);
/* register additional functions */
register_sys_functions(&sc);
register_communication_functions(&sc);
register_string_functions(&sc);
register_wm_functions(&sc);
/* construct *args* */
pointer args = sc.NIL;
for(int i = 0; i < argc; i++) {
pointer value = mk_string(&sc, argv[i]);
args = cons(&sc, value, args);
}
args = scheme_reverse(&sc, args);
scheme_define(&sc, sc.global_env, mk_symbol(&sc, "*args*"), args);
if(!expr) {
/* load file or go into console */
if(!fin) {
fin = stdin;
printf("Type '(quit)' or press Ctrl-D to quit");
}
scheme_load_file(&sc, fin);
} else {
/* or execute expression */
scheme_load_string(&sc, expr);
if(sc.retcode != 0)
printf("Bad expression: '%s'\n", expr);
}
scheme_deinit(&sc);
return 0;
}
int main(int argc, char **argv)
{
scheme sc;
FILE *fin;
char *file_name = INITFILE;
int isfile = 1;
if (argc == 1) {
printf(BANNER);
}
if (argc == 2 && strcmp(argv[1], "-?") == 0) {
usage();
return 1;
}
if (!scheme_init(&sc)) {
fprintf(stderr, "Could not initialize!\n");
return 2;
}
scheme_set_input_port_file(&sc, stdin);
scheme_set_output_port_file(&sc, stdout);
#if USE_DL
scheme_define(&sc, sc.global_env,
mk_symbol(&sc, "load-extension"),
mk_foreign_func(&sc, scm_load_ext));
#endif
argv++;
if (access(file_name, 0) != 0) {
char *p = getenv("TINYSCHEMEINIT");
if (p != 0) {
file_name = p;
}
}
do {
if (strcmp(file_name, "-") == 0) {
fin = stdin;
} else if (strcmp(file_name, "-1") == 0 ||
strcmp(file_name, "-c") == 0) {
pointer args = sc.NIL;
isfile = file_name[1] == '1';
file_name = *argv++;
if (strcmp(file_name, "-") == 0) {
fin = stdin;
} else if (isfile) {
fin = fopen(file_name, "r");
}
for (; *argv; argv++) {
pointer value = mk_string(&sc, *argv);
args = cons(&sc, value, args);
}
args = reverse_in_place(&sc, sc.NIL, args);
scheme_define(&sc, sc.global_env,
mk_symbol(&sc, "*args*"), args);
} else {
fin = fopen(file_name, "r");
}
if (isfile && fin == 0) {
fprintf(stderr, "Could not open file %s\n", file_name);
} else {
if (isfile) {
scheme_load_named_file(&sc, fin, file_name);
} else {
scheme_load_string(&sc, file_name);
}
if (!isfile || fin != stdin) {
if (sc.retcode != 0) {
fprintf(stderr, "Errors encountered reading %s\n", file_name);
}
if (isfile) {
fclose(fin);
}
}
}
file_name = *argv++;
} while (file_name != 0);
if (argc == 1) {
scheme_load_named_file(&sc, stdin, 0);
}
scheme_deinit(&sc);
return sc.retcode;
}
