/*
* get_qstring: removes the quotes from a quoted string, allocates
* space for the resulting string.
*
* Returns:
* a pointer to the new string
*/
static char *get_qstring(char *qstring, int len)
{
/* replace ending quote with \0 */
qstring[len - 1] = '\0';
/* copy everything following beginning quote */
return mk_string(qstring + 1, len - 2);
}
format * mk_unsigned(ast_manager & m, unsigned u) {
static char buffer[128];
#ifdef _WINDOWS
sprintf_s(buffer, ARRAYSIZE(buffer), "%u", u);
#else
sprintf(buffer, "%u", u);
#endif
return mk_string(m, buffer);
}
format * mk_int(ast_manager & m, int i) {
static char buffer[128];
#ifdef _WINDOWS
sprintf_s(buffer, ARRAYSIZE(buffer), "%d", i);
#else
sprintf(buffer, "%d", i);
#endif
return mk_string(m, buffer);
}
bool Theme::load(const char *f) {
E_RETURN_VAL_IF_FAIL(f != NULL, false);
/* do not allow loading if clear() wasn't called before */
E_RETURN_VAL_IF_FAIL(priv->sc == NULL, false);
priv->is_loaded = false;
init_interpreter();
scheme *ss = priv->sc;
/*
* Determine from which directory we loads file, and set that file as base directory
* where '(include)' statement can search additional files. Include uses 'private::theme.search-path'.
*/
char *path = edelib_strndup(f, PATH_MAX);
if(!path)
E_FATAL(E_STRLOC ": No memory\n");
char *dir = local_dirname(path);
/* If returned name is the same as file, dirname wasn't found directory name in given path. */
if(strcmp(dir, f) != 0) {
pointer sym = mk_symbol(ss, "private:theme.search-path");
edelib_scheme_define(ss, ss->global_env, sym, mk_string(ss, dir));
ss->vptr->setimmutable(sym);
}
/* scheme copies path, so we do not need it any more */
free(path);
FILE *fd = fopen(f, "r");
if(!fd) {
edelib_scheme_deinit(ss);
free(ss);
priv->sc = 0;
return false;
}
edelib_scheme_load_named_file(ss, fd, f);
fclose(fd);
if(ss->no_memory) {
E_WARNING(E_STRLOC ": No memory to load theme source in interpreter\n");
return false;
}
if(ss->retcode != 0)
return false;
/* fetch common variables */
priv->name = get_string_var(ss, "private:theme.name");
priv->author = get_string_var(ss, "private:theme.author");
priv->sample = get_string_var(ss, "private:theme.sample");
priv->is_loaded = true;
return true;
}
/*
* (getenv <what>) => <string>
* returns environment value for <what>; if <what> is not given, returns a list of all environment key/value pairs
*/
static pointer s_getenv(scheme* sc, pointer arg) {
if(arg == sc->NIL) {
char** env = environ;
pointer lst = sc->NIL;
while(*env) {
lst = cons(sc, mk_string(sc, *env), lst);
env++;
}
return scheme_reverse(sc, lst);
}
pointer a = sc->vptr->pair_car(arg);
if(a != sc->NIL && sc->vptr->is_string(a)) {
const char* val;
if((val = getenv(sc->vptr->string_value(a))) != NULL)
return mk_string(sc, val);
}
return sc->F;
}
int main(int argc, char *argv[])
{
region_t r;
cap_t fs_server;
if(argc != 2 && argc != 4) {
printf(_("Usage: %s /x=shell_options [OPTION_NAME on/off]\n"), argv[0]);
return 1;
}
if(get_process_caps("fs_op", &fs_server, NULL) < 0)
return 1;
{
cap_t opts;
struct cap_args result;
r = region_make();
cap_call(fs_server, r,
cap_args_make(cat2(r, mk_int(r, METHOD_FSOP_GET_OBJ),
mk_string(r, argv[1])),
caps_empty, fds_empty),
&result);
filesys_obj_free(fs_server);
if(expect_cap1(result, &opts) < 0) {
fprintf(stderr, _("%s: couldn't get options object\n"), argv[0]);
return 1;
}
if(argc == 2) {
print_option(r, opts, "log_summary");
print_option(r, opts, "log_into_xterm");
print_option(r, opts, "print_fs_tree");
print_option(r, opts, "enable_x11");
}
else if(argc == 4) {
int x;
if(!strcmp(argv[3], "on")) x = 1;
else if(!strcmp(argv[3], "off")) x = 0;
else {
fprintf(stderr, _("value `%s' not recognised\n"), argv[3]);
return 1;
}
set_option(r, opts, argv[2], x);
}
else assert(0);
}
return 0;
}
int main()
{
char *double_array[2];
double_array[0] = (char *)malloc(1);
double_array[0][0] = 0;
double_array[1] = NULL;
caml_startup(double_array);
std::string s= mk_string(1);
char* p;
c_echo (s.c_str(), &p);
free(p);
return 0;
}
static enum TOK_T get_next_token(port *in, pointer *token)
{
char ch, *t;
skip_white_spc(in);
switch (ch = get_next_char(in)) {
case EOF:
return FILE_END;
case '(':
return LIST_START;
case ')':
return LIST_END;
case '"':
*token = mk_string(read_string(in));
return STRING;
case '\'':
return QUOTE;
case '`':
return BACKQUOTE;
case ',':
if ((ch = get_next_char(in)) == '@')
return SPLICE;
else {
push_back_char(in, ch);
return UNQUOTE;
}
case '.':
return DOT;
default:
push_back_char(in, ch);
t = get_char_until_delim(in);
if (test_number(t)) {
*token = mk_number(atoi(t));
return NUMBER;
} else {
*token = mk_symbol(t);
return SYMBOL;
}
}
}
static int get_id(char *s)
{
static char string[MAXSTRINGLEN];
int len;
if ((len = lower(string, s, MAXSTRINGLEN)) == MAXSTRINGLEN)
return NOTOKEN;
if (!strcmp(string, "select"))
return yylval.ival = RW_SELECT;
if (!strcmp(string, "insert"))
return yylval.ival = RW_INSERT;
if (!strcmp(string, "delete"))
return yylval.ival = RW_DELETE;
if (!strcmp(string, "update"))
return yylval.ival = RW_UPDATE;
if (!strcmp(string, "create"))
return yylval.ival = RW_CREATE;
if (!strcmp(string, "destroy"))
return yylval.ival = RW_DESTROY;
if (!strcmp(string, "buildindex"))
return yylval.ival = RW_BUILD;
if (!strcmp(string, "rebuildindex"))
return yylval.ival = RW_REBUILD;
if (!strcmp(string, "dropindex"))
return yylval.ival = RW_DROP;
if (!strcmp(string, "load"))
return yylval.ival = RW_LOAD;
if (!strcmp(string, "print"))
return yylval.ival = RW_PRINT;
if (!strcmp(string, "help"))
return yylval.ival = RW_HELP;
if (!strcmp(string, "quit"))
return yylval.ival = RW_QUIT;
if (!strcmp(string, "into"))
return yylval.ival = RW_INTO;
if (!strcmp(string, "where"))
return yylval.ival = RW_WHERE;
if (!strcmp(string, "primary"))
return yylval.ival = RW_PRIMARY;
if (!strcmp(string, "numbuckets"))
return yylval.ival = RW_NUMBUCKETS;
if (!strcmp(string, "all"))
return yylval.ival = RW_ALL;
if (!strcmp(string, "from"))
return yylval.ival = RW_FROM;
if (!strcmp(string, "set"))
return yylval.ival = RW_SET;
if (!strcmp(string, "as"))
return yylval.ival = RW_AS;
if (!strcmp(string, "table"))
return yylval.ival = RW_TABLE;
if (!strcmp(string, "and"))
return yylval.ival = RW_AND;
if (!strcmp(string, "or"))
return yylval.ival = RW_OR;
if (!strcmp(string, "not"))
return yylval.ival = RW_NOT;
if (!strcmp(string, "values"))
return yylval.ival = RW_VALUES;
if (!strcmp(string, "int"))
return yylval.ival = INT_TYPE;
if (!strcmp(string, "real"))
return yylval.ival = REAL_TYPE;
if (!strcmp(string, "char"))
return yylval.ival = CHAR_TYPE;
yylval.sval = mk_string(s, len);
return T_STRING;
}
/*
* get_id: determines whether s is a reserved word, and returns the
* appropriate token value if it is. Otherwise, it returns the token
* value corresponding to a string. If s is longer than the maximum token
* length (MAXSTRINGLEN) then it returns NOTOKEN, so that the parser will
* flag an error (this is a stupid kludge).
*/
static int get_id(char *s)
{
static char string[MAXSTRINGLEN];
int len;
if((len = lower(string, s, MAXSTRINGLEN)) == MAXSTRINGLEN)
return NOTOKEN;
/* SM layer lexemes */
if(!strcmp(string, "create"))
return yylval.ival = RW_CREATE;
if(!strcmp(string, "drop"))
return yylval.ival = RW_DROP;
if(!strcmp(string, "table"))
return yylval.ival = RW_TABLE;
if(!strcmp(string, "index"))
return yylval.ival = RW_INDEX;
if(!strcmp(string, "load"))
return yylval.ival = RW_LOAD;
if(!strcmp(string, "help"))
return yylval.ival = RW_HELP;
if(!strcmp(string, "exit"))
return yylval.ival = RW_EXIT;
if(!strcmp(string, "print"))
return yylval.ival = RW_PRINT;
if(!strcmp(string, "set"))
return yylval.ival = RW_SET;
if(!strcmp(string, "and"))
return yylval.ival = RW_AND;
if(!strcmp(string, "into"))
return yylval.ival = RW_INTO;
if(!strcmp(string, "values"))
return yylval.ival = RW_VALUES;
/* QL layer lexemes */
if(!strcmp(string, "select"))
return yylval.ival = RW_SELECT;
if(!strcmp(string, "from"))
return yylval.ival = RW_FROM;
if(!strcmp(string, "where"))
return yylval.ival = RW_WHERE;
if(!strcmp(string, "insert"))
return yylval.ival = RW_INSERT;
if(!strcmp(string, "delete"))
return yylval.ival = RW_DELETE;
if(!strcmp(string, "update"))
return yylval.ival = RW_UPDATE;
/* IO Statistics lexemes */
if(!strcmp(string, "reset"))
return yylval.ival = RW_RESET;
if(!strcmp(string, "io"))
return yylval.ival = RW_IO;
if(!strcmp(string, "resize"))
return yylval.ival = RW_RESIZE;
if(!strcmp(string, "buffer"))
return yylval.ival = RW_BUFFER;
if(!strcmp(string, "queryplans"))
return yylval.ival = RW_QUERY_PLAN;
if(!strcmp(string, "on"))
return yylval.ival = RW_ON;
if(!strcmp(string, "off"))
return yylval.ival = RW_OFF;
/* unresolved lexemes are strings */
yylval.sval = mk_string(s, len);
return T_STRING;
}
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;
}
pointer mk_symbol(char *string)
{
pointer x= cons(mk_string(string), NULL);
type(x) = T_SYMBOL;
return x;
}
value_ptr String_literal::eval(const Environment&) const
{
return mk_string(val_);
}
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;
}
