Sol Part 64: Now with Less Non-Deterministic "Electric" Strangs!

Pursuant some fuzzing, *most* places where a SOL_STRING (C string)
escaped to the user are now replaced with SOL_BUFFER. This allows,
amongst other things, source strings to contain embedded NUL characters.

Also, a fix for comma-after-empty-list in the parser is implemented.

.gitignore

@@ -15,3 +15,4 @@ doxyxml
 valgrind.log
 *_INFO
 prof
+/afl

Makefile

@@ -67,7 +67,7 @@ $(LINKED_VERS): sol$(SOL_VER)
 	rm $@; ln -s $? $@
 	
 sol$(SOL_VER): $(OBJ)
-	$(CC) $(CFLAGS) $? $(LDFLAGS) -o $@
+	$(CC) $(CFLAGS) $^ $(LDFLAGS) -o $@
 
 test: all $(sort $(patsubst tests/%.sol,test_%,$(wildcard tests/*.sol))) $(sort $(patsubst tests/%.sol,testcomp_%,$(wildcard tests/*.sol)))
 

RECIPES

@@ -6,3 +6,6 @@ make CC=clang CFLAGS="-fprofile-instr-generate -fcoverage-mapping"
 
 use Boehm GC where available:
 make LDFLAGS=-lgc
+
+AFL fuzzing (use afl-fuzz on the resulting instrumented binary):
+make CC=afl-gcc

ast.h

@@ -24,7 +24,7 @@ typedef struct tag_stmt_node stmt_node;
  *
  * Defines the types of literals that may appear in a source program.
  */
-typedef enum {LIT_INT=1024, LIT_FLOAT, LIT_STRING, LIT_NONE} lit_t;
+typedef enum {LIT_INT=1024, LIT_FLOAT, LIT_STRING, LIT_BUFFER, LIT_NONE} lit_t;
 /** Literal node
  *
  * Represents a literal in a source program.
@@ -35,9 +35,15 @@ typedef struct {
 		long ival; ///< Integer value for `LIT_INT`.
 		double fval; ///< Floating-point value for `LIT_FLOAT`.
 		char *str; ///< String value for `LIT_STRING`.
+		unsigned long *buf; ///< Buffer value for `LIT_BUFFER`; points to. (char *)(buf + 1) points to the first byte in the buffer. There are *buf bytes starting there. See also LENGTH_OF and BYTES_OF.
 	};
 } lit_node;
 
+/** Returns the length (as an unsigned long) of the buffer in bytes, not including the length itself. */
+#define LENGTH_OF(buf) (*((unsigned long *) (buf)))
+/** Returns a (char *) pointing to the first byte in the buffer. */
+#define BYTES_OF(buf) ((char *) (((unsigned long *) (buf)) + 1))
+
 /** Binary operation type
  *
  * Defines the types of binary operators that may occur in a source program.
@@ -237,10 +243,12 @@ typedef enum {
 	BC_LIT_INT,
 	BC_LIT_FLOAT,
 	BC_LIT_STRING,
+	BC_LIT_BUFFER,
 	BC_LIT_NONE,
 	BC_INT,
 	BC_FLOAT,
 	BC_STRING,
+	BC_BUFFER,
 	BC_LIST_ST,
 	BC_LIST_EX,
 	BC_LIST_AS,
@@ -333,6 +341,7 @@ void sol_ser_lit(FILE *, lit_node *);
 void sol_ser_int(FILE *, long);
 void sol_ser_float(FILE *, double);
 void sol_ser_str(FILE *, const char *);
+void sol_ser_buf(FILE *, unsigned long *);
 
 void *sol_deser(FILE *);
 void *sol_deser_checked(FILE *, bytecode);

astprint.c

@@ -82,6 +82,10 @@ void prex(sol_state_t *state, expr_node *node, int lev) {
 					prlev(state, lev, "String: %s", node->lit->str);
 					break;
 
+				case LIT_BUFFER:
+					prlev(state, lev, "Buffer of %lu bytes:", LENGTH_OF(node->lit->buf));
+					prlev(state, lev + 1, "%s", BYTES_OF(node->lit->buf));
+
 				case LIT_NONE:
 					prlev(state, lev, "None");
 					break;

builtins.c

@@ -1,3 +1,4 @@
+#define _GNU_SOURCE
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -59,6 +60,14 @@ sol_object_t *sol_f_default_repr(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_default_tobuffer(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *str = CALL_METHOD(state, obj, tostring, args);
+	sol_object_t *res = sol_new_buffer(state, strdup(str->str), strlen(str->str), OWN_FREE, NULL, NULL);
+	sol_obj_free(obj);
+	sol_obj_free(str);
+	return res;
+}
+
 sol_object_t *sol_f_tbang(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1);
 	int refa = a->refcnt, refb = b->refcnt;
@@ -100,6 +109,13 @@ sol_object_t *sol_f_tostring(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_tobuffer(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0);
+	sol_object_t *res = CALL_METHOD(state, obj, tobuffer, args);
+	sol_obj_free(obj);
+	return res;
+}
+
 sol_object_t *sol_f_try(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *func = sol_list_get_index(state, args, 0), *fargs = sol_list_sublist(state, args, 1);
 	sol_object_t *ls = sol_new_list(state), *one = sol_new_int(state, 1);
@@ -150,7 +166,7 @@ sol_object_t *sol_f_error(sol_state_t *state, sol_object_t *args) {
 
 sol_object_t *sol_f_type(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *obj = sol_list_get_index(state, args, 0);
-	sol_object_t *res = sol_new_string(state, obj->ops->tname);
+	sol_object_t *res = sol_new_buffer(state, strdup(obj->ops->tname), strlen(obj->ops->tname), OWN_FREE, NULL, NULL);
 	sol_obj_free(obj);
 	return res;
 }
@@ -252,11 +268,14 @@ void ob_print(sol_object_t *obj) {
 			break;
 
 		case SOL_BUFFER:
+			/*
 			if(obj->sz == -1) {
 				printf("<Buffer @%p>", obj->buffer);
 			} else {
 				printf("<Buffer @%p size %ld>", obj->buffer, obj->sz);
 			}
+			*/
+			fwrite(obj->buffer, sizeof(char), obj->sz, stdout);
 			break;
 
 		case SOL_CDATA:
@@ -447,7 +466,7 @@ sol_object_t *sol_f_ord(sol_state_t *state, sol_object_t *args) {
 sol_object_t *sol_f_chr(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *arg = sol_list_get_index(state, args, 0), *iarg = sol_cast_int(state, arg);
 	char cbuf[2] = {iarg->ival, 0};
-	sol_object_t *res = sol_new_string(state, cbuf);
+	sol_object_t *res = sol_new_buffer(state, strdup(cbuf), 1, OWN_FREE, NULL, NULL);
 	sol_obj_free(arg);
 	sol_obj_free(iarg);
 	return res;
@@ -488,6 +507,38 @@ sol_object_t *sol_f_debug_scopes(sol_state_t *state, sol_object_t *args) {
 	return sol_incref(state->scopes);
 }
 
+sol_object_t *sol_f_debug_getops(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *res = sol_new_map(state);
+	sol_map_borrow_name(state, res, "add", sol_new_cfunc(state, obj->ops->add, "add"));
+	sol_map_borrow_name(state, res, "sub", sol_new_cfunc(state, obj->ops->sub, "sub"));
+	sol_map_borrow_name(state, res, "mul", sol_new_cfunc(state, obj->ops->mul, "mul"));
+	sol_map_borrow_name(state, res, "div", sol_new_cfunc(state, obj->ops->div, "div"));
+	sol_map_borrow_name(state, res, "mod", sol_new_cfunc(state, obj->ops->mod, "mod"));
+	sol_map_borrow_name(state, res, "pow", sol_new_cfunc(state, obj->ops->pow, "pow"));
+	sol_map_borrow_name(state, res, "tbang", sol_new_cfunc(state, obj->ops->tbang, "tbang"));
+	sol_map_borrow_name(state, res, "band", sol_new_cfunc(state, obj->ops->band, "band"));
+	sol_map_borrow_name(state, res, "bor", sol_new_cfunc(state, obj->ops->bor, "bor"));
+	sol_map_borrow_name(state, res, "bxor", sol_new_cfunc(state, obj->ops->bxor, "bxor"));
+	sol_map_borrow_name(state, res, "blsh", sol_new_cfunc(state, obj->ops->blsh, "blsh"));
+	sol_map_borrow_name(state, res, "brsh", sol_new_cfunc(state, obj->ops->brsh, "brsh"));
+	sol_map_borrow_name(state, res, "bnot", sol_new_cfunc(state, obj->ops->bnot, "bnot"));
+	sol_map_borrow_name(state, res, "cmp", sol_new_cfunc(state, obj->ops->cmp, "cmp"));
+	sol_map_borrow_name(state, res, "call", sol_new_cfunc(state, obj->ops->call, "call"));
+	sol_map_borrow_name(state, res, "index", sol_new_cfunc(state, obj->ops->index, "index"));
+	sol_map_borrow_name(state, res, "setindex", sol_new_cfunc(state, obj->ops->setindex, "setindex"));
+	sol_map_borrow_name(state, res, "len", sol_new_cfunc(state, obj->ops->len, "len"));
+	sol_map_borrow_name(state, res, "iter", sol_new_cfunc(state, obj->ops->iter, "iter"));
+	sol_map_borrow_name(state, res, "toint", sol_new_cfunc(state, obj->ops->toint, "toint"));
+	sol_map_borrow_name(state, res, "tofloat", sol_new_cfunc(state, obj->ops->tofloat, "tofloat"));
+	sol_map_borrow_name(state, res, "tostring", sol_new_cfunc(state, obj->ops->tostring, "tostring"));
+	sol_map_borrow_name(state, res, "tobuffer", sol_new_cfunc(state, obj->ops->tobuffer, "tobuffer"));
+	sol_map_borrow_name(state, res, "repr", sol_new_cfunc(state, obj->ops->repr, "repr"));
+	sol_map_borrow_name(state, res, "init", sol_new_cfunc(state, obj->ops->init, "init"));
+	sol_map_borrow_name(state, res, "free", sol_new_cfunc(state, obj->ops->free, "free"));
+	sol_obj_free(obj);
+	return res;
+}
+
 #ifndef NO_READLINE
 sol_object_t *sol_f_readline_readline(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *obj, *objstr, *res;
@@ -502,10 +553,10 @@ sol_object_t *sol_f_readline_readline(sol_state_t *state, sol_object_t *args) {
 		line = readline("");
 	}
 	if(line) {
-		res = sol_new_string(state, line);
+		res = sol_new_buffer(state, strdup(line), strlen(line), OWN_FREE, NULL, NULL);
 		free(line);
 	} else {
-		res = sol_new_string(state, "");
+		res = sol_new_buffer(state, strdup(""), 0, OWN_FREE, NULL, NULL);
 	}
 	return res;
 }
@@ -550,6 +601,31 @@ sol_object_t *sol_f_iter_str(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_iter_buffer(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *local = sol_list_get_index(state, args, 1);
+	sol_object_t *idx = sol_map_get_name(state, local, "idx"), *sz = sol_map_get_name(state,local, "sz"), *res;
+	if(sol_is_none(state, idx) || sol_is_none(state, sz)) {
+		sol_obj_free(idx);
+		sol_obj_free(sz);
+		idx = sol_new_buffer(state, (void *) 0, sizeof(void *), OWN_NONE, NULL, NULL);
+		sz = sol_new_int(state, obj->sz);
+		sol_map_set_name(state, local, "idx", idx);
+		sol_map_set_name(state, local, "sz", sz);
+	}
+	if(((size_t) idx->buffer) >= sz->ival) {
+		sol_obj_free(idx);
+		sol_obj_free(sz);
+		sol_obj_free(local);
+		return sol_incref(state->None);
+	}
+	res = sol_new_buffer(state, ((char *) obj->buffer) + ((size_t) idx->buffer), 1, OWN_NONE, NULL, NULL);
+	idx->buffer = (void *) ((size_t) idx->buffer + 1);
+	sol_obj_free(idx);
+	sol_obj_free(sz);
+	sol_obj_free(local);
+	return res;
+}
+
 sol_object_t *sol_f_iter_list(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *obj = sol_list_get_index(state, args, 0), *local = sol_list_get_index(state, args, 1);
 	sol_object_t *index = sol_map_get_name(state, local, "idx"), *res;
@@ -611,6 +687,12 @@ sol_object_t *sol_f_singlet_tostring(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_singlet_tobuffer(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *res = sol_new_buffer(state, strdup(obj->str), strlen(obj->str), OWN_FREE, NULL, NULL);
+	sol_obj_free(obj);
+	return res;
+}
+
 sol_object_t *sol_f_int_add(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1), *bint = sol_cast_int(state, b);
 	sol_object_t *res = sol_new_int(state, a->ival + bint->ival);
@@ -911,7 +993,12 @@ sol_object_t *sol_f_str_mul(sol_state_t *state, sol_object_t *args) {
 
 sol_object_t *sol_f_str_cmp(sol_state_t *state, sol_object_t *args) {
     sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1);
-    sol_object_t *res;
+    sol_object_t *sb, *res;
+	if(sol_is_buffer(b)) {
+		sb = sol_cast_string(state, b);
+		sol_obj_free(b);
+		b = sb;
+	}
 	if(sol_is_string(b)) {
 		res = sol_new_int(state, strcmp(a->str, b->str));
 	} else {
@@ -970,6 +1057,13 @@ sol_object_t *sol_f_str_tostring(sol_state_t *state, sol_object_t *args) {
 	return sol_list_get_index(state, args, 0);
 }
 
+sol_object_t *sol_f_str_tobuffer(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *str = sol_list_get_index(state, args, 0);
+	sol_object_t *res = sol_new_buffer(state, strdup(str->str), strlen(str->str), OWN_FREE, NULL, NULL);
+	sol_obj_free(str);
+	return res;
+}
+
 sol_object_t *sol_f_str_repr(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *obj = sol_list_get_index(state, args, 0), *cur = sol_new_string(state, "\""), *next = sol_string_concat(state, cur, obj);
 	sol_obj_free(cur);
@@ -1145,7 +1239,7 @@ sol_object_t *sol_f_list_cmp(sol_state_t *state, sol_object_t *args) {
 sol_object_t *sol_f_list_index(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *ls = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1), *ival;
 	sol_object_t *res, *funcs;
-	if(sol_is_string(b)) {
+	if(sol_is_name(b)) {
 		funcs = sol_get_methods_name(state, "list");
 		res = sol_map_get(state, funcs, b);
 		sol_obj_free(funcs);
@@ -1515,35 +1609,35 @@ sol_object_t *sol_f_func_index(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *func = sol_list_get_index(state, args, 0), *key = sol_list_get_index(state, args, 1), *res;
 	identlist_node *curi;
 	int i = 0;
-	if(!sol_is_string(key)) {
+	if(!sol_is_name(key)) {
 		res = sol_map_get(state, func->udata, key);
 	} else {
-		if(sol_string_eq(state, key, "name")) {
+		if(sol_name_eq(state, key, "name")) {
 			if(func->fname) {
 				res = sol_new_string(state, func->fname);
 			} else {
 				res = sol_incref(state->None);
 			}
-		} else if(sol_string_eq(state, key, "closure")) {
+		} else if(sol_name_eq(state, key, "closure")) {
 			res = sol_incref(func->closure);
-		} else if(sol_string_eq(state, key, "udata")) {
+		} else if(sol_name_eq(state, key, "udata")) {
 			res = sol_incref(func->udata);
-		} else if(sol_string_eq(state, key, "stmt")) {
+		} else if(sol_name_eq(state, key, "stmt")) {
 			res = sol_new_stmtnode(state, st_copy((stmt_node *) func->func));
-		} else if(sol_string_eq(state, key, "args")) {
+		} else if(sol_name_eq(state, key, "args")) {
 			res = sol_new_list(state);
 			curi = func->args;
 			while(curi) {
 				sol_list_insert(state, res, i++, sol_new_string(state, curi->ident));
 				curi = curi->next;
 			}
-		} else if(sol_string_eq(state, key, "rest")) {
+		} else if(sol_name_eq(state, key, "rest")) {
 			if(func->rest) {
 				res = sol_new_string(state, func->rest);
 			} else {
 				res = sol_incref(state->None);
 			}
-		} else if(sol_string_eq(state, key, "annos")) {
+		} else if(sol_name_eq(state, key, "annos")) {
 			res = sol_incref(func->annos);
 		} else {
 			res = sol_map_get(state, func->udata, key);
@@ -1558,21 +1652,25 @@ sol_object_t *sol_f_func_setindex(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *func = sol_list_get_index(state, args, 0), *key = sol_list_get_index(state, args, 1), *val = sol_list_get_index(state, args, 2), *temp, *str;
 	size_t i, len;
 	identlist_node *cur, *prev;
-	if(sol_string_eq(state, key, "name") && sol_is_string(val)) {
+	if(sol_name_eq(state, key, "name") && sol_is_name(val)) {
 		free(func->fname);
-		func->fname = strdup(val->str);
-	} else if(sol_string_eq(state, key, "closure") && sol_is_map(val)) {
+		if(sol_is_string(val)) {
+			func->fname = strdup(val->str);
+		} else {
+			func->fname = sol_buffer_strdup(val);
+		}
+	} else if(sol_name_eq(state, key, "closure") && sol_is_map(val)) {
 		temp = func->closure;
 		func->closure = sol_incref(val);
 		sol_obj_free(temp);
-	} else if(sol_string_eq(state, key, "udata") && sol_is_map(val)) {
+	} else if(sol_name_eq(state, key, "udata") && sol_is_map(val)) {
 		temp = func->udata;
 		func->udata = sol_incref(val);
 		sol_obj_free(temp);
-	} else if(sol_string_eq(state, key, "stmt") && sol_is_aststmt(val)) {
+	} else if(sol_name_eq(state, key, "stmt") && sol_is_aststmt(val)) {
 		st_free(func->func);
 		func->func = st_copy(val->node);
-	} else if(sol_string_eq(state, key, "args") && sol_is_list(val)) {
+	} else if(sol_name_eq(state, key, "args") && sol_is_list(val)) {
 		idl_free(func->args);
 		func->args = NEW(identlist_node);
 		cur = func->args;
@@ -1591,10 +1689,14 @@ sol_object_t *sol_f_func_setindex(sol_state_t *state, sol_object_t *args) {
 		prev->next = NULL;
 		if(cur == func->args) func->args = NULL;
 		free(cur);
-	} else if(sol_string_eq(state, key, "rest") && sol_is_string(val)) {
+	} else if(sol_name_eq(state, key, "rest") && sol_is_name(val)) {
 		free(func->rest);
-		func->rest = strdup(val->str);
-	} else if(sol_string_eq(state, key, "annos") && sol_is_map(val)) {
+		if(sol_is_string(val)) {
+			func->rest = strdup(val->str);
+		} else {
+			func->rest = sol_buffer_strdup(val);
+		}
+	} else if(sol_name_eq(state, key, "annos") && sol_is_map(val)) {
 		sol_obj_free(func->annos);
 		func->annos = sol_incref(val);
 	} else {
@@ -2307,26 +2409,158 @@ sol_object_t *sol_f_astnode_tostring(sol_state_t *state, sol_object_t *args) {
 }
 
 sol_object_t *sol_f_buffer_index(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0);
 	sol_object_t *key = sol_list_get_index(state, args, 1), *funcs = sol_get_methods_name(state, "buffer");
-	sol_object_t *res = sol_map_get(state, funcs, key);
+	sol_object_t *res;
+	if(sol_is_name(key)) {
+		res = sol_map_get(state, funcs, key);
+	} else if(sol_is_int(key)) {
+		res = sol_new_buffer(state, a->buffer, (a->sz < 0) ? a->sz : (a->sz - key->ival), OWN_NONE, NULL, NULL);
+	} else {
+		res = sol_f_not_impl(state, args);
+	}
+	sol_obj_free(a);
 	sol_obj_free(key);
 	sol_obj_free(funcs);
 	return res;
 }
 
+sol_object_t *sol_f_buffer_add(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1), *bb = sol_cast_buffer(state, b);
+	sol_object_t *res = sol_buffer_concat(state, a, bb);
+	sol_obj_free(a);
+	sol_obj_free(b);
+	if(sol_has_error(state)) {
+		sol_obj_free(res);
+		return sol_incref(state->None);
+	}
+	return res;
+}
+
+sol_object_t *sol_f_buffer_mul(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1), *bint = sol_cast_int(state, b);
+	long ival, i;
+	size_t sz;
+	char *buf;
+	sol_obj_free(b);
+	if(sol_has_error(state)) {
+		sol_obj_free(a);
+		sol_obj_free(bint);
+		return sol_incref(state->None);
+	}
+	ival = bint->ival;
+	sol_obj_free(bint);
+	if(a->sz < 0) {
+		sol_obj_free(a);
+		return sol_set_error_string(state, "Multiply unsized buffer");
+	}
+	if(ival < 0) {
+		ival = 0;
+	}
+	sz = a->sz * ival;
+	buf = malloc(sz * sizeof(char));
+	for(i = 0; i < ival; i++) {
+		memcpy(buf + (i * a->sz), a->buffer, a->sz);
+	}
+	sol_obj_free(a);
+	return sol_new_buffer(state, buf, sz, OWN_FREE, NULL, NULL);
+}
+
+sol_object_t *sol_f_buffer_cmp(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1);
+	sol_object_t *bb, *res;
+	if(sol_is_string(b)) {
+		bb = sol_cast_buffer(state, b);
+		sol_obj_free(b);
+		b = bb;
+	}
+	if(sol_is_buffer(b)) {
+		ssize_t len = a->sz;
+		if(a->sz >= 0 && b->sz >= 0 && a->sz != b->sz) {
+			res = sol_new_int(state, 1);
+		} else {
+			if(len < 0) {
+				len = b->sz;
+			}
+			if(a->sz >= 0 && len > a->sz) len = a->sz;
+			if(b->sz >= 0 && len > b->sz) len = b->sz;
+			if(len < 0) {
+				res = sol_new_int(state, 1);
+			} else {
+				res = sol_new_int(state, memcmp(a->buffer, b->buffer, len));
+			}
+		}
+	} else {
+		res = sol_new_int(state, 1);
+	}
+	sol_obj_free(a);
+	sol_obj_free(b);
+	return res;
+}
+
+sol_object_t *sol_f_buffer_len(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0);
+	sol_object_t *res = sol_new_int(state, a->sz);
+	sol_obj_free(a);
+	return res;
+}
+
+sol_object_t *sol_f_buffer_iter(sol_state_t *state, sol_object_t *args) {
+	return sol_new_cfunc(state, sol_f_iter_buffer, "iter.buffer");
+}
+
 sol_object_t *sol_f_buffer_tostring(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *buf = sol_list_get_index(state, args, 0), *res;
+	char *b;
+	/*
 	char s[64];
 	if(buf->sz == -1) {
 		snprintf(s, 64, "<Buffer @%p>", buf->buffer);
 	} else {
-		snprintf(s, 64, "<Buffer @%p size %ld", buf->buffer, buf->sz);
+		snprintf(s, 64, "<Buffer @%p size %ld>", buf->buffer, buf->sz);
+	}
+	*/
+	if(buf->sz < 0) {
+		res = sol_new_string(state, "<UNSIZED_BUFFER>");
+	} else {
+		b = malloc(buf->sz + 1);
+		strncpy(b, buf->buffer, buf->sz);
+		b[buf->sz] = '\0';
+		res = sol_new_string(state, b);
+		free(b);
 	}
-	res = sol_new_string(state, s);
 	sol_obj_free(buf);
 	return res;
 }
 
+sol_object_t *sol_f_buffer_repr(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *cur = sol_new_buffer(state, "'", 1, OWN_NONE, NULL, NULL), *next = sol_buffer_concat(state, cur, obj);
+	sol_object_t *termin = sol_new_buffer(state, "'", 2, OWN_NONE, NULL, NULL);
+	sol_obj_free(cur);
+	cur = next;
+	next = sol_buffer_concat(state, cur, termin);
+	sol_obj_free(cur);
+	return next;
+}
+
+sol_object_t *sol_f_buffer_toint(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0);
+	sol_object_t *res = sol_new_int(state, atoi(a->buffer));
+	sol_obj_free(a);
+	return res;
+}
+
+sol_object_t *sol_f_buffer_tofloat(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0);
+	sol_object_t *res = sol_new_float(state, atof(a->buffer));
+	sol_obj_free(a);
+	return res;
+}
+
+sol_object_t *sol_f_buffer_tobuffer(sol_state_t *state, sol_object_t *args) {
+	return sol_list_get_index(state, args, 0);
+}
+
 sol_object_t *sol_f_buffer_new(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *sz = sol_list_get_index(state, args, 0), *isz = sol_cast_int(state, sz);
 	size_t bufsz = isz->ival;
@@ -2585,6 +2819,97 @@ sol_object_t *sol_f_buffer_size(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_buffer_sub(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *buf = sol_list_get_index(state, args, 0);
+	sol_object_t *low = sol_list_get_index(state, args, 1), *high = sol_list_get_index(state, args, 2);
+	sol_object_t *ilow, *ihigh;
+	long l, h;
+	char *b;
+	if(sol_is_none(state, low)) {
+		ilow = sol_new_int(state, 0);
+	} else {
+		ilow = sol_cast_int(state, low);
+	}
+	if(sol_is_none(state, high)) {
+		ihigh = sol_new_int(state, buf->sz);
+	} else {
+		ihigh = sol_cast_int(state, high);
+	}
+	l = ilow->ival;
+	h = ihigh->ival;
+	sol_obj_free(low);
+	sol_obj_free(high);
+	sol_obj_free(ilow);
+	sol_obj_free(ihigh);
+	if(l < 0) {
+		l += buf->sz;
+		if(l < 0) {
+			l = 0;
+		}
+	}
+	if(l > buf->sz) {
+		l = buf->sz;
+	}
+	if(h < 0) {
+		h += buf->sz;
+		if(h < 0) {
+			h = 0;
+		}
+	}
+	if(h > buf->sz) {
+		h = buf->sz;
+	}
+	if(l >= h) {
+		sol_obj_free(buf);
+		return sol_new_buffer(state, NULL, 0, OWN_NONE, NULL, NULL);
+	}
+	b = malloc(sizeof(char) * (h - l));
+	memcpy(b, buf->buffer, h - l);
+	sol_obj_free(buf);
+	return sol_new_buffer(state, b, h - l, OWN_FREE, NULL, NULL);
+}
+
+sol_object_t *sol_f_buffer_split(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *buf = sol_list_get_index(state, args, 0);
+	char *b;
+	sol_object_t *str, *res, *ls;
+	if(buf->sz < 0) {
+		sol_obj_free(buf);
+		return sol_set_error_string(state, "split unsized buffer");
+	}
+	b = malloc(sizeof(char) * (buf->sz + 1));
+	memcpy(b, buf->buffer, buf->sz);
+	b[buf->sz] = '\0';
+	str = sol_new_string(state, b);
+	free(b);
+	ls = sol_new_list(state);
+	sol_list_insert(state, ls, 0, str);
+	sol_obj_free(str);
+	str = sol_list_get_index(state, args, 1);
+	sol_list_insert(state, ls, 1, str);
+	sol_obj_free(str);
+	res = sol_f_str_split(state, ls);
+	sol_obj_free(ls);
+	return res;
+}
+
+sol_object_t *sol_f_buffer_find(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *buf = sol_list_get_index(state, args, 0), *subbuf = sol_list_get_index(state, args, 1), *bsubbuf = sol_cast_buffer(state, subbuf);
+	sol_object_t *res;
+	char *ptr;
+	sol_obj_free(subbuf);
+	if(buf->sz < 0 || bsubbuf->sz < 0) {
+		sol_obj_free(buf);
+		sol_obj_free(bsubbuf);
+		return sol_set_error_string(state, "find with unsized buffer");
+	}
+	ptr = memmem(buf->buffer, buf->sz, bsubbuf->buffer, bsubbuf->sz);
+	res = sol_new_int(state, ptr ? (ptr - ((char *) buf->buffer)) : -1);
+	sol_obj_free(buf);
+	sol_obj_free(bsubbuf);
+	return res;
+}
+
 sol_object_t *sol_f_buffer_fromstring(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *val = sol_list_get_index(state, args, 0), *sval = sol_cast_string(state, val);
 	size_t sz = strlen(sval->str) + 1;
@@ -2654,7 +2979,7 @@ sol_object_t *sol_f_stream_blsh(sol_state_t *state, sol_object_t *args) {
 }
 
 sol_object_t *sol_f_stream_brsh(sol_state_t *state, sol_object_t *args) {
-	return sol_f_stream_read(state, args);
+	return sol_f_stream_read_buffer(state, args);
 }
 
 sol_object_t *sol_f_stream_index(sol_state_t *state, sol_object_t *args) {
@@ -2670,10 +2995,16 @@ sol_object_t *sol_f_stream_tostring(sol_state_t *state, sol_object_t *args) {
 }
 
 sol_object_t *sol_f_stream_write(sol_state_t *state, sol_object_t *args) {
-	sol_object_t *stream = sol_list_get_index(state, args, 0), *obj = sol_list_get_index(state, args, 1), *str = sol_cast_string(state, obj);
-	size_t sz = sol_stream_printf(state, stream, "%s", str->str);
+	sol_object_t *stream = sol_list_get_index(state, args, 0), *obj = sol_list_get_index(state, args, 1), *str;
+	size_t sz;
+	if(sol_is_buffer(obj)) {
+		sz = sol_stream_fwrite(state, stream, obj->buffer, sizeof(char), obj->sz);
+	} else {
+		str = sol_cast_string(state, obj);
+		sz = sol_stream_printf(state, stream, "%s", str->str);
+		sol_obj_free(str);
+	}
 	sol_obj_free(obj);
-	sol_obj_free(str);
 	sol_obj_free(stream);
 	return sol_new_int(state, sz);
 }
@@ -2682,8 +3013,8 @@ sol_object_t *sol_f_stream_read_buffer(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *stream = sol_list_get_index(state, args, 0), *amt = sol_list_get_index(state, args, 1), *iamt, *res;
 	char *s = NULL, *p;
 	size_t count = 0, max = 0, pos, end;
-	if(sol_is_string(amt)) {
-		if(sol_string_eq(state, amt, "ALL")) {
+	if(sol_is_name(amt)) {
+		if(sol_name_eq(state, amt, "ALL")) {
 			pos = sol_stream_ftell(state, stream);
 			sol_stream_fseek(state, stream, 0, SEEK_END);
 			end = sol_stream_ftell(state, stream);
@@ -2697,7 +3028,7 @@ sol_object_t *sol_f_stream_read_buffer(sol_state_t *state, sol_object_t *args) {
 				return sol_set_error_string(state, "IO read error");
 			}
 			count = end - pos;
-		} else if(sol_string_eq(state, amt, "LINE")) {
+		} else if(sol_name_eq(state, amt, "LINE")) {
 			s = malloc(STDIO_CHUNK_SIZE * sizeof(char));
 			sol_stream_fgets(state, stream, s, STDIO_CHUNK_SIZE);
 			count = strlen(s);
@@ -2720,12 +3051,14 @@ sol_object_t *sol_f_stream_read_buffer(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+/*
 sol_object_t *sol_f_stream_read(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *buf = sol_f_stream_read_buffer(state, args);
 	sol_object_t *str = sol_new_string(state, buf->buffer);
 	sol_obj_free(buf);
 	return str;
 }
+*/
 
 sol_object_t *sol_f_stream_seek(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *stream = sol_list_get_index(state, args, 0), *offset = sol_list_get_index(state, args, 1), *whence = sol_list_get_index(state, args, 2);

lex.yy.c

@@ -8,96 +8,34 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 6
-#define YY_FLEX_SUBMINOR_VERSION 3
+#define YY_FLEX_SUBMINOR_VERSION 4
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
 
-    #define yy_create_buffer yy_create_buffer
-
-    #define yy_delete_buffer yy_delete_buffer
-
-    #define yy_scan_buffer yy_scan_buffer
-
-    #define yy_scan_string yy_scan_string
-
-    #define yy_scan_bytes yy_scan_bytes
-
-    #define yy_init_buffer yy_init_buffer
-
-    #define yy_flush_buffer yy_flush_buffer
-
-    #define yy_load_buffer_state yy_load_buffer_state
-
-    #define yy_switch_to_buffer yy_switch_to_buffer
-
-    #define yypush_buffer_state yypush_buffer_state
-
-    #define yypop_buffer_state yypop_buffer_state
-
-    #define yyensure_buffer_stack yyensure_buffer_stack
-
-    #define yylex yylex
-
-    #define yyrestart yyrestart
-
-    #define yylex_init yylex_init
-
-    #define yylex_init_extra yylex_init_extra
-
-    #define yylex_destroy yylex_destroy
-
-    #define yyget_debug yyget_debug
-
-    #define yyset_debug yyset_debug
-
-    #define yyget_extra yyget_extra
-
-    #define yyset_extra yyset_extra
-
-    #define yyget_in yyget_in
-
-    #define yyset_in yyset_in
-
-    #define yyget_out yyget_out
-
-    #define yyset_out yyset_out
-
-    #define yyget_leng yyget_leng
-
-    #define yyget_text yyget_text
-
-    #define yyget_lineno yyget_lineno
-
-    #define yyset_lineno yyset_lineno
-
-    #define yywrap yywrap
-
-    #define yyget_lval yyget_lval
-
-    #define yyset_lval yyset_lval
-
-    #define yyget_lloc yyget_lloc
-
-    #define yyset_lloc yyset_lloc
-
-    #define yyalloc yyalloc
-
-    #define yyrealloc yyrealloc
-
-    #define yyfree yyfree
-
-    #define yytext yytext
-
-    #define yyleng yyleng
-
-    #define yyin yyin
+#ifdef yyget_lval
+#define yyget_lval_ALREADY_DEFINED
+#else
+#define yyget_lval yyget_lval
+#endif
 
-    #define yyout yyout
+#ifdef yyset_lval
+#define yyset_lval_ALREADY_DEFINED
+#else
+#define yyset_lval yyset_lval
+#endif
 
-    #define yy_flex_debug yy_flex_debug
+#ifdef yyget_lloc
+#define yyget_lloc_ALREADY_DEFINED
+#else
+#define yyget_lloc yyget_lloc
+#endif
 
-    #define yylineno yylineno
+#ifdef yyset_lloc
+#define yyset_lloc_ALREADY_DEFINED
+#else
+#define yyset_lloc yyset_lloc
+#endif
 
 /* First, we deal with  platform-specific or compiler-specific issues. */
 
@@ -169,10 +107,16 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
 #endif /* ! C99 */
 
 #endif /* ! FLEXINT_H */
 
+/* begin standard C++ headers. */
+
 /* TODO: this is always defined, so inline it */
 #define yyconst const
 
@@ -204,7 +148,7 @@ typedef unsigned int flex_uint32_t;
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart(yyin  )
+#define YY_NEW_FILE yyrestart( yyin  )
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
@@ -370,7 +314,7 @@ void yypop_buffer_state ( void );
 static void yyensure_buffer_stack ( void );
 static void yy_load_buffer_state ( void );
 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
-#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
 
 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
 YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
@@ -386,7 +330,7 @@ void yyfree ( void *  );
 	if ( ! YY_CURRENT_BUFFER ){ \
         yyensure_buffer_stack (); \
 		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
 	} \
 	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 	}
@@ -395,7 +339,7 @@ void yyfree ( void *  );
 	if ( ! YY_CURRENT_BUFFER ){\
         yyensure_buffer_stack (); \
 		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
 	} \
 	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 	}
@@ -677,7 +621,7 @@ static void update_loc(YYLTYPE *yylloc, char *yytext){
 
 #define YY_USER_ACTION update_loc(yylloc, yytext);
 
-#line 680 "lex.yy.c"
+#line 624 "lex.yy.c"
 /* This is the right way to do it, but it keeps generating token $undefined.
 
 %x STRING
@@ -693,7 +637,7 @@ static void update_loc(YYLTYPE *yylloc, char *yytext){
 <STRING>. { str_putc(*yytext); }
 
 */
-#line 696 "lex.yy.c"
+#line 640 "lex.yy.c"
 
 #define INITIAL 0
 
@@ -924,17 +868,17 @@ YY_DECL
 		if ( ! YY_CURRENT_BUFFER ) {
 			yyensure_buffer_stack ();
 			YY_CURRENT_BUFFER_LVALUE =
-				yy_create_buffer(yyin,YY_BUF_SIZE );
+				yy_create_buffer( yyin, YY_BUF_SIZE );
 		}
 
-		yy_load_buffer_state( );
+		yy_load_buffer_state(  );
 		}
 
 	{
 #line 85 "tokenizer.lex"
 
 
-#line 937 "lex.yy.c"
+#line 881 "lex.yy.c"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1004,369 +948,366 @@ YY_RULE_SETUP
 	YY_BREAK
 case 3:
 /* rule 3 can match eol */
-YY_RULE_SETUP
-#line 91 "tokenizer.lex"
-{ *yylval = strdup(yytext+1); ((char *) *yylval)[yyleng-2] = 0; return STRING; }
-	YY_BREAK
+#line 92 "tokenizer.lex"
 case 4:
 /* rule 4 can match eol */
 YY_RULE_SETUP
-#line 93 "tokenizer.lex"
-{ *yylval = strdup(yytext+1); ((char *) *yylval)[yyleng-2] = 0; return STRING; }
+#line 92 "tokenizer.lex"
+{ *yylval = malloc(sizeof(unsigned long) + (yyleng - 2) * sizeof(char)); *((unsigned long *) *yylval) = yyleng - 2; memcpy(((char *) *yylval) + sizeof(unsigned long), yytext + 1, yyleng - 2); return STRING; }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 95 "tokenizer.lex"
+#line 94 "tokenizer.lex"
 { return IF; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 97 "tokenizer.lex"
+#line 96 "tokenizer.lex"
 { return THEN; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 99 "tokenizer.lex"
+#line 98 "tokenizer.lex"
 { return ELSE; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 101 "tokenizer.lex"
+#line 100 "tokenizer.lex"
 { return ELSEIF; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 103 "tokenizer.lex"
+#line 102 "tokenizer.lex"
 { return WHILE; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 105 "tokenizer.lex"
+#line 104 "tokenizer.lex"
 { return FOR; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 107 "tokenizer.lex"
+#line 106 "tokenizer.lex"
 { return IN; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 109 "tokenizer.lex"
+#line 108 "tokenizer.lex"
 { return DO; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 111 "tokenizer.lex"
+#line 110 "tokenizer.lex"
 { return FUNC; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 113 "tokenizer.lex"
+#line 112 "tokenizer.lex"
 { return LAMBDA; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 115 "tokenizer.lex"
+#line 114 "tokenizer.lex"
 { return RETURN; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 117 "tokenizer.lex"
+#line 116 "tokenizer.lex"
 { return BREAK; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 119 "tokenizer.lex"
+#line 118 "tokenizer.lex"
 { return CONTINUE; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 121 "tokenizer.lex"
+#line 120 "tokenizer.lex"
 { return END; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 123 "tokenizer.lex"
+#line 122 "tokenizer.lex"
 { return NONE; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 125 "tokenizer.lex"
+#line 124 "tokenizer.lex"
 { return PLUS; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 127 "tokenizer.lex"
+#line 126 "tokenizer.lex"
 { return MINUS; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 129 "tokenizer.lex"
+#line 128 "tokenizer.lex"
 { return STAR; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 131 "tokenizer.lex"
+#line 130 "tokenizer.lex"
 { return SLASH; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 133 "tokenizer.lex"
+#line 132 "tokenizer.lex"
 { return PERCENT; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 135 "tokenizer.lex"
+#line 134 "tokenizer.lex"
 { return PERCENT; }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 137 "tokenizer.lex"
+#line 136 "tokenizer.lex"
 { return DSTAR; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 139 "tokenizer.lex"
+#line 138 "tokenizer.lex"
 { return BAND; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 141 "tokenizer.lex"
+#line 140 "tokenizer.lex"
 { return BOR; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 143 "tokenizer.lex"
+#line 142 "tokenizer.lex"
 { return BXOR; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 145 "tokenizer.lex"
+#line 144 "tokenizer.lex"
 { return BNOT; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 147 "tokenizer.lex"
+#line 146 "tokenizer.lex"
 { return LAND; }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 149 "tokenizer.lex"
+#line 148 "tokenizer.lex"
 { return LAND; }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 151 "tokenizer.lex"
+#line 150 "tokenizer.lex"
 { return LOR; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 153 "tokenizer.lex"
+#line 152 "tokenizer.lex"
 { return LOR; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 155 "tokenizer.lex"
+#line 154 "tokenizer.lex"
 { return LNOT; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 157 "tokenizer.lex"
+#line 156 "tokenizer.lex"
 { return LNOT; }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 159 "tokenizer.lex"
+#line 158 "tokenizer.lex"
 { *yylval = malloc(sizeof(long)); *((long *) *yylval) = 1; return INT;  }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 161 "tokenizer.lex"
+#line 160 "tokenizer.lex"
 { *yylval = malloc(sizeof(long)); *((long *) *yylval) = 1; return INT;  }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 163 "tokenizer.lex"
+#line 162 "tokenizer.lex"
 { *yylval = malloc(sizeof(long)); *((long *) *yylval) = 0; return INT;  }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 165 "tokenizer.lex"
+#line 164 "tokenizer.lex"
 { *yylval = malloc(sizeof(long)); *((long *) *yylval) = 0; return INT;  }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 167 "tokenizer.lex"
+#line 166 "tokenizer.lex"
 { return ASSIGN; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 169 "tokenizer.lex"
+#line 168 "tokenizer.lex"
 { return ASSIGNPLUS; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 171 "tokenizer.lex"
+#line 170 "tokenizer.lex"
 { return ASSIGNMINUS; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 173 "tokenizer.lex"
+#line 172 "tokenizer.lex"
 { return ASSIGNSTAR; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 175 "tokenizer.lex"
+#line 174 "tokenizer.lex"
 { return ASSIGNSLASH; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 177 "tokenizer.lex"
+#line 176 "tokenizer.lex"
 { return ASSIGNDSTAR; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 179 "tokenizer.lex"
+#line 178 "tokenizer.lex"
 { return ASSIGNBAND; }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 181 "tokenizer.lex"
+#line 180 "tokenizer.lex"
 { return ASSIGNBOR; }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 183 "tokenizer.lex"
+#line 182 "tokenizer.lex"
 { return ASSIGNBXOR; }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 185 "tokenizer.lex"
+#line 184 "tokenizer.lex"
 { return EQUAL; }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 187 "tokenizer.lex"
+#line 186 "tokenizer.lex"
 { return NEQUAL; }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 189 "tokenizer.lex"
+#line 188 "tokenizer.lex"
 { return LESS; }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
-#line 191 "tokenizer.lex"
+#line 190 "tokenizer.lex"
 { return GREATER; }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 193 "tokenizer.lex"
+#line 192 "tokenizer.lex"
 { return LESSEQ; }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 195 "tokenizer.lex"
+#line 194 "tokenizer.lex"
 { return GREATEREQ; }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 197 "tokenizer.lex"
+#line 196 "tokenizer.lex"
 { return RSHIFT; }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 199 "tokenizer.lex"
+#line 198 "tokenizer.lex"
 { return LSHIFT; }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 201 "tokenizer.lex"
+#line 200 "tokenizer.lex"
 { return LBRACE; }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 203 "tokenizer.lex"
+#line 202 "tokenizer.lex"
 { return RBRACE; }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 205 "tokenizer.lex"
+#line 204 "tokenizer.lex"
 { return LBRACKET; }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 207 "tokenizer.lex"
+#line 206 "tokenizer.lex"
 { return RBRACKET; }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 209 "tokenizer.lex"
+#line 208 "tokenizer.lex"
 { return BLPAREN; } /* "Breaking" paren, not allowed to introduce a call_expr */
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 211 "tokenizer.lex"
+#line 210 "tokenizer.lex"
 { return LPAREN; } 
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 213 "tokenizer.lex"
+#line 212 "tokenizer.lex"
 { return RPAREN; }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 215 "tokenizer.lex"
+#line 214 "tokenizer.lex"
 { return DOT; }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 217 "tokenizer.lex"
+#line 216 "tokenizer.lex"
 { return COLON; }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 219 "tokenizer.lex"
+#line 218 "tokenizer.lex"
 { return SEMICOLON; }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
-#line 221 "tokenizer.lex"
+#line 220 "tokenizer.lex"
 { return COMMA; }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
-#line 223 "tokenizer.lex"
+#line 222 "tokenizer.lex"
 { return POUND; }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 225 "tokenizer.lex"
+#line 224 "tokenizer.lex"
 { return TBANG; }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 227 "tokenizer.lex"
+#line 226 "tokenizer.lex"
 { *yylval = (void *) strdup(yytext); return IDENT; }
 	YY_BREAK
 case 72:
 /* rule 72 can match eol */
 YY_RULE_SETUP
-#line 229 "tokenizer.lex"
+#line 228 "tokenizer.lex"
 /* Skip comments */
 	YY_BREAK
 case 73:
 /* rule 73 can match eol */
 YY_RULE_SETUP
-#line 231 "tokenizer.lex"
+#line 230 "tokenizer.lex"
 /* Skip whitespace */
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
-#line 233 "tokenizer.lex"
+#line 232 "tokenizer.lex"
 ECHO;
 	YY_BREAK
-#line 1369 "lex.yy.c"
+#line 1310 "lex.yy.c"
 case YY_STATE_EOF(INITIAL):
 	yyterminate();
 
@@ -1444,7 +1385,7 @@ case YY_STATE_EOF(INITIAL):
 				{
 				(yy_did_buffer_switch_on_eof) = 0;
 
-				if ( yywrap( ) )
+				if ( yywrap(  ) )
 					{
 					/* Note: because we've taken care in
 					 * yy_get_next_buffer() to have set up
@@ -1576,7 +1517,8 @@ static int yy_get_next_buffer (void)
 
 				b->yy_ch_buf = (char *)
 					/* Include room in for 2 EOB chars. */
-					yyrealloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2)  );
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2)  );
 				}
 			else
 				/* Can't grow it, we don't own it. */
@@ -1608,7 +1550,7 @@ static int yy_get_next_buffer (void)
 		if ( number_to_move == YY_MORE_ADJ )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart(yyin  );
+			yyrestart( yyin  );
 			}
 
 		else
@@ -1625,9 +1567,12 @@ static int yy_get_next_buffer (void)
 	if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
 		/* Extend the array by 50%, plus the number we really need. */
 		int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size  );
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size  );
 		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
 	}
 
 	(yy_n_chars) += number_to_move;
@@ -1779,13 +1724,13 @@ static int yy_get_next_buffer (void)
 					 */
 
 					/* Reset buffer status. */
-					yyrestart(yyin );
+					yyrestart( yyin );
 
 					/*FALLTHROUGH*/
 
 				case EOB_ACT_END_OF_FILE:
 					{
-					if ( yywrap( ) )
+					if ( yywrap(  ) )
 						return 0;
 
 					if ( ! (yy_did_buffer_switch_on_eof) )
@@ -1825,11 +1770,11 @@ static int yy_get_next_buffer (void)
 	if ( ! YY_CURRENT_BUFFER ){
         yyensure_buffer_stack ();
 		YY_CURRENT_BUFFER_LVALUE =
-            yy_create_buffer(yyin,YY_BUF_SIZE );
+            yy_create_buffer( yyin, YY_BUF_SIZE );
 	}
 
-	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
-	yy_load_buffer_state( );
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
+	yy_load_buffer_state(  );
 }
 
 /** Switch to a different input buffer.
@@ -1857,7 +1802,7 @@ static int yy_get_next_buffer (void)
 		}
 
 	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-	yy_load_buffer_state( );
+	yy_load_buffer_state(  );
 
 	/* We don't actually know whether we did this switch during
 	 * EOF (yywrap()) processing, but the only time this flag
@@ -1885,7 +1830,7 @@ static void yy_load_buffer_state  (void)
 {
 	YY_BUFFER_STATE b;
     
-	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
@@ -1894,13 +1839,13 @@ static void yy_load_buffer_state  (void)
 	/* yy_ch_buf has to be 2 characters longer than the size given because
 	 * we need to put in 2 end-of-buffer characters.
 	 */
-	b->yy_ch_buf = (char *) yyalloc((yy_size_t) (b->yy_buf_size + 2)  );
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
 	if ( ! b->yy_ch_buf )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
 	b->yy_is_our_buffer = 1;
 
-	yy_init_buffer(b,file );
+	yy_init_buffer( b, file );
 
 	return b;
 }
@@ -1919,9 +1864,9 @@ static void yy_load_buffer_state  (void)
 		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
 	if ( b->yy_is_our_buffer )
-		yyfree((void *) b->yy_ch_buf  );
+		yyfree( (void *) b->yy_ch_buf  );
 
-	yyfree((void *) b  );
+	yyfree( (void *) b  );
 }
 
 /* Initializes or reinitializes a buffer.
@@ -1933,7 +1878,7 @@ static void yy_load_buffer_state  (void)
 {
 	int oerrno = errno;
     
-	yy_flush_buffer(b );
+	yy_flush_buffer( b );
 
 	b->yy_input_file = file;
 	b->yy_fill_buffer = 1;
@@ -1976,7 +1921,7 @@ static void yy_load_buffer_state  (void)
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
 	if ( b == YY_CURRENT_BUFFER )
-		yy_load_buffer_state( );
+		yy_load_buffer_state(  );
 }
 
 /** Pushes the new state onto the stack. The new state becomes
@@ -2007,7 +1952,7 @@ void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
 	YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
 	/* copied from yy_switch_to_buffer. */
-	yy_load_buffer_state( );
+	yy_load_buffer_state(  );
 	(yy_did_buffer_switch_on_eof) = 1;
 }
 
@@ -2026,7 +1971,7 @@ void yypop_buffer_state (void)
 		--(yy_buffer_stack_top);
 
 	if (YY_CURRENT_BUFFER) {
-		yy_load_buffer_state( );
+		yy_load_buffer_state(  );
 		(yy_did_buffer_switch_on_eof) = 1;
 	}
 }
@@ -2093,7 +2038,7 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
 		/* They forgot to leave room for the EOB's. */
 		return NULL;
 
-	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 
@@ -2107,7 +2052,7 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
 	b->yy_fill_buffer = 0;
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
-	yy_switch_to_buffer(b  );
+	yy_switch_to_buffer( b  );
 
 	return b;
 }
@@ -2123,7 +2068,7 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
 YY_BUFFER_STATE yy_scan_string (const char * yystr )
 {
     
-	return yy_scan_bytes(yystr,(int) strlen(yystr) );
+	return yy_scan_bytes( yystr, (int) strlen(yystr) );
 }
 
 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
@@ -2142,7 +2087,7 @@ YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
     
 	/* Get memory for full buffer, including space for trailing EOB's. */
 	n = (yy_size_t) (_yybytes_len + 2);
-	buf = (char *) yyalloc(n  );
+	buf = (char *) yyalloc( n  );
 	if ( ! buf )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 
@@ -2151,7 +2096,7 @@ YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
 
 	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-	b = yy_scan_buffer(buf,n );
+	b = yy_scan_buffer( buf, n );
 	if ( ! b )
 		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
@@ -2169,7 +2114,7 @@ YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
 
 static void yynoreturn yy_fatal_error (const char* msg )
 {
-			(void) fprintf( stderr, "%s\n", msg );
+			fprintf( stderr, "%s\n", msg );
 	exit( YY_EXIT_FAILURE );
 }
 
@@ -2304,7 +2249,7 @@ int yylex_destroy  (void)
     
     /* Pop the buffer stack, destroying each element. */
 	while(YY_CURRENT_BUFFER){
-		yy_delete_buffer(YY_CURRENT_BUFFER  );
+		yy_delete_buffer( YY_CURRENT_BUFFER  );
 		YY_CURRENT_BUFFER_LVALUE = NULL;
 		yypop_buffer_state();
 	}
@@ -2370,7 +2315,7 @@ void yyfree (void * ptr )
 
 #define YYTABLES_NAME "yytables"
 
-#line 233 "tokenizer.lex"
+#line 232 "tokenizer.lex"
 
 
 int yywrap(void) {

object.c

@@ -31,6 +31,18 @@ sol_object_t *sol_cast_float(sol_state_t *state, sol_object_t *obj) {
 	return res;
 }
 
+sol_object_t *sol_cast_buffer(sol_state_t *state, sol_object_t *obj) {
+	sol_object_t *res, *ls;
+	if(sol_is_buffer(obj)) {
+		return sol_incref(obj);
+	}
+	ls = sol_new_list(state);
+	sol_list_insert(state, ls, 0, obj);
+	res = CALL_METHOD(state, obj, tobuffer, ls);
+	sol_obj_free(ls);
+	return res;
+}
+
 sol_object_t *sol_cast_string(sol_state_t *state, sol_object_t *obj) {
 	sol_object_t *res, *ls;
 	if(sol_is_string(obj)) {
@@ -375,7 +387,7 @@ sol_object_t *sol_map_get(sol_state_t *state, sol_object_t *map, sol_object_t *k
 }
 
 sol_object_t *sol_map_get_name(sol_state_t *state, sol_object_t *map, char *name) {
-	sol_object_t *key = sol_new_string(state, name);
+	sol_object_t *key = sol_new_buffer(state, name, strlen(name), OWN_NONE, NULL, NULL);
 	sol_object_t *res = sol_map_get(state, map, key);
 	sol_obj_free(key);
 	return res;
@@ -414,7 +426,7 @@ void sol_map_set(sol_state_t *state, sol_object_t *map, sol_object_t *key, sol_o
 }
 
 void sol_map_set_name(sol_state_t *state, sol_object_t *map, char *name, sol_object_t *val) {
-	sol_object_t *key = sol_new_string(state, name);
+	sol_object_t *key = sol_new_buffer(state, name, strlen(name), OWN_NONE, NULL, NULL);
 	sol_map_set(state, map, key, val);
 	sol_obj_free(key);
 }
@@ -554,6 +566,52 @@ sol_object_t *sol_new_buffer(sol_state_t *state, void *buffer, ssize_t sz, sol_o
 	return res;
 }
 
+int sol_buffer_cmp(sol_state_t *state, sol_object_t *buf, const char *s) {
+	size_t len = strlen(s);
+	if(buf->sz != -1 && buf->sz < len) len = buf->sz;
+	return memcmp(buf->buffer, s, len);
+}
+
+sol_object_t *sol_buffer_concat(sol_state_t *state, sol_object_t *a, sol_object_t *b) {
+	sol_object_t *ba = sol_cast_buffer(state, a), *bb = sol_cast_buffer(state, b);
+	char *buf;
+	size_t total;
+	if(ba->sz < 0 || bb->sz < 0) {
+		sol_obj_free(ba);
+		sol_obj_free(bb);
+		return sol_set_error_string(state, "Concatenate unsized buffer");
+	}
+	total = ba->sz + bb->sz;
+	buf = malloc(sizeof(char) * total);
+	if(!buf) {
+		sol_obj_free(ba);
+		sol_obj_free(bb);
+		return sol_incref(state->OutOfMemory);
+	}
+	memcpy(buf, ba->buffer, ba->sz);
+	memcpy(buf + ba->sz, bb->buffer, bb->sz);
+	sol_obj_free(ba);
+	sol_obj_free(bb);
+	return sol_new_buffer(state, buf, total, OWN_FREE, NULL, NULL);
+}
+
+sol_object_t *sol_buffer_concat_cstr(sol_state_t *state, sol_object_t *a, char *b) {
+	sol_object_t *buf = sol_new_buffer(state, b, strlen(b), OWN_NONE, NULL, NULL);
+	sol_object_t *res = sol_buffer_concat(state, a, buf);
+	sol_obj_free(buf);
+	return res;
+}
+
+char *sol_buffer_strdup(sol_object_t *a) {
+	char *b;
+	if(a->sz < 0) return NULL;
+	b = malloc(a->sz + 1);
+	if(!b) return NULL;
+	strncpy(b, a->buffer, a->sz);
+	b[a->sz] = '\0';
+	return b;
+}
+
 sol_object_t *sol_f_buffer_free(sol_state_t *state, sol_object_t *buf) {
 	switch(buf->own) {
 		case OWN_FREE:

parser.tab.c

@@ -526,8 +526,8 @@ static const yytype_uint16 yyrline[] =
      361,   365,   366,   370,   371,   379,   383,   392,   401,   413,
      417,   418,   429,   433,   434,   448,   449,   453,   454,   455,
      456,   457,   458,   462,   463,   464,   468,   472,   473,   478,
-     479,   510,   511,   546,   559,   594,   598,   599,   604,   605,
-     617,   622,   634,   635,   639,   640
+     479,   524,   525,   560,   573,   608,   612,   613,   618,   619,
+     638,   643,   655,   656,   660,   661
 };
 #endif
 
@@ -2453,7 +2453,7 @@ yyreduce:
 
   case 90:
 #line 456 "parser.y" /* yacc.c:1646  */
-    { (yyval) = NEW_EX(); AS_EX((yyval))->type = EX_LIT; AS_EX((yyval))->lit = NEW(lit_node); AS_EX((yyval))->lit->type = LIT_STRING; AS_EX((yyval))->lit->str = (yyvsp[0]); }
+    { (yyval) = NEW_EX(); AS_EX((yyval))->type = EX_LIT; AS_EX((yyval))->lit = NEW(lit_node); AS_EX((yyval))->lit->type = LIT_BUFFER; AS_EX((yyval))->lit->buf = (yyvsp[0]); }
 #line 2458 "parser.tab.c" /* yacc.c:1646  */
     break;
 
@@ -2519,24 +2519,31 @@ yyreduce:
 #line 479 "parser.y" /* yacc.c:1646  */
     {
 	exprlist_node *cur = (yyvsp[-1]);
-	while(cur->next) cur = cur->next;
-	cur->next = NEW(exprlist_node);
-	cur = cur->next;
-	cur->expr = (yyvsp[0]);
-	cur->next = NULL;
-	(yyval) = (yyvsp[-1]);
+	if(!cur) {
+		cur = NEW(exprlist_node);
+		cur->expr = (yyvsp[0]);
+		cur->next = NULL;
+		(yyval) = cur;
+	} else {
+		while(cur->next) cur = cur->next;
+		cur->next = NEW(exprlist_node);
+		cur = cur->next;
+		cur->expr = (yyvsp[0]);
+		cur->next = NULL;
+		(yyval) = (yyvsp[-1]);
+	}
 }
-#line 2530 "parser.tab.c" /* yacc.c:1646  */
+#line 2537 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 101:
-#line 510 "parser.y" /* yacc.c:1646  */
+#line 524 "parser.y" /* yacc.c:1646  */
     { (yyval) = NULL; }
-#line 2536 "parser.tab.c" /* yacc.c:1646  */
+#line 2543 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 102:
-#line 511 "parser.y" /* yacc.c:1646  */
+#line 525 "parser.y" /* yacc.c:1646  */
     {
 	paramlist_node *pl = (yyvsp[-3]);
 	identlist_node *curk;
@@ -2572,11 +2579,11 @@ yyreduce:
 	curv->next = NULL;
 	(yyval) = pl;
 }
-#line 2576 "parser.tab.c" /* yacc.c:1646  */
+#line 2583 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 103:
-#line 546 "parser.y" /* yacc.c:1646  */
+#line 560 "parser.y" /* yacc.c:1646  */
     {
 	paramlist_node *pl = (yyvsp[-2]);
 	if(!pl) {
@@ -2590,11 +2597,11 @@ yyreduce:
 	pl-> rest = (yyvsp[0]);
 	(yyval) = pl;
 }
-#line 2594 "parser.tab.c" /* yacc.c:1646  */
+#line 2601 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 104:
-#line 559 "parser.y" /* yacc.c:1646  */
+#line 573 "parser.y" /* yacc.c:1646  */
     {
 	paramlist_node *pl = (yyvsp[-2]);
 	identlist_node *cura;
@@ -2630,63 +2637,70 @@ yyreduce:
 	curn->next = NULL;
 	(yyval) = pl;
 }
-#line 2634 "parser.tab.c" /* yacc.c:1646  */
+#line 2641 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 105:
-#line 594 "parser.y" /* yacc.c:1646  */
+#line 608 "parser.y" /* yacc.c:1646  */
     { (yyval) = (yyvsp[-1]); }
-#line 2640 "parser.tab.c" /* yacc.c:1646  */
+#line 2647 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 106:
-#line 598 "parser.y" /* yacc.c:1646  */
+#line 612 "parser.y" /* yacc.c:1646  */
     { (yyval) = NULL; }
-#line 2646 "parser.tab.c" /* yacc.c:1646  */
+#line 2653 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 107:
-#line 599 "parser.y" /* yacc.c:1646  */
+#line 613 "parser.y" /* yacc.c:1646  */
     {
 	(yyval) = NEW(assoclist_node);
 	AS((yyval), assoclist_node)->item = (yyvsp[0]);
 	AS((yyval), assoclist_node)->next = NULL;
 }
-#line 2656 "parser.tab.c" /* yacc.c:1646  */
+#line 2663 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 108:
-#line 604 "parser.y" /* yacc.c:1646  */
+#line 618 "parser.y" /* yacc.c:1646  */
     { (yyval) = (yyvsp[-1]); }
-#line 2662 "parser.tab.c" /* yacc.c:1646  */
+#line 2669 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 109:
-#line 605 "parser.y" /* yacc.c:1646  */
+#line 619 "parser.y" /* yacc.c:1646  */
     {
 	assoclist_node *cur = (yyvsp[-1]);
-	while(cur->next) cur = cur->next;
-	cur->next = NEW(assoclist_node);
-	cur = cur->next;
-	cur->item = (yyvsp[0]);
-	cur->next = NULL;
-	(yyval) = (yyvsp[-1]);
+	if(!cur) {
+		cur = NEW(assoclist_node);
+		cur->item = (yyvsp[0]);
+		cur->next = NULL;
+		(yyval) = cur;
+	} else {
+		while(cur->next) cur = cur->next;
+		cur->next = NEW(assoclist_node);
+		cur = cur->next;
+		cur->item = (yyvsp[0]);
+		cur->next = NULL;
+		(yyval) = (yyvsp[-1]);
+	}
 }
-#line 2676 "parser.tab.c" /* yacc.c:1646  */
+#line 2690 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 110:
-#line 617 "parser.y" /* yacc.c:1646  */
+#line 638 "parser.y" /* yacc.c:1646  */
     {
 	(yyval) = NEW(associtem_node);
 	AS((yyval), associtem_node)->key = (yyvsp[-3]);
 	AS((yyval), associtem_node)->value = (yyvsp[0]);
 }
-#line 2686 "parser.tab.c" /* yacc.c:1646  */
+#line 2700 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 111:
-#line 622 "parser.y" /* yacc.c:1646  */
+#line 643 "parser.y" /* yacc.c:1646  */
     {
 	(yyval) = NEW(associtem_node);
 	AS((yyval), associtem_node)->key = NEW_EX();
@@ -2696,23 +2710,23 @@ yyreduce:
 	AS((yyval), associtem_node)->key->lit->str = (yyvsp[-2]);
 	AS((yyval), associtem_node)->value = (yyvsp[0]);
 }
-#line 2700 "parser.tab.c" /* yacc.c:1646  */
+#line 2714 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 114:
-#line 639 "parser.y" /* yacc.c:1646  */
+#line 660 "parser.y" /* yacc.c:1646  */
     { (yyval) = (yyvsp[0]); }
-#line 2706 "parser.tab.c" /* yacc.c:1646  */
+#line 2720 "parser.tab.c" /* yacc.c:1646  */
     break;
 
   case 115:
-#line 640 "parser.y" /* yacc.c:1646  */
+#line 661 "parser.y" /* yacc.c:1646  */
     { (yyval) = NULL; }
-#line 2712 "parser.tab.c" /* yacc.c:1646  */
+#line 2726 "parser.tab.c" /* yacc.c:1646  */
     break;
 
 
-#line 2716 "parser.tab.c" /* yacc.c:1646  */
+#line 2730 "parser.tab.c" /* yacc.c:1646  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -2947,7 +2961,7 @@ yyreturn:
 #endif
   return yyresult;
 }
-#line 643 "parser.y" /* yacc.c:1906  */
+#line 664 "parser.y" /* yacc.c:1906  */
 
 
 // TODO

parser.y

@@ -453,7 +453,7 @@ lit_expr:
   INT { $$ = NEW_EX(); AS_EX($$)->type = EX_LIT; AS_EX($$)->lit = NEW(lit_node); AS_EX($$)->lit->type = LIT_INT; AS_EX($$)->lit->ival = *AS($1, long); free($1); }
 | MINUS INT { $$ = NEW_EX(); AS_EX($$)->type = EX_LIT; AS_EX($$)->lit = NEW(lit_node); AS_EX($$)->lit->type = LIT_INT; AS_EX($$)->lit->ival = -(*AS($2, long)); free($2); }
 | FLOAT { $$ = NEW_EX(); AS_EX($$)->type = EX_LIT; AS_EX($$)->lit = NEW(lit_node); AS_EX($$)->lit->type = LIT_FLOAT; AS_EX($$)->lit->fval = *AS($1, double); free($1); }
-| STRING { $$ = NEW_EX(); AS_EX($$)->type = EX_LIT; AS_EX($$)->lit = NEW(lit_node); AS_EX($$)->lit->type = LIT_STRING; AS_EX($$)->lit->str = $1; }
+| STRING { $$ = NEW_EX(); AS_EX($$)->type = EX_LIT; AS_EX($$)->lit = NEW(lit_node); AS_EX($$)->lit->type = LIT_BUFFER; AS_EX($$)->lit->buf = $1; }
 | NONE { $$ = NEW_EX(); AS_EX($$)->type = EX_LIT; AS_EX($$)->lit = NEW(lit_node); AS_EX($$)->lit->type = LIT_NONE; }
 | gen_expr { $$ = $1; }
 ;
@@ -478,12 +478,19 @@ expr_list:
 | expr_list COMMA { $$ = $1; }
 | expr_list expr {
 	exprlist_node *cur = $1;
-	while(cur->next) cur = cur->next;
-	cur->next = NEW(exprlist_node);
-	cur = cur->next;
-	cur->expr = $2;
-	cur->next = NULL;
-	$$ = $1;
+	if(!cur) {
+		cur = NEW(exprlist_node);
+		cur->expr = $2;
+		cur->next = NULL;
+		$$ = cur;
+	} else {
+		while(cur->next) cur = cur->next;
+		cur->next = NEW(exprlist_node);
+		cur = cur->next;
+		cur->expr = $2;
+		cur->next = NULL;
+		$$ = $1;
+	}
 }
 ;
 
@@ -497,12 +504,19 @@ ident_list:
 | ident_list COMMA { $$ = $1; }
 | ident_list IDENT {
 	identlist_node *cur = $1;
-	while(cur->next) cur = cur->next;
-	cur->next = NEW(identlist_node);
-	cur = cur->next;
-	cur->ident = $2;
-	cur->next = NULL;
-	$$ = $1;
+	if(!cur) {
+		cur = NEW(identlist_node);
+		cur->ident = $2;
+		cur->next = NULL;
+		$$ = cur;
+	} else {
+		while(cur->next) cur = cur->next;
+		cur->next = NEW(identlist_node);
+		cur = cur->next;
+		cur->ident = $2;
+		cur->next = NULL;
+		$$ = $1;
+	}
 }
 ;
 
@@ -604,12 +618,19 @@ assoc_list:
 | assoc_list COMMA { $$ = $1; }
 | assoc_list assoc_item {
 	assoclist_node *cur = $1;
-	while(cur->next) cur = cur->next;
-	cur->next = NEW(assoclist_node);
-	cur = cur->next;
-	cur->item = $2;
-	cur->next = NULL;
-	$$ = $1;
+	if(!cur) {
+		cur = NEW(assoclist_node);
+		cur->item = $2;
+		cur->next = NULL;
+		$$ = cur;
+	} else {
+		while(cur->next) cur = cur->next;
+		cur->next = NEW(assoclist_node);
+		cur = cur->next;
+		cur->item = $2;
+		cur->next = NULL;
+		$$ = $1;
+	}
 }
 ;
 

programs/test.sol

@@ -331,9 +331,9 @@ print('(buffer.sizeof.ptr = ', buffer.sizeof.ptr, ')')
 print('(buffer.sizeof.int = ', buffer.sizeof.int, ')')
 print('(buffer.sizeof.int*2 = ', buffer.sizeof.int*2, ')')
 print('(buffer.sizeof.int*2 + buffer.sizeof.ptr = ', buffer.sizeof.int*2 + (buffer.sizeof.ptr), ')')
-bs = b:get(buffer.type.ptr, buffer.sizeof.int*2 + (buffer.sizeof.ptr))
-print('...string buffer:', bs)
-print('...with value:', bs:get(buffer.type.cstr))
+--bs = b:get(buffer.type.ptr, buffer.sizeof.int*2 + (buffer.sizeof.ptr))
+--print('...string buffer:', bs)
+--print('...with value:', bs:get(buffer.type.cstr))
 
 print('--- IO redirection')
 

runtime.c

@@ -108,6 +108,12 @@ expr_node *ex_copy(expr_node *old) {
 					new->lit->str = strdup(old->lit->str);
 					break;
 
+				case LIT_BUFFER:
+					new->lit->buf = malloc(sizeof(unsigned long) + LENGTH_OF(old->lit->buf) * sizeof(char));
+					LENGTH_OF(new->lit->buf) = LENGTH_OF(old->lit->buf);
+					memcpy(BYTES_OF(new->lit->buf), BYTES_OF(old->lit->buf), LENGTH_OF(old->lit->buf) * sizeof(char));
+					break;
+
 				case LIT_NONE:
 					break;
 
@@ -358,6 +364,9 @@ void ex_free(expr_node *expr) {
 			if(expr->lit->type == LIT_STRING) {
 				free(expr->lit->str);
 			}
+			if(expr->lit->type == LIT_BUFFER) {
+				free(expr->lit->buf);
+			}
 			free(expr->lit);
 			break;
 
@@ -497,6 +506,7 @@ sol_object_t *sol_eval_inner(sol_state_t *state, expr_node *expr, jmp_buf jmp) {
 	exprlist_node *cure = NULL;
 	assoclist_node *cura = NULL;
 	identlist_node *curi = NULL;
+	char *buf;
 	if(!expr) {
 		return sol_set_error_string(state, "Evaluate NULL expression");
 	}
@@ -516,6 +526,11 @@ sol_object_t *sol_eval_inner(sol_state_t *state, expr_node *expr, jmp_buf jmp) {
 					return sol_new_string(state, expr->lit->str);
 					break;
 
+				case LIT_BUFFER:
+					buf = malloc(LENGTH_OF(expr->lit->buf));
+					memcpy(buf, BYTES_OF(expr->lit->buf), LENGTH_OF(expr->lit->buf));
+					return sol_new_buffer(state, buf, LENGTH_OF(expr->lit->buf), OWN_FREE, NULL, NULL);
+
 				case LIT_NONE:
 					return sol_incref(state->None);
 					break;

ser.c

@@ -29,10 +29,12 @@ char *sol_BytecodeNames[] = {
 	"BC_LIT_INT",
 	"BC_LIT_FLOAT",
 	"BC_LIT_STRING",
+	"BC_LIT_BUFFER",
 	"BC_LIT_NONE",
 	"BC_INT",
 	"BC_FLOAT",
 	"BC_STRING",
+	"BC_BUFFER",
 	"BC_LIST_ST",
 	"BC_LIST_EX",
 	"BC_LIST_AS",
@@ -251,6 +253,11 @@ void sol_ser_lit(FILE *io, lit_node *lit) {
 			sol_ser_str(io, lit->str);
 			break;
 
+		case LIT_BUFFER:
+			fputc(BC_LIT_BUFFER, io);
+			sol_ser_buf(io, lit->buf);
+			break;
+
 		case LIT_NONE:
 			fputc(BC_LIT_NONE, io);
 			break;
@@ -273,6 +280,12 @@ void sol_ser_str(FILE *io, const char *s) {
 	fwrite(s, sizeof(char), len, io);
 }
 
+void sol_ser_buf(FILE *io, unsigned long *buf) {
+	fputc(BC_BUFFER, io);
+	fwrite(buf, sizeof(unsigned long), 1, io);
+	fwrite(BYTES_OF(buf), sizeof(char), LENGTH_OF(buf), io);
+}
+
 void sol_ser_int(FILE *io, long i) {
 	fputc(BC_INT, io);
 	fwrite(&i, sizeof(long), 1, io);
@@ -350,6 +363,7 @@ void *sol_deser_lit(FILE *io) {
 		case BC_LIT_INT:
 		case BC_LIT_FLOAT:
 		case BC_LIT_STRING:
+		case BC_LIT_BUFFER:
 		case BC_LIT_NONE:
 			;
 	}
@@ -540,6 +554,12 @@ void *sol_deser(FILE *io) {
 			AS(obj, lit_node)->str = sol_deser_checked(io, BC_STRING);
 			return obj;
 
+		case BC_LIT_BUFFER:
+			obj = NEW(lit_node);
+			AS(obj, lit_node)->type = LIT_BUFFER;
+			AS(obj, lit_node)->buf = sol_deser_checked(io, BC_BUFFER);
+			return obj;
+
 		case BC_LIT_NONE:
 			obj = NEW(lit_node);
 			AS(obj, lit_node)->type = LIT_NONE;
@@ -564,6 +584,15 @@ void *sol_deser(FILE *io) {
 			free(node);
 			return obj;
 
+		case BC_BUFFER:
+			node = NEW(unsigned long);
+			fread(node, sizeof(unsigned long), 1, io);
+			obj = malloc(sizeof(unsigned long) + sizeof(char) * (*AS(node, unsigned long)));
+			LENGTH_OF(obj) = *AS(node, unsigned long);
+			fread(BYTES_OF(obj), sizeof(char), LENGTH_OF(obj), io);
+			free(node);
+			return obj;
+
 		case BC_LIST_ST:
 			while((b = fgetc(io)) != BC_ENDLIST) {
 				ungetc(b, io);

sol.h

@@ -10,7 +10,7 @@
 #include "dsl/dsl.h"
 
 /** The version of the project, as made available through `debug.version`. */
-#define SOL_VERSION "0.3a4"
+#define SOL_VERSION "0.4a0"
 /** The hexadecimal version of the project, formatted 0xAAIIRPP where:
  * 
  * - AA is the two-digit major version
@@ -23,7 +23,7 @@
  * version shall be available in all versions numerically greater than it
  * (unless they are later deprecated or removed).
  */
-#define SOL_HEXVER 0x0003A04
+#define SOL_HEXVER 0x0004A00
 
 #ifndef SOL_BUILD_HOST
 #define SOL_BUILD_HOST "(unknown host)"
@@ -160,6 +160,8 @@ typedef struct {
 	sol_cfunc_t tofloat;
 	/** Called with [this] to cast "this" to a string object. This generally shouldn't raise an error, and usually falls back to a simple representation. */
 	sol_cfunc_t tostring;
+	/** Called with [this] to cast "this" to a buffer object. This generally shouldn't raise an error, and usually falls back to converting the tostring to a buffer (which might be lossy if the string has embedded NULs). */
+	sol_cfunc_t tobuffer;
 	/** Called with [this] to provide a representation of "this", in the sense that it is human-readable and informative. This usually falls back to tostring. */
 	sol_cfunc_t repr;
 	/** Called with this (*not a list*) as a result of calling `sol_init_object`. Since this is usually called from a constructor anyway, it's usually fairly useless. It should return this. */
@@ -704,6 +706,11 @@ sol_object_t *sol_f_default_tostring(sol_state_t *, sol_object_t *);
  * Returns tostring(object).
  */
 sol_object_t *sol_f_default_repr(sol_state_t *, sol_object_t *);
+/** Default tobuffer handler.
+ *
+ * Returns buffer.fromstring(tostring(object)).
+ */
+sol_object_t *sol_f_default_tobuffer(sol_state_t *, sol_object_t *);
 
 /// Built-in function toint
 sol_object_t *sol_f_toint(sol_state_t *, sol_object_t *);
@@ -711,6 +718,8 @@ sol_object_t *sol_f_toint(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_tofloat(sol_state_t *, sol_object_t *);
 /// Built-in function tostring
 sol_object_t *sol_f_tostring(sol_state_t *, sol_object_t *);
+/// Built-in function tobuffer
+sol_object_t *sol_f_tobuffer(sol_state_t *, sol_object_t *);
 /// Built-in function try
 sol_object_t *sol_f_try(sol_state_t *, sol_object_t *);
 /// Built-in function apply
@@ -748,8 +757,10 @@ sol_object_t *sol_f_debug_closure(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_debug_globals(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_debug_locals(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_debug_scopes(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_debug_getops(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_iter_str(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_iter_buffer(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_iter_list(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_iter_map(sol_state_t *, sol_object_t *);
 
@@ -759,6 +770,7 @@ sol_object_t *sol_f_readline_add_history(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_ast_print(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_singlet_tostring(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_singlet_tobuffer(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_int_add(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_int_sub(sol_state_t *, sol_object_t *);
@@ -796,6 +808,7 @@ sol_object_t *sol_f_str_index(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_toint(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_tofloat(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_tostring(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_str_tobuffer(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_repr(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_str_sub(sol_state_t *, sol_object_t *);
@@ -844,12 +857,24 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_astnode_tostring(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_buffer_index(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_add(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_mul(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_cmp(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_len(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_iter(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_buffer_tostring(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_repr(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_toint(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_tofloat(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_tobuffer(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_buffer_get(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_buffer_set(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_buffer_address(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_buffer_size(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_sub(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_split(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_buffer_find(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_buffer_new(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_buffer_fromstring(sol_state_t *, sol_object_t *);
@@ -875,7 +900,7 @@ sol_object_t *sol_f_stream_index(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_stream_tostring(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_stream_write(sol_state_t *, sol_object_t *);
-sol_object_t *sol_f_stream_read(sol_state_t *, sol_object_t *);
+/*sol_object_t *sol_f_stream_read(sol_state_t *, sol_object_t *);*/
 sol_object_t *sol_f_stream_read_buffer(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_stream_seek(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_stream_tell(sol_state_t *, sol_object_t *);
@@ -903,6 +928,9 @@ sol_object_t *sol_f_stream_open(sol_state_t *, sol_object_t *);
 #define sol_is_buffer(obj) ((obj)->type == SOL_BUFFER)
 #define sol_is_cdata(obj) ((obj)->type == SOL_CDATA)
 
+#define sol_is_name(obj) (sol_is_string(obj) || sol_is_buffer(obj))
+#define sol_name_eq(state, obj, cstr) (sol_is_string(obj) ? sol_string_eq((state), (obj), (cstr)) : (sol_is_buffer(obj) ? sol_buffer_eq((state), (obj), (cstr)) : 0))
+
 #define sol_has_error(state) (!sol_is_none((state), (state)->error))
 
 /** Creates a new singlet object with the specified name (or NULL).
@@ -1064,6 +1092,11 @@ sol_object_t *sol_new_cfunc(sol_state_t *, sol_cfunc_t, char *);
 sol_object_t *sol_new_cdata(sol_state_t *, void *, sol_ops_t *);
 
 sol_object_t *sol_new_buffer(sol_state_t *, void *, ssize_t, sol_owntype_t, sol_freefunc_t, sol_movefunc_t);
+int sol_buffer_cmp(sol_state_t *, sol_object_t *, const char *);
+#define sol_buffer_eq(state, buffer, cstr) (sol_buffer_cmp((state), (buffer), (cstr)) == 0)
+sol_object_t *sol_buffer_concat(sol_state_t *, sol_object_t *, sol_object_t *);
+sol_object_t *sol_buffer_concat_cstr(sol_state_t *, sol_object_t *, char *);
+char *sol_buffer_strdup(sol_object_t *);
 
 sol_object_t *sol_new_dylib(sol_state_t *, void *);
 
@@ -1099,6 +1132,7 @@ sol_object_t *sol_cast_int(sol_state_t *, sol_object_t *);
 sol_object_t *sol_cast_float(sol_state_t *, sol_object_t *);
 sol_object_t *sol_cast_string(sol_state_t *, sol_object_t *);
 sol_object_t *sol_cast_repr(sol_state_t *, sol_object_t *);
+sol_object_t *sol_cast_buffer(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_singlet_free(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_free(sol_state_t *, sol_object_t *);

state.c

@@ -79,6 +79,7 @@ int sol_state_init(sol_state_t *state) {
 
 	state->SingletOps.tname = "singlet";
 	state->SingletOps.tostring = sol_f_singlet_tostring;
+	state->SingletOps.tobuffer = sol_f_singlet_tobuffer;
 	state->SingletOps.free = sol_f_singlet_free;
 
 	state->IntOps.tname = "int";
@@ -119,6 +120,7 @@ int sol_state_init(sol_state_t *state) {
 	state->StringOps.toint = sol_f_str_toint;
 	state->StringOps.tofloat = sol_f_str_tofloat;
 	state->StringOps.tostring = sol_f_str_tostring;
+	state->StringOps.tobuffer = sol_f_str_tobuffer;
 	state->StringOps.repr = sol_f_str_repr;
 	state->StringOps.free = sol_f_str_free;
 
@@ -169,8 +171,17 @@ int sol_state_init(sol_state_t *state) {
 	state->ASTNodeOps.free = sol_f_astnode_free;
 
 	state->BufferOps.tname = "buffer";
+	state->BufferOps.add = sol_f_buffer_add;
+	state->BufferOps.mul = sol_f_buffer_mul;
+	state->BufferOps.cmp = sol_f_buffer_cmp;
+	state->BufferOps.len = sol_f_buffer_len;
+	state->BufferOps.iter = sol_f_buffer_iter;
 	state->BufferOps.index = sol_f_buffer_index;
 	state->BufferOps.tostring = sol_f_buffer_tostring;
+	state->BufferOps.repr = sol_f_buffer_repr;
+	state->BufferOps.toint = sol_f_buffer_toint;
+	state->BufferOps.tofloat = sol_f_buffer_tofloat;
+	state->BufferOps.tobuffer = sol_f_buffer_tobuffer;
 	state->BufferOps.free = sol_f_buffer_free;
 
 	state->DyLibOps.tname = "dylib";
@@ -242,6 +253,7 @@ int sol_state_init(sol_state_t *state) {
 	sol_map_borrow_name(state, globals, "toint", sol_new_cfunc(state, sol_f_toint, "toint"));
 	sol_map_borrow_name(state, globals, "tofloat", sol_new_cfunc(state, sol_f_tofloat, "tofloat"));
 	sol_map_borrow_name(state, globals, "tostring", sol_new_cfunc(state, sol_f_tostring, "tostring"));
+	sol_map_borrow_name(state, globals, "tobuffer", sol_new_cfunc(state, sol_f_tobuffer, "tobuffer"));
 	sol_map_borrow_name(state, globals, "try", sol_new_cfunc(state, sol_f_try, "try"));
 	sol_map_borrow_name(state, globals, "apply", sol_new_cfunc(state, sol_f_apply, "apply"));
 	sol_map_borrow_name(state, globals, "error", sol_new_cfunc(state, sol_f_error, "error"));
@@ -265,17 +277,21 @@ int sol_state_init(sol_state_t *state) {
 	sol_map_borrow_name(state, mod, "globals", sol_new_cfunc(state, sol_f_debug_globals, "debug.globals"));
 	sol_map_borrow_name(state, mod, "locals", sol_new_cfunc(state, sol_f_debug_locals, "debug.locals"));
 	sol_map_borrow_name(state, mod, "scopes", sol_new_cfunc(state, sol_f_debug_scopes, "debug.scopes"));
-	sol_map_borrow_name(state, mod, "version", sol_new_string(state, SOL_VERSION));
+	sol_map_borrow_name(state, mod, "version", sol_new_buffer(state, SOL_VERSION, strlen(SOL_VERSION), OWN_NONE, NULL, NULL));
 	sol_map_borrow_name(state, mod, "hexversion", sol_new_int(state, SOL_HEXVER));
 #ifdef SOL_ICACHE
 	sol_map_borrow_name(state, mod, "icache_min", sol_new_int(state, SOL_ICACHE_MIN));
 	sol_map_borrow_name(state, mod, "icache_max", sol_new_int(state, SOL_ICACHE_MAX));
 #endif
+	sol_map_borrow_name(state, mod, "modules", state->modules);
+	sol_map_borrow_name(state, mod, "methods", state->methods);
+	sol_map_borrow_name(state, mod, "getops", sol_new_cfunc(state, sol_f_debug_getops, "debug.getops"));
 	sol_register_module_name(state, "debug", mod);
 	sol_obj_free(mod);
 
 	mod = sol_new_map(state);
 	sol_map_borrow_name(state, mod, "str", sol_new_cfunc(state, sol_f_iter_str, "iter.str"));
+	sol_map_borrow_name(state, mod, "buffer", sol_new_cfunc(state, sol_f_iter_buffer, "iter.buffer"));
 	sol_map_borrow_name(state, mod, "list", sol_new_cfunc(state, sol_f_iter_list, "iter.list"));
 	sol_map_borrow_name(state, mod, "map", sol_new_cfunc(state, sol_f_iter_map, "iter.map"));
 	sol_register_module_name(state, "iter", mod);
@@ -426,8 +442,8 @@ int sol_state_init(sol_state_t *state) {
 	sol_map_borrow_name(state, mod, "SEEK_SET", sol_new_int(state, SEEK_SET));
 	sol_map_borrow_name(state, mod, "SEEK_CUR", sol_new_int(state, SEEK_CUR));
 	sol_map_borrow_name(state, mod, "SEEK_END", sol_new_int(state, SEEK_END));
-	sol_map_borrow_name(state, mod, "ALL", sol_new_string(state, "ALL"));
-	sol_map_borrow_name(state, mod, "LINE", sol_new_string(state, "LINE"));
+	sol_map_borrow_name(state, mod, "ALL", sol_new_buffer(state, "ALL", 3, OWN_NONE, NULL, NULL));
+	sol_map_borrow_name(state, mod, "LINE", sol_new_buffer(state, "LINE", 4, OWN_NONE, NULL, NULL));
 	sol_map_borrow_name(state, mod, "TIOCGWINSZ", sol_new_int(state, TIOCGWINSZ));
 	sol_map_borrow_name(state, mod, "TIOCSWINSZ", sol_new_int(state, TIOCSWINSZ));
 	sol_map_borrow_name(state, mod, "open", sol_new_cfunc(state, sol_f_stream_open, "io.open"));
@@ -441,6 +457,9 @@ int sol_state_init(sol_state_t *state) {
 	sol_map_borrow_name(state, meths, "set", sol_new_cfunc(state, sol_f_buffer_set, "buffer.set"));
 	sol_map_borrow_name(state, meths, "address", sol_new_cfunc(state, sol_f_buffer_address, "buffer.address"));
 	sol_map_borrow_name(state, meths, "size", sol_new_cfunc(state, sol_f_buffer_size, "buffer.size"));
+	sol_map_borrow_name(state, meths, "sub", sol_new_cfunc(state, sol_f_buffer_sub, "buffer.sub"));
+	sol_map_borrow_name(state, meths, "split", sol_new_cfunc(state, sol_f_buffer_split, "buffer.split"));
+	sol_map_borrow_name(state, meths, "find", sol_new_cfunc(state, sol_f_buffer_find, "buffer.find"));
 	sol_register_methods_name(state, "buffer", meths);
 	sol_obj_free(meths);
 
@@ -456,7 +475,7 @@ int sol_state_init(sol_state_t *state) {
 	sol_obj_free(meths);
 
 	meths = sol_new_map(state);
-	sol_map_borrow_name(state, meths, "read", sol_new_cfunc(state, sol_f_stream_read, "stream.read"));
+	sol_map_borrow_name(state, meths, "read", sol_new_cfunc(state, sol_f_stream_read_buffer, "stream.read_buffer"));
 	sol_map_borrow_name(state, meths, "read_buffer", sol_new_cfunc(state, sol_f_stream_read_buffer, "stream.read_buffer"));
 	sol_map_borrow_name(state, meths, "write", sol_new_cfunc(state, sol_f_stream_write, "stream.write"));
 	sol_map_borrow_name(state, meths, "seek", sol_new_cfunc(state, sol_f_stream_seek, "stream.seek"));
@@ -604,7 +623,7 @@ sol_object_t *sol_state_resolve(sol_state_t *state, sol_object_t *key) {
 }
 
 sol_object_t *sol_state_resolve_name(sol_state_t *state, const char *name) {
-	sol_object_t *key = sol_new_string(state, name), *temp;
+	sol_object_t *key = sol_new_buffer(state, (char *) name, strlen(name), OWN_NONE, NULL, NULL), *temp;
 
 	if(sol_has_error(state)) {
 		return sol_incref(state->None);
@@ -639,7 +658,7 @@ void sol_state_assign(sol_state_t *state, sol_object_t *key, sol_object_t *val)
 }
 
 void sol_state_assign_name(sol_state_t *state, const char *name, sol_object_t *val) {
-	sol_object_t *key = sol_new_string(state, name);
+	sol_object_t *key = sol_new_buffer(state, (char *) name, strlen(name), OWN_NONE, NULL, NULL);
 
 	if(sol_has_error(state)) {
 		return;
@@ -668,7 +687,7 @@ void sol_state_assign_l(sol_state_t *state, sol_object_t *key, sol_object_t *val
 }
 
 void sol_state_assign_l_name(sol_state_t *state, const char *name, sol_object_t *val) {
-	sol_object_t *key = sol_new_string(state, name);
+	sol_object_t *key = sol_new_buffer(state, (char *) name, strlen(name), OWN_NONE, NULL, NULL);
 
 	if(sol_has_error(state)) {
 		return;
@@ -697,9 +716,10 @@ sol_object_t *sol_set_error(sol_state_t *state, sol_object_t *err) {
 }
 
 sol_object_t *sol_set_error_string(sol_state_t *state, const char *serr) {
-	sol_object_t *err = sol_new_string(state, serr), *res;
+	sol_object_t *err = sol_new_buffer(state, strdup(serr), strlen(serr), OWN_FREE, NULL, NULL), *res;
 
 	if(sol_has_error(state)) {
+		sol_obj_free(err);
 		return sol_incref(state->None);
 	}
 
@@ -866,6 +886,7 @@ void sol_ops_init(sol_ops_t *ops) {
 	ops->toint = sol_f_not_impl;
 	ops->tofloat = sol_f_not_impl;
 	ops->tostring = sol_f_default_tostring;
+	ops->tobuffer = sol_f_default_tobuffer;
 	ops->repr = sol_f_default_repr;
 	ops->init = sol_f_no_op;
 	ops->free = sol_f_no_op;

tests/crasher_init_comma.sol

@@ -0,0 +1,9 @@
+execfile("tests/_lib.sol")
+
+assert_eq([0], [,,,,0], "initial comma in list")
+d = {,,a=7}
+assert_eq(d.a, 7, "initial comma in map")
+
+ident = lambda(,x) x end
+
+assert_eq("hi", ident(,"hi"), "initial comma in funcdecl/call")

tokenizer.lex

@@ -88,9 +88,8 @@ IDENT [a-zA-Z_][a-zA-Z0-9_]*
 
 {DIGIT}+ { *yylval = malloc(sizeof(long)); *((long *) *yylval) = atol(yytext); return INT; }
 
-\"[^"]*\" { *yylval = strdup(yytext+1); ((char *) *yylval)[yyleng-2] = 0; return STRING; }
-
-\'[^']*\' { *yylval = strdup(yytext+1); ((char *) *yylval)[yyleng-2] = 0; return STRING; }
+\"[^"]*\"	|
+\'[^']*\' { *yylval = malloc(sizeof(unsigned long) + (yyleng - 2) * sizeof(char)); *((unsigned long *) *yylval) = yyleng - 2; memcpy(((char *) *yylval) + sizeof(unsigned long), yytext + 1, yyleng - 2); return STRING; }
 
 if { return IF; }