shithub: sl

--- a/src/compress.c

+++ b/src/compress.c

@@ -73,6 +73,6 @@

 void

 compress_init(void)

-	FL_sizesym = symbol(":size", false);

-	FL_tosym = symbol(":to", false);

+	FL_sizesym = csymbol(":size");

+	FL_tosym = csymbol(":to");

--- a/src/cvalues.c

+++ b/src/cvalues.c

@@ -804,7 +804,7 @@

 #define cv_intern(tok) \

 	do{ \

-		FL_##tok##sym = symbol(#tok, false); \

+		FL_##tok##sym = csymbol(#tok); \

 	}while(0)

 #define ctor_cv_intern(tok, nt, ctype) \

@@ -1330,10 +1330,10 @@

 	ctor_cv_intern(array, NONNUMERIC, int);

-	FL_stringtypesym = symbol("*string-type*", false);

+	FL_stringtypesym = csymbol("*string-type*");

 	setc(FL_stringtypesym, fl_list2(FL_arraysym, FL_bytesym));

-	FL_runestringtypesym = symbol("*runestring-type*", false);

+	FL_runestringtypesym = csymbol("*runestring-type*");

 	setc(FL_runestringtypesym, fl_list2(FL_arraysym, FL_runesym));

 	mk_primtype(int8, int8_t);

--- a/src/flisp.c

+++ b/src/flisp.c

@@ -220,6 +220,14 @@

 	return tagptr(v, TAG_SYM);

+value_t

+csymbol_(const char *str, int len)

+{

+	symbol_t *v = mk_symbol(str, len, false);

+	FL(symtab) = Tsetl(FL(symtab), str, len, v);

+	return tagptr(v, TAG_SYM);

+}

 BUILTIN("gensym", gensym)

 	argcount(nargs, 0);

@@ -1316,61 +1324,61 @@

 		goto failed;

 	comparehash_init();

-	FL_lambda = symbol("λ", false);

-	FL_function = symbol("function", false);

-	FL_quote = symbol("quote", false);

-	FL_trycatch = symbol("trycatch", false);

-	FL_backquote = symbol("quasiquote", false);

-	FL_comma = symbol("unquote", false);

-	FL_commaat = symbol("unquote-splicing", false);

-	FL_commadot = symbol("unquote-nsplicing", false);

-	FL_IOError = symbol("io-error", false);

-	FL_ParseError = symbol("parse-error", false);

-	FL_TypeError = symbol("type-error", false);

-	FL_ArgError = symbol("arg-error", false);

-	FL_UnboundError = symbol("unbound-error", false);

-	FL_KeyError = symbol("key-error", false);

-	FL_MemoryError = symbol("memory-error", false);

-	FL_BoundsError = symbol("bounds-error", false);

-	FL_DivideError = symbol("divide-error", false);

-	FL_Error = symbol("error", false);

-	FL_conssym = symbol("cons", false);

-	FL_symbolsym = symbol("symbol", false);

-	FL_fixnumsym = symbol("fixnum", false);

-	FL_vectorsym = symbol("vector", false);

-	FL_builtinsym = symbol("builtin", false);

-	FL_booleansym = symbol("boolean", false);

-	FL_nullsym = symbol("null", false);

-	FL_definesym = symbol("define", false);

-	FL_defmacrosym = symbol("define-macro", false);

-	FL_forsym = symbol("for", false);

-	FL_setqsym = symbol("set!", false);

-	FL_evalsym = symbol("eval", false);

-	FL_vu8sym = symbol("vu8", false);

-	FL_fnsym = symbol("fn", false);

-	FL_nulsym = symbol("nul", false);

-	FL_alarmsym = symbol("alarm", false);

-	FL_backspacesym = symbol("backspace", false);

-	FL_tabsym = symbol("tab", false);

-	FL_linefeedsym = symbol("linefeed", false);

-	FL_vtabsym = symbol("vtab", false);

-	FL_pagesym = symbol("page", false);

-	FL_returnsym = symbol("return", false);

-	FL_escsym = symbol("esc", false);

-	FL_spacesym = symbol("space", false);

-	FL_deletesym = symbol("delete", false);

-	FL_newlinesym = symbol("newline", false);

-	FL_tsym = symbol("t", false);

-	FL_Tsym = symbol("T", false);

-	FL_fsym = symbol("f", false);

-	FL_Fsym = symbol("F", false);

-	FL_builtins_table_sym = symbol("*builtins*", false);

+	FL_lambda = csymbol("λ");

+	FL_function = csymbol("function");

+	FL_quote = csymbol("quote");

+	FL_trycatch = csymbol("trycatch");

+	FL_backquote = csymbol("quasiquote");

+	FL_comma = csymbol("unquote");

+	FL_commaat = csymbol("unquote-splicing");

+	FL_commadot = csymbol("unquote-nsplicing");

+	FL_IOError = csymbol("io-error");

+	FL_ParseError = csymbol("parse-error");

+	FL_TypeError = csymbol("type-error");

+	FL_ArgError = csymbol("arg-error");

+	FL_UnboundError = csymbol("unbound-error");

+	FL_KeyError = csymbol("key-error");

+	FL_MemoryError = csymbol("memory-error");

+	FL_BoundsError = csymbol("bounds-error");

+	FL_DivideError = csymbol("divide-error");

+	FL_Error = csymbol("error");

+	FL_conssym = csymbol("cons");

+	FL_symbolsym = csymbol("symbol");

+	FL_fixnumsym = csymbol("fixnum");

+	FL_vectorsym = csymbol("vector");

+	FL_builtinsym = csymbol("builtin");

+	FL_booleansym = csymbol("boolean");

+	FL_nullsym = csymbol("null");

+	FL_definesym = csymbol("define");

+	FL_defmacrosym = csymbol("define-macro");

+	FL_forsym = csymbol("for");

+	FL_setqsym = csymbol("set!");

+	FL_evalsym = csymbol("eval");

+	FL_vu8sym = csymbol("vu8");

+	FL_fnsym = csymbol("fn");

+	FL_nulsym = csymbol("nul");

+	FL_alarmsym = csymbol("alarm");

+	FL_backspacesym = csymbol("backspace");

+	FL_tabsym = csymbol("tab");

+	FL_linefeedsym = csymbol("linefeed");

+	FL_vtabsym = csymbol("vtab");

+	FL_pagesym = csymbol("page");

+	FL_returnsym = csymbol("return");

+	FL_escsym = csymbol("esc");

+	FL_spacesym = csymbol("space");

+	FL_deletesym = csymbol("delete");

+	FL_newlinesym = csymbol("newline");

+	FL_tsym = csymbol("t");

+	FL_Tsym = csymbol("T");

+	FL_fsym = csymbol("f");

+	FL_Fsym = csymbol("F");

+	FL_builtins_table_sym = csymbol("*builtins*");

-	set(FL_printprettysym = symbol("*print-pretty*", false), FL_t);

-	set(FL_printreadablysym = symbol("*print-readably*", false), FL_t);

-	set(FL_printwidthsym = symbol("*print-width*", false), fixnum(FL(scr_width)));

-	set(FL_printlengthsym = symbol("*print-length*", false), FL_f);

-	set(FL_printlevelsym = symbol("*print-level*", false), FL_f);

+	set(FL_printprettysym = csymbol("*print-pretty*"), FL_t);

+	set(FL_printreadablysym = csymbol("*print-readably*"), FL_t);

+	set(FL_printwidthsym = csymbol("*print-width*"), fixnum(FL(scr_width)));

+	set(FL_printlengthsym = csymbol("*print-length*"), FL_f);

+	set(FL_printlevelsym = csymbol("*print-level*"), FL_f);

 	FL(lasterror) = FL_nil;

 	for(i = 0; i < nelem(builtins); i++){

@@ -1377,8 +1385,8 @@

 		if(builtins[i].name)

 			set(symbol(builtins[i].name, false), builtin(i));

-	setc(symbol("procedure?", false), builtin(OP_FUNCTIONP));

-	setc(symbol("top-level-bound?", false), builtin(OP_BOUNDP));

+	setc(csymbol("procedure?"), builtin(OP_FUNCTIONP));

+	setc(csymbol("top-level-bound?"), builtin(OP_BOUNDP));

 	FL(the_empty_vector) = tagptr(alloc_words(1), TAG_VECTOR);

 	vector_setsize(FL(the_empty_vector), 0);

@@ -1385,9 +1393,9 @@

 	cvalues_init();

-	set(symbol("*os-name*", false), cvalue_static_cstring(__os_name__));

+	set(csymbol("*os-name*"), cvalue_static_cstring(__os_name__));

 #if defined(__os_version__)

-	set(symbol("*os-version*", false), cvalue_static_cstring(__os_version__));

+	set(csymbol("*os-version*"), cvalue_static_cstring(__os_version__));

 #endif

 	FL(memory_exception_value) = fl_list2(FL_MemoryError, cvalue_static_cstring("out of memory"));

--- a/src/flisp.h

+++ b/src/flisp.h

@@ -193,6 +193,8 @@

 /* symbol table */

 value_t gensym(void);

 value_t symbol(const char *str, bool copy) fl_hotfn;

+value_t csymbol_(const char *str, int len);

+#define csymbol(str) csymbol_(str, sizeof(str)-1)

 const char *symbol_name(value_t v);

 /* read, eval, print main entry points */

--- a/src/iostream.c

+++ b/src/iostream.c

@@ -438,16 +438,16 @@

 void

 iostream_init(void)

-	FL_iostreamsym = symbol("iostream", false);

-	FL_rdsym = symbol(":read", false);

-	FL_wrsym = symbol(":write", false);

-	FL_apsym = symbol(":append", false);

-	FL_crsym = symbol(":create", false);

-	FL_truncsym = symbol(":truncate", false);

-	FL_instrsym = symbol("*input-stream*", false);

-	FL_outstrsym = symbol("*output-stream*", false);

+	FL_iostreamsym = csymbol("iostream");

+	FL_rdsym = csymbol(":read");

+	FL_wrsym = csymbol(":write");

+	FL_apsym = csymbol(":append");

+	FL_crsym = csymbol(":create");

+	FL_truncsym = csymbol(":truncate");

+	FL_instrsym = csymbol("*input-stream*");

+	FL_outstrsym = csymbol("*output-stream*");

 	FL(iostreamtype) = define_opaque_type(FL_iostreamsym, sizeof(ios_t), &iostream_vtable, nil);

-	set(symbol("*stdout*", false), cvalue_from_ref(FL(iostreamtype), ios_stdout, sizeof(ios_t)));

-	set(symbol("*stderr*", false), cvalue_from_ref(FL(iostreamtype), ios_stderr, sizeof(ios_t)));

-	set(symbol("*stdin*", false), cvalue_from_ref(FL(iostreamtype), ios_stdin, sizeof(ios_t)));

+	set(csymbol("*stdout*"), cvalue_from_ref(FL(iostreamtype), ios_stdout, sizeof(ios_t)));

+	set(csymbol("*stderr*"), cvalue_from_ref(FL(iostreamtype), ios_stderr, sizeof(ios_t)));

+	set(csymbol("*stdin*"), cvalue_from_ref(FL(iostreamtype), ios_stdin, sizeof(ios_t)));