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; }