Sol Part 5: Kid Tested, Mother Approved!

ast.h

@@ -21,7 +21,7 @@ typedef struct {
 	};
 } lit_node;
 
-typedef enum {OP_ADD, OP_SUB, OP_MUL, OP_DIV, OP_POW, OP_BAND, OP_BOR, OP_BXOR, OP_LAND, OP_LOR, OP_EQUAL, OP_LESS, OP_GREATER, OP_LESSEQ, OP_GREATEREQ} binop_t;
+typedef enum {OP_ADD, OP_SUB, OP_MUL, OP_DIV, OP_POW, OP_BAND, OP_BOR, OP_BXOR, OP_LAND, OP_LOR, OP_EQUAL, OP_LESS, OP_GREATER, OP_LESSEQ, OP_GREATEREQ, OP_LSHIFT, OP_RSHIFT} binop_t;
 typedef struct {
 	binop_t type;
 	expr_node *left;

astprint.c

@@ -198,6 +198,14 @@ void prex(expr_node *node, int lev) {
 				case OP_GREATEREQ:
 					prlev(lev, "Op: >=");
 					break;
+					
+				case OP_LSHIFT:
+					prlev(lev, "Op: <<");
+					break;
+					
+				case OP_RSHIFT:
+					prlev(lev, "Op: >>");
+					break;
 			}
 			prlev(lev, "Left:");
 			prex(node->binop->left, lev+1);

builtins.c

@@ -70,20 +70,20 @@ sol_object_t *sol_f_try(sol_state_t *state, sol_object_t *args) {
 		sol_obj_free(res);
 		sol_obj_free(one);
 		sol_clear_error(state);
-		sol_list_insert(state, &ls, 0, err);
+		sol_list_insert(state, ls, 0, err);
 		sol_obj_free(err);
-		sol_list_insert(state, &ls, 0, zero);
+		sol_list_insert(state, ls, 0, zero);
 		sol_obj_free(zero);
 		return ls;
 	}
-	sol_list_insert(state, &ls, 0, res);
+	sol_list_insert(state, ls, 0, res);
 	sol_obj_free(res);
-	sol_list_insert(state, &ls, 0, one);
+	sol_list_insert(state, ls, 0, one);
 	sol_obj_free(one);
 	return ls;
 }
 
-static char *sol_TypeNames[] = {"singlet", "integer", "float", "string", "list", "map", "function", "cfunction", "cdata"};
+static char *sol_TypeNames[] = {"singlet", "integer", "float", "string", "list", "listcell", "map", "mapcell", "function", "cfunction", "cdata"};
 
 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);
@@ -92,8 +92,21 @@ sol_object_t *sol_f_type(sol_state_t *state, sol_object_t *args) {
     return res;
 }
 
+sol_object_t *p_seen[1024] = {0};
+
 void ob_print(sol_object_t *obj) {
     sol_object_t *cur;
+	int i;
+	for(i=0; i<1024; i++) {
+		if(!p_seen[i]) {
+			p_seen[i] = obj;
+			break;
+		}
+		if(p_seen[i] == obj) {
+			printf("... (%p)", obj);
+			return;
+		}
+	}
     switch(obj->type) {
         case SOL_SINGLET:
             printf("<Singlet>");
@@ -110,6 +123,10 @@ void ob_print(sol_object_t *obj) {
         case SOL_STRING:
             printf("\"%s\"", obj->str);
             break;
+			
+		case SOL_LCELL:
+			printf("<<");
+			/* fall through */
 
         case SOL_LIST:
             printf("[");
@@ -125,6 +142,10 @@ void ob_print(sol_object_t *obj) {
             }
             printf("]");
             break;
+			
+		case SOL_MCELL:
+			printf("<<");
+			/* fall through */
 
         case SOL_MAP:
             printf("{");
@@ -161,13 +182,170 @@ void ob_print(sol_object_t *obj) {
 }
 
 sol_object_t *sol_f_prepr(sol_state_t *state, sol_object_t *args) {
-    sol_object_t *obj = sol_list_get_index(state, args, 0);
-    ob_print(obj);
-    printf("\n");
-    sol_obj_free(obj);
+	int i, sz = sol_list_len(state, args);
+    sol_object_t *obj;
+	for(i=0; i<1024; i++) p_seen[i] = NULL;
+	for(i=0; i<sz; i++) {
+		obj = sol_list_get_index(state, args, i);
+		ob_print(obj);
+		printf(" ");
+		sol_obj_free(obj);
+	}
+	printf("\n");
+    return sol_incref(state->None);
+}
+
+sol_object_t *sol_f_print(sol_state_t *state, sol_object_t *args) {
+	int i, sz = sol_list_len(state, args);
+    sol_object_t *obj;
+	for(i=0; i<1024; i++) p_seen[i] = NULL;
+	for(i=0; i<sz; i++) {
+		obj = sol_list_get_index(state, args, i);
+		if(sol_is_string(obj)) {
+			printf("%s", obj->str);
+		} else {
+			ob_print(obj);
+		}
+		printf(" ");
+		sol_obj_free(obj);
+	}
+	printf("\n");
     return sol_incref(state->None);
 }
 
+sol_object_t *sol_f_rawget(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *key, *res;
+	if(!sol_is_map(obj)) return sol_set_error_string(state, "Rawset of non-map");
+	key = sol_list_get_index(state, args, 1);
+	res = sol_map_get(state, obj, key);
+	sol_obj_free(key);
+	sol_obj_free(obj);
+	return sol_incref(state->None);
+}
+
+
+sol_object_t *sol_f_rawset(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *key, *val;
+	if(!sol_is_map(obj)) return sol_set_error_string(state, "Rawset of non-map");
+	key = sol_list_get_index(state, args, 1);
+	val = sol_list_get_index(state, args, 2);
+	sol_map_set(state, obj, key, val);
+	sol_obj_free(val);
+	sol_obj_free(key);
+	sol_obj_free(obj);
+	return sol_incref(state->None);
+}
+
+sol_object_t *sol_f_range(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *res = sol_new_list(state), *bound = sol_cast_int(state, sol_list_get_index(state, args, 0));
+	int i;
+	for(i=0; i<bound->ival; i++) {
+		sol_list_insert(state, res, sol_list_len(state, res), sol_new_int(state, i));
+	}
+	sol_obj_free(bound);
+	return res;
+}
+
+sol_object_t *sol_f_debug_getref(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_int(state, obj->refcnt - 2); // NB: We grabbed a reference, and there's one in the arglist, so account for them.
+	sol_obj_free(obj);
+	return res;
+}
+
+sol_object_t *sol_f_debug_setref(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0), *cnt = sol_list_get_index(state, args, 1);
+	obj->refcnt = sol_cast_int(state, cnt)->ival + 2; // NB: As above.
+	sol_obj_free(cnt);
+	sol_obj_free(obj);
+	return sol_incref(state->None);
+}
+
+sol_object_t *sol_f_debug_closure(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *func = sol_list_get_index(state, args, 0);
+	sol_object_t *res = sol_incref(func->closure);
+	sol_obj_free(func);
+	return res;
+}
+
+sol_object_t *sol_f_debug_globals(sol_state_t *state, sol_object_t *args) {
+	return sol_list_get_index(state, state->scopes, sol_list_len(state, state->scopes)-1);
+}
+
+sol_object_t *sol_f_debug_locals(sol_state_t *state, sol_object_t *args) {
+	return sol_list_get_index(state, state->scopes, 0);
+}
+
+sol_object_t *sol_f_iter_str(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;
+	char temp[2] = {0, 0};
+	if(sol_is_none(state, index)) {
+		sol_obj_free(index);
+		index = sol_new_int(state, 0);
+		sol_map_set_name(state, local, "idx", index);
+	}
+	if(index->ival >= strlen(obj->str)) {
+		sol_obj_free(index);
+		sol_obj_free(obj);
+		sol_obj_free(local);
+		return sol_incref(state->StopIteration);
+	}
+	temp[0] = obj->str[index->ival];
+	res = sol_new_string(state, temp);
+	index->ival++;
+	sol_obj_free(index);
+	sol_obj_free(local);
+	sol_obj_free(obj);
+	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;
+	if(sol_is_none(state, index)) {
+		sol_obj_free(index);
+		index = sol_new_int(state, 0);
+		sol_map_set_name(state, local, "idx", index);
+	}
+	if(index->ival >= sol_list_len(state, obj)) {
+		sol_obj_free(index);
+		sol_obj_free(obj);
+		sol_obj_free(local);
+		return sol_incref(state->StopIteration);
+	}
+	res = sol_list_get_index(state, obj, index->ival);
+	index->ival++;
+	sol_obj_free(index);
+	sol_obj_free(local);
+	sol_obj_free(obj);
+	return res;
+}
+
+sol_object_t *sol_f_iter_map(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;
+	if(sol_is_none(state, index)) {
+		sol_obj_free(index);
+		index = obj;
+		sol_map_set_name(state, local, "idx", index);
+	}
+	while(index && !index->mkey) index = index->mnext;
+	if(!index || !index->mnext) {
+		sol_obj_free(index);
+		sol_obj_free(obj);
+		sol_obj_free(local);
+		return sol_incref(state->StopIteration);
+	}
+	res = sol_incref(index->mkey);
+	index = index->mnext;
+	sol_map_set_name(state, local, "idx", index);
+	sol_obj_free(index);
+	sol_obj_free(local);
+	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_cast_int(state, sol_list_get_index(state, args, 1));
 	sol_object_t *res = sol_new_int(state, a->ival + b->ival);
@@ -240,6 +418,24 @@ sol_object_t *sol_f_int_bxor(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_int_blsh(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_cast_int(state, sol_list_get_index(state, args, 1));
+	sol_object_t *res = sol_new_int(state, a->ival << b->ival);
+	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_int_brsh(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_cast_int(state, sol_list_get_index(state, args, 1));
+	sol_object_t *res = sol_new_int(state, a->ival >> b->ival);
+	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_int_bnot(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->ival);
@@ -390,6 +586,10 @@ sol_object_t *sol_f_str_len(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_str_iter(sol_state_t *state, sol_object_t *args) {
+	return sol_new_cfunc(state, sol_f_iter_str);
+}
+
 sol_object_t *sol_f_str_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->str));
@@ -467,6 +667,10 @@ sol_object_t *sol_f_list_len(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_list_iter(sol_state_t *state, sol_object_t *args) {
+	return sol_new_cfunc(state, sol_f_iter_list);
+}
+
 sol_object_t *sol_f_list_tostring(sol_state_t *state, sol_object_t *args) {
 	return sol_new_string(state, "<List>");
 }
@@ -487,7 +691,21 @@ sol_object_t *sol_f_map_add(sol_state_t *state, sol_object_t *args) {
 
 sol_object_t *sol_f_map_index(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *map = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1);
-	sol_object_t *res = sol_map_get(state, map, b);
+	sol_object_t *indexf = sol_map_get_name(state, map, "__index");
+	sol_object_t *res = NULL, *newls;
+	if(!sol_is_none(state, indexf)) {
+		if(indexf->ops->call && indexf->ops->call != sol_f_not_impl) {
+			newls = sol_new_list(state);
+			sol_list_insert(state, newls, 0, indexf);
+			sol_list_append(state, newls, args);
+			res = indexf->ops->call(state, newls);
+			sol_obj_free(newls);
+		} else if(indexf->ops->index && indexf->ops->index != sol_f_not_impl) {
+			res = indexf->ops->index(state, args);
+		}
+	}
+	if(!res) res = sol_map_get(state, map, b);
+	sol_obj_free(indexf);
 	sol_obj_free(map);
 	sol_obj_free(b);
 	return res;
@@ -496,6 +714,21 @@ sol_object_t *sol_f_map_index(sol_state_t *state, sol_object_t *args) {
 sol_object_t *sol_f_map_setindex(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *map = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1);
 	sol_object_t *val = sol_list_get_index(state, args, 2);
+	sol_object_t *setindexf = sol_map_get_name(state, map, "__setindex"), *newls;
+	if(!sol_is_none(state, setindexf)) {
+		if(setindexf->ops->call && setindexf->ops->call != sol_f_not_impl) {
+			newls = sol_new_list(state);
+			sol_list_insert(state, newls, 0, setindexf);
+			sol_list_append(state, newls, args);
+			sol_obj_free(setindexf->ops->call(state, newls));
+			sol_obj_free(newls);
+			return sol_incref(state->None);
+		} else if(setindexf->ops->setindex && setindexf->ops->setindex != sol_f_not_impl) {
+			setindexf->ops->setindex(state, args);
+			return sol_incref(state->None);
+		}
+	}
+	sol_obj_free(setindexf);
 	sol_map_set(state, map, b, val);
 	sol_obj_free(map);
 	sol_obj_free(b);
@@ -503,6 +736,23 @@ sol_object_t *sol_f_map_setindex(sol_state_t *state, sol_object_t *args) {
 	return sol_incref(state->None);
 }
 
+sol_object_t *sol_f_map_call(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *map = sol_list_get_index(state, args, 0), *fargs = sol_list_sublist(state, args, 1);
+	sol_object_t *callf = sol_map_get_name(state, map, "__call"), *res = NULL;
+	if(!sol_is_none(state, callf)) {
+		if(callf->ops->call) {
+			sol_list_insert(state, fargs, 0, callf);
+			sol_list_insert(state, fargs, 1, map);
+			res = callf->ops->call(state, fargs);
+		}
+	}
+	sol_obj_free(map);
+	sol_obj_free(fargs);
+	sol_obj_free(callf);
+	if(res) return res;
+	return sol_set_error_string(state, "Call map without call method");
+}
+
 sol_object_t *sol_f_map_len(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *map = sol_list_get_index(state, args, 0);
 	sol_object_t *res = sol_new_int(state, sol_map_len(state, map));
@@ -510,10 +760,31 @@ sol_object_t *sol_f_map_len(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_map_iter(sol_state_t *state, sol_object_t *args) {
+	return sol_new_cfunc(state, sol_f_iter_map);
+}
+
 sol_object_t *sol_f_map_tostring(sol_state_t *state, sol_object_t *args) {
 	return sol_new_string(state, "<Map>");
 }
 
+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;
+	res = sol_map_get(state, func->closure, key);
+	sol_obj_free(func);
+	sol_obj_free(key);
+	return res;
+}
+
+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);
+	sol_map_set(state, func->closure, key, val);
+	sol_obj_free(func);
+	sol_obj_free(key);
+	sol_obj_free(val);
+	return sol_incref(state->None);
+}
+
 sol_object_t *sol_f_func_tostring(sol_state_t *state, sol_object_t *args) {
 	return sol_new_string(state, "<Function>");
 }

dsdebug.gdb

@@ -1,7 +1,4 @@
-break object.c:265
-  condition $bpnum sol_validate_list(state, *list)
-break object.c:294
-  condition $bpnum sol_validate_list(state, *list)
-break object.c:183
-  condition $bpnum sol_validate_list(state, list)
-watch state->error
+break object.c:277
+  condition $bpnum sol_validate_list(list)
+break object.c:304
+  condition $bpnum sol_validate_list(list)

lex.yy.c

@@ -368,8 +368,8 @@ static void yy_fatal_error (yyconst char msg[]  );
 	*yy_cp = '\0'; \
 	(yy_c_buf_p) = yy_cp;
 
-#define YY_NUM_RULES 58
-#define YY_END_OF_BUFFER 59
+#define YY_NUM_RULES 60
+#define YY_END_OF_BUFFER 61
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -377,20 +377,20 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static yyconst flex_int16_t yy_accept[109] =
+static yyconst flex_int16_t yy_accept[111] =
     {   0,
-        0,    0,   59,   58,   57,   29,   58,   54,   23,   58,
-       48,   49,   20,   18,   53,   19,   50,   21,    2,   51,
-       52,   40,   30,   41,   55,   55,   46,   47,   25,   55,
-       55,   55,   55,   55,   55,   55,   55,   55,   44,   24,
-       45,   26,   57,    0,    3,   27,   36,    0,    4,   22,
-       33,   31,    0,   32,   34,    1,    2,   42,   39,   43,
-       55,   55,   38,   55,   55,   11,   55,   55,   55,   55,
-        5,   10,   55,   55,   55,   37,   28,   35,    0,   56,
-        1,   55,   55,   55,   55,   16,    9,   55,   55,   55,
-       55,   17,   55,   55,    7,   12,   55,    6,   55,   14,
-
-       55,   55,    8,   55,   13,   55,   15,    0
+        0,    0,   61,   60,   59,   29,   60,   56,   23,   60,
+       50,   51,   20,   18,   55,   19,   52,   21,    2,   53,
+       54,   40,   30,   41,   57,   57,   48,   49,   25,   57,
+       57,   57,   57,   57,   57,   57,   57,   57,   46,   24,
+       47,   26,   59,    0,    3,   27,   36,    0,    4,   22,
+       33,   31,    0,   32,   34,    1,    2,   45,   42,   39,
+       43,   44,   57,   57,   38,   57,   57,   11,   57,   57,
+       57,   57,    5,   10,   57,   57,   57,   37,   28,   35,
+        0,   58,    1,   57,   57,   57,   57,   16,    9,   57,
+       57,   57,   57,   17,   57,   57,    7,   12,   57,    6,
+
+       57,   14,   57,   57,    8,   57,   13,   57,   15,    0
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
@@ -434,84 +434,84 @@ static yyconst flex_int32_t yy_meta[49] =
         2,    2,    2,    2,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int16_t yy_base[113] =
+static yyconst flex_int16_t yy_base[115] =
     {   0,
-        0,    0,  126,  127,   47,  127,  120,  127,   44,  116,
-      127,  127,   41,  102,  127,   39,  127,  101,   39,  127,
-      127,  100,   99,   98,    0,   79,  127,  127,   96,   76,
-       76,   75,   20,   16,   28,   81,   78,   77,  127,   42,
-      127,  127,   65,  105,  127,  127,  127,  101,  127,   87,
-      127,  127,  104,  127,  127,   89,   54,  127,  127,  127,
-        0,   67,  127,   72,   65,    0,   61,   70,   60,   61,
-        0,    0,   56,   65,   61,  127,  127,  127,   92,  127,
-       70,   54,   57,   42,   51,    0,    0,   52,   38,   42,
-       42,    0,   42,   42,    0,    0,   36,    0,   43,    0,
-
-       36,   35,    0,   29,    0,   38,    0,  127,   88,   90,
-       62,   92
+        0,    0,  128,  129,   47,  129,  122,  129,   44,  118,
+      129,  129,   41,  104,  129,   39,  129,  103,   39,  129,
+      129,   37,  102,   42,    0,   83,  129,  129,  100,   80,
+       80,   79,   29,   16,   35,   85,   82,   81,  129,   40,
+      129,  129,   67,  109,  129,  129,  129,  105,  129,   91,
+      129,  129,  108,  129,  129,   93,   57,  129,  129,  129,
+      129,  129,    0,   71,  129,   76,   69,    0,   65,   74,
+       64,   65,    0,    0,   60,   69,   65,  129,  129,  129,
+       96,  129,   81,   65,   68,   53,   62,    0,    0,   63,
+       42,   46,   46,    0,   46,   46,    0,    0,   40,    0,
+
+       47,    0,   40,   39,    0,   33,    0,   43,    0,  129,
+       86,   88,   69,   90
     } ;
 
-static yyconst flex_int16_t yy_def[113] =
+static yyconst flex_int16_t yy_def[115] =
     {   0,
-      108,    1,  108,  108,  108,  108,  109,  108,  108,  110,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  111,  111,  108,  108,  108,  111,
-      111,  111,  111,  111,  111,  111,  111,  111,  108,  108,
-      108,  108,  108,  109,  108,  108,  108,  110,  108,  108,
-      108,  108,  112,  108,  108,  108,  108,  108,  108,  108,
-      111,  111,  108,  111,  111,  111,  111,  111,  111,  111,
-      111,  111,  111,  111,  111,  108,  108,  108,  112,  108,
-      108,  111,  111,  111,  111,  111,  111,  111,  111,  111,
-      111,  111,  111,  111,  111,  111,  111,  111,  111,  111,
-
-      111,  111,  111,  111,  111,  111,  111,    0,  108,  108,
-      108,  108
+      110,    1,  110,  110,  110,  110,  111,  110,  110,  112,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  113,  113,  110,  110,  110,  113,
+      113,  113,  113,  113,  113,  113,  113,  113,  110,  110,
+      110,  110,  110,  111,  110,  110,  110,  112,  110,  110,
+      110,  110,  114,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  113,  113,  110,  113,  113,  113,  113,  113,
+      113,  113,  113,  113,  113,  113,  113,  110,  110,  110,
+      114,  110,  110,  113,  113,  113,  113,  113,  113,  113,
+      113,  113,  113,  113,  113,  113,  113,  113,  113,  113,
+
+      113,  113,  113,  113,  113,  113,  113,  113,  113,    0,
+      110,  110,  110,  110
     } ;
 
-static yyconst flex_int16_t yy_nxt[176] =
+static yyconst flex_int16_t yy_nxt[178] =
     {   0,
         4,    5,    5,    6,    7,    8,    9,   10,   11,   12,
        13,   14,   15,   16,   17,   18,   19,   20,   21,   22,
        23,   24,   25,   26,   27,   28,   29,   25,   30,   31,
        32,   33,   34,   25,   35,   25,   25,   25,   25,   36,
        25,   37,   25,   38,   39,   40,   41,   42,   43,   43,
-       46,   50,   53,   56,   69,   57,   67,   68,   70,   54,
-       71,   51,   76,   61,   47,   72,   43,   43,   56,  107,
-       57,  106,  105,  104,  103,  102,  101,  100,   99,   98,
-       97,   96,   95,   94,   93,   92,   81,   77,   44,   44,
-       48,   48,   79,   79,   80,   91,   90,   89,   88,   87,
-
-       86,   85,   84,   83,   82,   81,   80,   78,   49,   45,
-       75,   74,   73,   66,   65,   64,   63,   62,   60,   59,
-       58,   55,   52,   49,   45,  108,    3,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108
+       46,   50,   53,   56,   71,   57,   58,   59,   72,   54,
+       78,   51,   61,   62,   47,   69,   70,   73,   43,   43,
+       63,   56,   74,   57,  109,  108,  107,  106,  105,  104,
+      103,  102,  101,  100,   99,   79,   44,   44,   48,   48,
+       81,   81,   98,   97,   96,   95,   94,   83,   82,   93,
+
+       92,   91,   90,   89,   88,   87,   86,   85,   84,   83,
+       82,   80,   49,   45,   77,   76,   75,   68,   67,   66,
+       65,   64,   60,   55,   52,   49,   45,  110,    3,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110
     } ;
 
-static yyconst flex_int16_t yy_chk[176] =
+static yyconst flex_int16_t yy_chk[178] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    5,    5,
-        9,   13,   16,   19,   34,   19,   33,   33,   34,   16,
-       35,   13,   40,  111,    9,   35,   43,   43,   57,  106,
-       57,  104,  102,  101,   99,   97,   94,   93,   91,   90,
-       89,   88,   85,   84,   83,   82,   81,   40,  109,  109,
-      110,  110,  112,  112,   79,   75,   74,   73,   70,   69,
-
-       68,   67,   65,   64,   62,   56,   53,   50,   48,   44,
-       38,   37,   36,   32,   31,   30,   29,   26,   24,   23,
-       22,   18,   14,   10,    7,    3,  108,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  108,  108,  108
+        9,   13,   16,   19,   34,   19,   22,   22,   34,   16,
+       40,   13,   24,   24,    9,   33,   33,   35,   43,   43,
+      113,   57,   35,   57,  108,  106,  104,  103,  101,   99,
+       96,   95,   93,   92,   91,   40,  111,  111,  112,  112,
+      114,  114,   90,   87,   86,   85,   84,   83,   81,   77,
+
+       76,   75,   72,   71,   70,   69,   67,   66,   64,   56,
+       53,   50,   48,   44,   38,   37,   36,   32,   31,   30,
+       29,   26,   23,   18,   14,   10,    7,    3,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110
     } ;
 
 static yy_state_type yy_last_accepting_state;
@@ -820,13 +820,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 109 )
+				if ( yy_current_state >= 111 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 127 );
+		while ( yy_base[yy_current_state] != 129 );
 
 yy_find_action:
 		yy_act = yy_accept[yy_current_state];
@@ -1070,81 +1070,91 @@ YY_RULE_SETUP
 case 44:
 YY_RULE_SETUP
 #line 145 "tokenizer.lex"
-{ return LBRACE; }
+{ return RSHIFT; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
 #line 147 "tokenizer.lex"
-{ return RBRACE; }
+{ return LSHIFT; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
 #line 149 "tokenizer.lex"
-{ return LBRACKET; }
+{ return LBRACE; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
 #line 151 "tokenizer.lex"
-{ return RBRACKET; }
+{ return RBRACE; }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
 #line 153 "tokenizer.lex"
-{ return LPAREN; }
+{ return LBRACKET; }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
 #line 155 "tokenizer.lex"
-{ return RPAREN; }
+{ return RBRACKET; }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
 #line 157 "tokenizer.lex"
-{ return DOT; }
+{ return LPAREN; }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
 #line 159 "tokenizer.lex"
-{ return COLON; }
+{ return RPAREN; }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
 #line 161 "tokenizer.lex"
-{ return SEMICOLON; }
+{ return DOT; }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
 #line 163 "tokenizer.lex"
-{ return COMMA; }
+{ return COLON; }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
 #line 165 "tokenizer.lex"
-{ return POUND; }
+{ return SEMICOLON; }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
 #line 167 "tokenizer.lex"
-{ yylval = strdup(yytext); return IDENT; }
+{ return COMMA; }
 	YY_BREAK
 case 56:
-/* rule 56 can match eol */
 YY_RULE_SETUP
 #line 169 "tokenizer.lex"
-/* Skip comments */
+{ return POUND; }
 	YY_BREAK
 case 57:
-/* rule 57 can match eol */
 YY_RULE_SETUP
 #line 171 "tokenizer.lex"
-/* Skip whitespace */
+{ yylval = strdup(yytext); return IDENT; }
 	YY_BREAK
 case 58:
+/* rule 58 can match eol */
 YY_RULE_SETUP
 #line 173 "tokenizer.lex"
+/* Skip comments */
+	YY_BREAK
+case 59:
+/* rule 59 can match eol */
+YY_RULE_SETUP
+#line 175 "tokenizer.lex"
+/* Skip whitespace */
+	YY_BREAK
+case 60:
+YY_RULE_SETUP
+#line 177 "tokenizer.lex"
 ECHO;
 	YY_BREAK
-#line 1148 "lex.yy.c"
+#line 1158 "lex.yy.c"
 case YY_STATE_EOF(INITIAL):
 	yyterminate();
 
@@ -1436,7 +1446,7 @@ static int yy_get_next_buffer (void)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 109 )
+			if ( yy_current_state >= 111 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -1464,11 +1474,11 @@ static int yy_get_next_buffer (void)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 109 )
+		if ( yy_current_state >= 111 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 108);
+	yy_is_jam = (yy_current_state == 110);
 
 	return yy_is_jam ? 0 : yy_current_state;
 }
@@ -2142,7 +2152,7 @@ void yyfree (void * ptr )
 
 #define YYTABLES_NAME "yytables"
 
-#line 173 "tokenizer.lex"
+#line 177 "tokenizer.lex"
 
 
 

object.c

@@ -3,12 +3,13 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <assert.h>
 
 sol_object_t *sol_cast_int(sol_state_t *state, sol_object_t *obj) {
 	sol_object_t *res, *ls;
 	if(sol_is_int(obj)) return obj;
 	ls = sol_new_list(state);
-	sol_list_insert(state, &ls, 0, obj);
+	sol_list_insert(state, ls, 0, obj);
 	res = obj->ops->toint(state, ls);
 	sol_obj_free(ls);
 	sol_obj_free(obj);
@@ -19,7 +20,7 @@ sol_object_t *sol_cast_float(sol_state_t *state, sol_object_t *obj) {
 	sol_object_t *res, *ls;
 	if(sol_is_float(obj)) return obj;
 	ls = sol_new_list(state);
-	sol_list_insert(state, &ls, 0, obj);
+	sol_list_insert(state, ls, 0, obj);
 	res = obj->ops->tofloat(state, ls);
 	sol_obj_free(ls);
 	sol_obj_free(obj);
@@ -30,7 +31,7 @@ sol_object_t *sol_cast_string(sol_state_t *state, sol_object_t *obj) {
 	sol_object_t *res, *ls;
 	if(sol_is_string(obj)) return obj;
 	ls = sol_new_list(state);
-	sol_list_insert(state, &ls, 0, obj);
+	sol_list_insert(state, ls, 0, obj);
 	res = obj->ops->tostring(state, ls);
 	sol_obj_free(ls);
 	sol_obj_free(obj);
@@ -67,8 +68,16 @@ void sol_init_object(sol_state_t *state, sol_object_t *obj) {
 }
 
 void sol_obj_free(sol_object_t *obj) {
+	if(!obj) {
+		printf("WARNING: Attempt to free NULL\n");
+		return;
+	}
 	if(sol_decref(obj) <= 0) {
-		sol_obj_release(obj);
+		if(obj->refcnt < 0) {
+			printf("WARNING: Encountered refcnt < 0!\nObject %p type %d ref %d\n", obj, obj->type, obj->refcnt);
+		} else {
+			sol_obj_release(obj);
+		}
 	}
 }
 
@@ -147,8 +156,8 @@ int sol_list_len(sol_state_t *state, sol_object_t *list) {
 		sol_obj_free(sol_set_error_string(state, "Compute length of non-list"));
 		return -1;
 	}
-	while(cur && cur->lvalue) {
-		i++;
+	while(cur) {
+		if(cur->lvalue) i++;
 		cur = cur->lnext;
 	}
 	return i;
@@ -173,8 +182,8 @@ sol_object_t *sol_list_sublist(sol_state_t *state, sol_object_t *list, int idx)
 			if(cur->lnext) {
 				copy->lnext = sol_alloc_object(state);
 				copy = copy->lnext;
-				copy->type = SOL_LIST;
-				copy->ops = &(state->ListOps);
+				copy->type = SOL_LCELL;
+				copy->ops = &(state->LCellOps);
 				copy->lnext = NULL;
 				copy->lvalue = NULL;
 			}
@@ -193,11 +202,12 @@ sol_object_t *sol_list_get_index(sol_state_t *state, sol_object_t *list, int idx
 	if(idx < 0) {
 		return sol_set_error_string(state, "Get negative index");
 	}
-	while(cur && cur->lvalue && i < idx) {
-		i++;
+	while(cur && i < idx) {
+		if(cur->lvalue) i++;
 		cur = cur->lnext;
 	}
-	if(cur && cur->lvalue) {
+	while(cur && !cur->lvalue) cur = cur->lnext;
+	if(cur) {
 		return sol_incref(cur->lvalue);
 	} else {
 		return sol_set_error_string(state, "Get out-of-bounds index");
@@ -205,7 +215,7 @@ sol_object_t *sol_list_get_index(sol_state_t *state, sol_object_t *list, int idx
 }
 
 void sol_list_set_index(sol_state_t *state, sol_object_t *list, int idx, sol_object_t *obj) {
-	sol_object_t *cur = list;
+	sol_object_t *cur = list, *temp;
 	int i = 0;
 	if(!sol_is_list(list)) {
 		sol_obj_free(sol_set_error_string(state, "Set index of non-list"));
@@ -215,24 +225,25 @@ void sol_list_set_index(sol_state_t *state, sol_object_t *list, int idx, sol_obj
 		sol_obj_free(sol_set_error_string(state, "Set negative index"));
 		return;
 	}
-	while(cur && cur->lvalue && i < idx) {
-		i++;
+	while(cur && i < idx) {
+		if(cur->lvalue) i++;
 		cur = cur->lnext;
 	}
 	if(cur) {
-		sol_obj_free(cur->lvalue);
+		temp = cur->lvalue;
 		cur->lvalue = sol_incref(obj);
+		sol_obj_free(temp);
 	} else {
 		sol_obj_free(sol_set_error_string(state, "Set out-of-bounds index"));
 		return;
 	}
 }
 
-void sol_list_insert(sol_state_t *state, sol_object_t **list, int idx, sol_object_t *obj) {
-	sol_object_t *next = *list, *prev = NULL, *temp = sol_alloc_object(state);
+void sol_list_insert(sol_state_t *state, sol_object_t *list, int idx, sol_object_t *obj) {
+	sol_object_t *next = list, *prev = NULL, *temp = sol_alloc_object(state);
 	int i = 0;
 	if(sol_has_error(state)) return;
-	if(!sol_is_list(*list)) {
+	if(!sol_is_list(list)) {
 		sol_obj_free(sol_set_error_string(state, "Insert into non-list"));
 		return;
 	}
@@ -240,8 +251,8 @@ void sol_list_insert(sol_state_t *state, sol_object_t **list, int idx, sol_objec
 		sol_obj_free(sol_set_error_string(state, "Insert at negative index"));
 		return;
 	}
-	temp->type = SOL_LIST;
-	temp->ops = &(state->ListOps);
+	temp->type = SOL_LCELL;
+	temp->ops = &(state->LCellOps);
 	temp->lvalue = sol_incref(obj);
 	while(next && i < idx) {
 		if(next->lvalue) i++;
@@ -249,12 +260,18 @@ void sol_list_insert(sol_state_t *state, sol_object_t **list, int idx, sol_objec
 		next = next->lnext;
 	}
 	if(next) {
-		temp->lnext = next;
 		if(prev) {
 			prev->lnext = temp;
-		} else {
-			*list = temp;
 			temp->lnext = next;
+		} else {
+			assert(next == list);
+			temp->lnext = sol_alloc_object(state);
+			temp->lnext->type = SOL_LCELL;
+			temp->lnext->ops = &(state->LCellOps);
+			temp->lnext->lvalue = list->lvalue;
+			temp->lnext->lnext = list->lnext;
+			list->lnext = temp;
+			list->lvalue = NULL;
 		}
 	} else {
         if(prev) {
@@ -267,10 +284,11 @@ void sol_list_insert(sol_state_t *state, sol_object_t **list, int idx, sol_objec
             return;
         }
 	}
+	assert(!sol_validate_list(state, list));
 }
 
-sol_object_t *sol_list_remove(sol_state_t *state, sol_object_t **list, int idx) {
-	sol_object_t *next = *list, *prev = NULL, *res, *temp;
+sol_object_t *sol_list_remove(sol_state_t *state, sol_object_t *list, int idx) {
+	sol_object_t *next = list, *prev = NULL, *res, *temp;
 	int i = 0;
 	if(sol_has_error(state)) return sol_incref(state->None);
 	if(idx < 0) {
@@ -285,13 +303,12 @@ sol_object_t *sol_list_remove(sol_state_t *state, sol_object_t **list, int idx)
 		if(prev) {
             res = next->lvalue;
 			prev->lnext = next->lnext;
-			free(next);
+			sol_obj_free(next);
 		} else {
-            res = (*list)->lvalue;
-			temp = *list;
-			*list = (*list)->lnext;
-			free(temp);
+            res = list->lvalue;
+			list->lvalue = NULL;
 		}
+		assert(!sol_validate_list(state, list));
 		return res;
 	} else {
 		return sol_set_error_string(state, "Out-of-bounds remove");
@@ -307,8 +324,8 @@ sol_object_t *sol_list_copy(sol_state_t *state, sol_object_t *list) {
 			newls->lnext = sol_alloc_object(state);
 			if(sol_has_error(state)) return sol_incref(state->None);
 			newls = newls->lnext;
-			newls->type = SOL_LIST;
-			newls->ops = &(state->ListOps);
+			newls->type = SOL_LCELL;
+			newls->ops = &(state->LCellOps);
 		}
 		cur = cur->lnext;
 	}
@@ -318,13 +335,17 @@ sol_object_t *sol_list_copy(sol_state_t *state, sol_object_t *list) {
 void sol_list_append(sol_state_t *state, sol_object_t *dest, sol_object_t *src) {
     sol_object_t *curd = dest, *curs = src;
     while(curd->lnext) curd = curd->lnext;
-    while(curs && curs->lvalue) {
-        curd->lnext = sol_alloc_object(state);
-        if(sol_has_error(state)) return;
-        curd = curd->lnext;
-        curd->type = SOL_LIST;
-        curd->ops = &(state->ListOps);
-        curd->lvalue = sol_incref(curs->lvalue);
+    while(curs) {
+		if(curs->lvalue) {
+			curd->lvalue = sol_incref(curs->lvalue);
+			curd->lnext = sol_alloc_object(state);
+			if(sol_has_error(state)) return;
+			curd = curd->lnext;
+			curd->type = SOL_LCELL;
+			curd->ops = &(state->LCellOps);
+			curd->lnext = NULL;
+			curd->lvalue = NULL;
+		}
         curs = curs->lnext;
     }
 }
@@ -332,11 +353,16 @@ void sol_list_append(sol_state_t *state, sol_object_t *dest, sol_object_t *src)
 sol_object_t *sol_f_list_free(sol_state_t *state, sol_object_t *list) {
     sol_object_t *cur = list, *prev;
     while(cur) {
-        if(cur->lvalue) sol_obj_free(cur->lvalue);
         prev = cur;
         cur = cur->lnext;
-        if(prev!=list) free(prev);
+        if(prev!=list) sol_obj_free(prev);
     }
+    return list;
+}
+
+sol_object_t *sol_f_lcell_free(sol_state_t *state, sol_object_t *lcell) {
+	if(lcell->lvalue) sol_obj_free(lcell->lvalue);
+	return lcell;
 }
 
 int sol_test_cycle(sol_state_t *state, sol_object_t *seq) {
@@ -365,20 +391,20 @@ int sol_validate_list(sol_state_t *state, sol_object_t *list) {
 	while(cur) {
 		if(!sol_is_list(cur)) {
 			snprintf(msg, 128, "Node at index %d not a list node", i);
-			//sol_obj_free(sol_set_error_string(state, msg));
+			sol_obj_free(sol_set_error_string(state, msg));
 			return 1;
 		}
-		if(cur->lnext && !cur->lvalue) {
+		/*if(cur->lnext && !cur->lvalue) {
 			snprintf(msg, 128, "Node at index %d has a next node but NULL value", i);
-			//sol_obj_free(sol_set_error_string(state, msg));
+			sol_obj_free(sol_set_error_string(state, msg));
 			return 1;
-		}
+		}*/
 		cur = cur->lnext;
 		i++;
 	}
 	if(sol_test_cycle(state, list)) {
 		snprintf(msg, 128, "Cycle detected");
-		//sol_obj_free(sol_set_error_string(state, msg));
+		sol_obj_free(sol_set_error_string(state, msg));
 		return 1;
 	}
 	return 0;
@@ -406,12 +432,12 @@ int sol_map_len(sol_state_t *state, sol_object_t *map) {
 
 sol_object_t *sol_map_submap(sol_state_t *state, sol_object_t *map, sol_object_t *key) {
     sol_object_t *list = sol_new_list(state), *res = NULL, *cur = map, *cmp;
-    sol_list_insert(state, &list, 0, key);
+    sol_list_insert(state, list, 0, key);
     while(cur) {
         if(cur->mkey) {
-            sol_list_insert(state, &list, 1, cur->mkey);
+            sol_list_insert(state, list, 1, cur->mkey);
             cmp = sol_cast_int(state, key->ops->cmp(state, list));
-            sol_list_remove(state, &list, 1);
+            sol_list_remove(state, list, 1);
             if(cmp->ival == 0) {
                 res = cur;
                 break;
@@ -437,23 +463,29 @@ 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 *res = sol_map_get(state, map, key);
+	sol_obj_free(key);
+	return res;
+}
+
 void sol_map_set(sol_state_t *state, sol_object_t *map, sol_object_t *key, sol_object_t *val) {
     sol_object_t *cur = map, *prev = NULL, *list = sol_new_list(state), *cmp;
-    sol_list_insert(state, &list, 0, key);
+    sol_list_insert(state, list, 0, key);
     while(cur) {
         if(cur->mkey) {
-            sol_list_insert(state, &list, 1, cur->mkey);
+            sol_list_insert(state, list, 1, cur->mkey);
             cmp = sol_cast_int(state, key->ops->cmp(state, list));
-            sol_list_remove(state, &list, 1);
+            sol_list_remove(state, list, 1);
             if(cmp->ival == 0) {
-                sol_obj_free(cur->mval);
                 if(sol_is_none(state, val)) {
                     if(prev) {
                         prev->mnext = cur->mnext;
-                        sol_obj_free(cur->mkey);
-                        free(cur);
+                        sol_obj_free(cur);
                     } else {
                         sol_obj_free(cur->mkey);
+						sol_obj_free(cur->mval);
                         cur->mkey = NULL;
                         cur->mval = NULL;
                     }
@@ -470,30 +502,35 @@ void sol_map_set(sol_state_t *state, sol_object_t *map, sol_object_t *key, sol_o
     prev->mnext = sol_alloc_object(state);
     if(sol_has_error(state)) return;
     cur = prev->mnext;
-    cur->type = SOL_MAP;
-    cur->ops = &(state->MapOps);
+    cur->type = SOL_MCELL;
+    cur->ops = &(state->MCellOps);
     cur->mkey = sol_incref(key);
     cur->mval = sol_incref(val);
     cur->mnext = NULL;
 }
 
+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_map_set(state, map, key, val);
+	sol_obj_free(key);
+}
+
 void sol_map_set_existing(sol_state_t *state, sol_object_t *map, sol_object_t *key, sol_object_t *val) {
     sol_object_t *cur = map, *prev = NULL, *list = sol_new_list(state), *cmp;
-    sol_list_insert(state, &list, 0, key);
+    sol_list_insert(state, list, 0, key);
     while(cur) {
         if(cur->mkey) {
-            sol_list_insert(state, &list, 1, cur->mkey);
+            sol_list_insert(state, list, 1, cur->mkey);
             cmp = sol_cast_int(state, key->ops->cmp(state, list));
-            sol_obj_free(sol_list_remove(state, &list, 1));
+            sol_obj_free(sol_list_remove(state, list, 1));
             if(cmp->ival == 0) {
-                sol_obj_free(cur->mval);
                 if(sol_is_none(state, val)) {
                     if(prev) {
                         prev->mnext = cur->mnext;
-                        sol_obj_free(cur->mkey);
-                        free(cur);
+                        sol_obj_free(cur);
                     } else {
                         sol_obj_free(cur->mkey);
+						sol_obj_free(cur->mval);
                         cur->mkey = NULL;
                         cur->mval = NULL;
                     }
@@ -516,8 +553,8 @@ sol_object_t *sol_map_copy(sol_state_t *state, sol_object_t *map) {
             newcur->mval = sol_incref(cur->mval);
             newcur->mnext = sol_alloc_object(state);
             newcur = newcur->mnext;
-            newcur->type = SOL_MAP;
-            newcur->ops = &(state->MapOps);
+            newcur->type = SOL_MCELL;
+            newcur->ops = &(state->MCellOps);
             newcur->mkey = NULL;
             newcur->mval = NULL;
             newcur->mnext = NULL;
@@ -561,6 +598,12 @@ sol_object_t *sol_f_map_free(sol_state_t *state, sol_object_t *map) {
     return map;
 }
 
+sol_object_t *sol_f_mcell_free(sol_state_t *state, sol_object_t *mcell) {
+	if(mcell->mkey) sol_obj_free(mcell->mkey);
+	if(mcell->mval) sol_obj_free(mcell->mval);
+	return mcell;
+}
+
 int sol_validate_map(sol_state_t *state, sol_object_t *map) {
 	sol_object_t *cur = map;
 	int i = 0;

parser.tab.h

@@ -89,17 +89,19 @@ extern int yydebug;
      GREATER = 298,
      LESSEQ = 299,
      GREATEREQ = 300,
-     LBRACE = 301,
-     RBRACE = 302,
-     LPAREN = 303,
-     RPAREN = 304,
-     LBRACKET = 305,
-     RBRACKET = 306,
-     DOT = 307,
-     COLON = 308,
-     SEMICOLON = 309,
-     COMMA = 310,
-     POUND = 311
+     RSHIFT = 301,
+     LSHIFT = 302,
+     LBRACE = 303,
+     RBRACE = 304,
+     LPAREN = 305,
+     RPAREN = 306,
+     LBRACKET = 307,
+     RBRACKET = 308,
+     DOT = 309,
+     COLON = 310,
+     SEMICOLON = 311,
+     COMMA = 312,
+     POUND = 313
    };
 #endif
 

parser.y

@@ -18,7 +18,7 @@
 %token INT FLOAT STRING
 %token PLUS MINUS STAR SLASH DSTAR BAND BOR BXOR BNOT LAND LOR LNOT
 %token ASSIGN ASSIGNPLUS ASSIGNMINUS ASSIGNSTAR ASSIGNSLASH ASSIGNDSTAR ASSIGNBAND ASSIGNBOR ASSIGNBXOR
-%token EQUAL LESS GREATER LESSEQ GREATEREQ
+%token EQUAL LESS GREATER LESSEQ GREATEREQ RSHIFT LSHIFT
 %token LBRACE RBRACE LPAREN RPAREN LBRACKET RBRACKET DOT COLON SEMICOLON COMMA POUND
 
 %parse-param {stmt_node **program}
@@ -36,7 +36,7 @@ stmt:
 | IF expr THEN stmt END { $$ = NEW_ST(); AS_ST($$)->type = ST_IFELSE; AS_ST($$)->ifelse = NEW(ifelse_node); AS_ST($$)->ifelse->cond = $2; AS_ST($$)->ifelse->iftrue = $4; AS_ST($$)->ifelse->iffalse = NULL; }
 | IF expr THEN stmt ELSE stmt END { $$ = NEW_ST(); AS_ST($$)->type = ST_IFELSE; AS_ST($$)->ifelse = NEW(ifelse_node); AS_ST($$)->ifelse->cond = $2; AS_ST($$)->ifelse->iftrue = $4; AS_ST($$)->ifelse->iffalse = $6; }
 | WHILE expr DO stmt END { $$ = NEW_ST(); AS_ST($$)->type = ST_LOOP; AS_ST($$)->loop = NEW(loop_node); AS_ST($$)->loop->cond = $2; AS_ST($$)->loop->loop = $4; }
-| FOR IDENT IN expr DO stmt END { $$ = NEW_ST(); AS_ST($$)->type = ST_ITER; AS_ST($$)->iter = NEW(iter_node); AS_ST($$)->iter->var = strdup($2); AS_ST($$)->iter->iter = $4; AS_ST($$)->iter->loop = $6; }
+| FOR IDENT IN expr DO stmt END { $$ = NEW_ST(); AS_ST($$)->type = ST_ITER; AS_ST($$)->iter = NEW(iter_node); AS_ST($$)->iter->var = $2; AS_ST($$)->iter->iter = $4; AS_ST($$)->iter->loop = $6; }
 | RETURN expr { $$ = NEW_ST(); AS_ST($$)->type = ST_RET; AS_ST($$)->ret = NEW(ret_node); AS_ST($$)->ret->ret = $2; }
 | RETURN { $$ = NEW_ST(); AS_ST($$)->type = ST_RET; AS_ST($$)->ret = NEW(ret_node); AS_ST($$)->ret->ret = NULL; }
 | BREAK { $$ = NEW_ST(); AS_ST($$)->type = ST_BREAK; }
@@ -282,9 +282,11 @@ power_expr:
 ;
 
 binary_expr:
-  ubinary_expr BAND ubinary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_BAND; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
-| ubinary_expr BOR ubinary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_BOR; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
-| ubinary_expr BXOR ubinary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_BXOR; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
+  binary_expr BAND binary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_BAND; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
+| binary_expr BOR binary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_BOR; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
+| binary_expr BXOR binary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_BXOR; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
+| binary_expr LSHIFT binary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_LSHIFT; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
+| binary_expr RSHIFT binary_expr { $$ = NEW_EX(); AS_EX($$)->type = EX_BINOP; AS_EX($$)->binop = NEW(binop_node); AS_EX($$)->binop->type = OP_RSHIFT; AS_EX($$)->binop->left = $1; AS_EX($$)->binop->right = $3; }
 | ubinary_expr { $$ = $1; }
 ;
 
@@ -300,6 +302,23 @@ ulen_expr:
 
 call_expr:
   call_expr LPAREN expr_list RPAREN { $$ = NEW_EX(); AS_EX($$)->type = EX_CALL; AS_EX($$)->call = NEW(call_node); AS_EX($$)->call->expr = $1; AS_EX($$)->call->args = $3; }
+| call_expr COLON IDENT LPAREN expr_list RPAREN {
+	$$ = NEW_EX();
+	AS_EX($$)->type = EX_CALL;
+	AS_EX($$)->call = NEW(call_node);
+	AS_EX($$)->call->expr = NEW_EX();
+	AS_EX($$)->call->expr->type = EX_INDEX;
+	AS_EX($$)->call->expr->index = NEW(index_node);
+	AS_EX($$)->call->expr->index->expr = $1;
+	AS_EX($$)->call->expr->index->index = NEW_EX();
+	AS_EX($$)->call->expr->index->index->type = EX_LIT;
+	AS_EX($$)->call->expr->index->index->lit = NEW(lit_node);
+	AS_EX($$)->call->expr->index->index->lit->type = LIT_STRING;
+	AS_EX($$)->call->expr->index->index->lit->str = $3;
+	AS_EX($$)->call->args = NEW(exprlist_node);
+	AS_EX($$)->call->args->expr = $1;
+	AS_EX($$)->call->args->next = $5;
+}
 | funcdecl_expr { $$ = $1; }
 ;
 

runtime.c

@@ -190,7 +190,7 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
             res = sol_new_list(state);
             cure = expr->listgen->list;
             while(cure) {
-                if(cure->expr) sol_list_insert(state, &res, sol_list_len(state, res), sol_eval(state, cure->expr));
+                if(cure->expr) sol_list_insert(state, res, sol_list_len(state, res), sol_eval(state, cure->expr));
                 cure = cure->next;
             }
             return res;
@@ -210,8 +210,8 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
             list = sol_new_list(state);
             left = sol_eval(state, expr->binop->left);
             right = sol_eval(state, expr->binop->right);
-            sol_list_insert(state, &list, 0, left);
-            sol_list_insert(state, &list, 1, right);
+            sol_list_insert(state, list, 0, left);
+            sol_list_insert(state, list, 1, right);
             switch(expr->binop->type) {
                 case OP_ADD:
                     res = left->ops->add(state, list);
@@ -238,7 +238,7 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
                     break;
 
                 case OP_BOR:
-                    res = left->ops->bor(state, list);
+                    res = left->ops->bor(state, list);			printf("BINOP\n"); ob_print(list); printf("\n");
                     break;
 
                 case OP_BXOR:
@@ -249,16 +249,16 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
                     lint = sol_cast_int(state, left);
                     rint = sol_cast_int(state, right);
                     res = sol_new_int(state, BOOL_TO_INT(lint && rint));
-                    sol_obj_free(lint);
-                    sol_obj_free(rint);
+                    if(lint != left) sol_obj_free(lint);
+                    if(rint != right) sol_obj_free(rint);
                     break;
 
                 case OP_LOR:
                     lint = sol_cast_int(state, left);
                     rint = sol_cast_int(state, right);
                     res = sol_new_int(state, BOOL_TO_INT(lint || rint));
-                    sol_obj_free(lint);
-                    sol_obj_free(rint);
+                    if(lint != left) sol_obj_free(lint);
+                    if(rint != right) sol_obj_free(rint);
                     break;
 
                 case OP_EQUAL:
@@ -280,21 +280,29 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
                 case OP_GREATEREQ:
                     res = sol_new_int(state, BOOL_TO_INT(sol_cast_int(state, left->ops->cmp(state, list))->ival>=0));
                     break;
+					
+				case OP_LSHIFT:
+					res = left->ops->blsh(state, list);
+					break;
+					
+				case OP_RSHIFT:
+					res = left->ops->brsh(state, list);
+					break;
             }
+            sol_obj_free(list);
             sol_obj_free(left);
             sol_obj_free(right);
-            sol_obj_free(list);
             return res;
             break;
 
         case EX_UNOP:
             left = sol_eval(state, expr->unop->expr);
             list = sol_new_list(state);
-            sol_list_insert(state, &list, 0, left);
+            sol_list_insert(state, list, 0, left);
             switch(expr->unop->type) {
                 case OP_NEG:
                     right = sol_new_int(state, -1);
-                    sol_list_insert(state, &list, 1, right);
+                    sol_list_insert(state, list, 1, right);
                     res = left->ops->mul(state, list);
                     sol_obj_free(right);
                     break;
@@ -322,8 +330,8 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
             left = sol_eval(state, expr->index->expr);
             right = sol_eval(state, expr->index->index);
             list = sol_new_list(state);
-            sol_list_insert(state, &list, 0, left);
-            sol_list_insert(state, &list, 1, right);
+            sol_list_insert(state, list, 0, left);
+            sol_list_insert(state, list, 1, right);
             res = left->ops->index(state, list);
             sol_obj_free(left);
             sol_obj_free(right);
@@ -336,9 +344,9 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
             right = sol_eval(state, expr->setindex->index);
             value = sol_eval(state, expr->setindex->value);
             list = sol_new_list(state);
-            sol_list_insert(state, &list, 0, left);
-            sol_list_insert(state, &list, 1, right);
-            sol_list_insert(state, &list, 2, value);
+            sol_list_insert(state, list, 0, left);
+            sol_list_insert(state, list, 1, right);
+            sol_list_insert(state, list, 2, value);
             res = left->ops->setindex(state, list);
             sol_obj_free(left);
             sol_obj_free(right);
@@ -360,10 +368,10 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
         case EX_CALL:
             value = sol_eval(state, expr->call->expr);
             list = sol_new_list(state);
-            sol_list_insert(state, &list, 0, value);
+            sol_list_insert(state, list, 0, value);
             cure = expr->call->args;
             while(cure) {
-                if(cure->expr) sol_list_insert(state, &list, sol_list_len(state, list), sol_eval(state, cure->expr));
+                if(cure->expr) sol_list_insert(state, list, sol_list_len(state, list), sol_eval(state, cure->expr));
                 cure = cure->next;
             }
             res = value->ops->call(state, list);
@@ -383,7 +391,7 @@ sol_object_t *sol_eval(sol_state_t *state, expr_node *expr) {
 }
 
 void sol_exec(sol_state_t *state, stmt_node *stmt) {
-    sol_object_t *value, *vint;
+    sol_object_t *value, *vint, *list, *iter, *item;
     stmtlist_node *curs;
     if(!stmt) {
         sol_obj_free(sol_set_error_string(state, "Execute NULL statement"));
@@ -410,7 +418,7 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
             value = sol_eval(state, stmt->loop->cond);
             vint = sol_cast_int(state, value);
             while(vint->ival) {
-                sol_obj_free(value);
+                if(value != vint) sol_obj_free(value);
                 sol_obj_free(vint);
                 sol_exec(state, stmt->loop->loop);
                 if(state->ret || state->sflag == SF_BREAKING || sol_has_error(state)) break;
@@ -418,18 +426,40 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
                 vint = sol_cast_int(state, value);
             }
             state->sflag = SF_NORMAL;
+			if(vint != value) sol_obj_free(value);
+			if(vint) sol_obj_free(vint);
             break;
 
         case ST_ITER:
             value = sol_eval(state, stmt->iter->iter);
-            while(value != state->StopIteration) {
-                sol_state_assign_l_name(state, stmt->iter->var, value);
-                sol_obj_free(value);
-                sol_exec(state, stmt->loop->loop);
+			if(value->ops->iter && value->ops->iter != sol_f_not_impl) {
+				list = sol_new_list(state);
+				sol_list_insert(state, list, 0, value);
+				iter = value->ops->iter(state, list);
+				sol_obj_free(list);
+			} else {
+				iter = value;
+			}
+			if(!iter->ops->call || iter->ops->call==sol_f_not_impl) {
+				sol_obj_free(sol_set_error_string(state, "Iterate over non-iterable"));
+				return;
+			}
+			list = sol_new_list(state);
+			sol_list_insert(state, list, 0, iter);
+			sol_list_insert(state, list, 1, value);
+			sol_list_insert(state, list, 2, sol_new_map(state));
+			item = iter->ops->call(state, list);
+            while(item != state->StopIteration) {
+                sol_state_assign_l_name(state, stmt->iter->var, item);
+                sol_exec(state, stmt->iter->loop);
+				sol_obj_free(item);
                 if(state->ret || state->sflag == SF_BREAKING || sol_has_error(state)) break;
-                value = sol_eval(state, stmt->iter->iter);
+                item = iter->ops->call(state, list);
             }
             state->sflag = SF_NORMAL;
+			sol_obj_free(list);
+			sol_obj_free(iter);
+			sol_obj_free(value);
             break;
 
         case ST_LIST:
@@ -461,9 +491,12 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
 sol_object_t *sol_f_func_call(sol_state_t *state, sol_object_t *args) {
     sol_object_t *res, *scope, *value, *curo = args, *key;
     identlist_node *curi;
+	while(curo && !curo->lvalue) curo = curo->lnext;
+	if(!curo) return sol_incref(state->None);
     value = curo->lvalue;
-	if(!value->func) return sol_incref(state->None);
+	if(!value || !value->func) return sol_incref(state->None);
     curo = curo->lnext;
+	while(curo && !curo->lvalue) curo = curo->lnext;
     scope = sol_map_copy(state, value->closure);
     curi = AS(value->args, identlist_node);
     while(curi) {
@@ -474,6 +507,7 @@ sol_object_t *sol_f_func_call(sol_state_t *state, sol_object_t *args) {
             } else {
                 sol_map_set(state, scope, key, curo->lvalue);
                 curo = curo->lnext;
+				while(curo && !curo->lvalue) curo = curo->lnext;
             }
             sol_obj_free(key);
             curi = curi->next;

sol.h

@@ -23,12 +23,15 @@ typedef struct {
 	sol_cfunc_t band;
 	sol_cfunc_t bor;
 	sol_cfunc_t bxor;
+	sol_cfunc_t blsh;
+	sol_cfunc_t brsh;
 	sol_cfunc_t bnot;
 	sol_cfunc_t cmp;
 	sol_cfunc_t call;
 	sol_cfunc_t index;
 	sol_cfunc_t setindex;
 	sol_cfunc_t len;
+	sol_cfunc_t iter;
 	sol_cfunc_t toint;
 	sol_cfunc_t tofloat;
 	sol_cfunc_t tostring;
@@ -42,7 +45,9 @@ typedef enum {
 	SOL_FLOAT,
 	SOL_STRING,
 	SOL_LIST,
+	SOL_LCELL,
 	SOL_MAP,
+	SOL_MCELL,
 	SOL_FUNCTION,
 	SOL_CFUNCTION,
 	SOL_CDATA
@@ -96,7 +101,9 @@ typedef struct sol_tag_state_t {
 	sol_ops_t FloatOps;
 	sol_ops_t StringOps;
 	sol_ops_t ListOps;
+	sol_ops_t LCellOps;
 	sol_ops_t MapOps;
+	sol_ops_t MCellOps;
 	sol_ops_t FuncOps;
 	sol_ops_t CFuncOps;
 } sol_state_t;
@@ -133,6 +140,20 @@ sol_object_t *sol_f_tostring(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_try(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_type(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_prepr(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_print(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_rawget(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_rawset(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_range(sol_state_t *, sol_object_t *);
+
+sol_object_t *sol_f_debug_getref(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_debug_setref(sol_state_t *, sol_object_t *);
+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_iter_str(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 *);
 
 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 *);
@@ -142,6 +163,8 @@ sol_object_t *sol_f_int_pow(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_int_band(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_int_bor(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_int_bxor(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_int_blsh(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_int_brsh(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_int_bnot(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_int_cmp(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_int_toint(sol_state_t *, sol_object_t *);
@@ -161,6 +184,7 @@ sol_object_t *sol_f_float_tostring(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_add(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_mul(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_len(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_str_iter(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_cmp(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 *);
@@ -171,15 +195,20 @@ sol_object_t *sol_f_list_mul(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_list_index(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_list_setindex(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_list_len(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_list_iter(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_list_tostring(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_map_add(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_index(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_setindex(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_map_call(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_len(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_map_iter(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_tostring(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_func_call(sol_state_t *, sol_object_t *); // Defined in ast.c
+sol_object_t *sol_f_func_index(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_func_setindex(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_func_tostring(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_cfunc_call(sol_state_t *, sol_object_t *);
@@ -199,8 +228,8 @@ void sol_obj_release(sol_object_t *);
 #define sol_is_int(obj) ((obj)-> type == SOL_INTEGER)
 #define sol_is_float(obj) ((obj)->type == SOL_FLOAT)
 #define sol_is_string(obj) ((obj)->type == SOL_STRING)
-#define sol_is_list(obj) ((obj)->type == SOL_LIST)
-#define sol_is_map(obj) ((obj)->type == SOL_MAP)
+#define sol_is_list(obj) ((obj)->type == SOL_LIST || (obj)->type == SOL_LCELL)
+#define sol_is_map(obj) ((obj)->type == SOL_MAP || (obj)->type == SOL_MCELL)
 #define sol_is_func(obj) ((obj)->type == SOL_FUNCTION)
 #define sol_is_cfunc(obj) ((obj)->type == SOL_CFUNCTION)
 #define sol_is_cdata(obj) ((obj)->type == SOL_CDATA)
@@ -219,18 +248,20 @@ int sol_list_len(sol_state_t *, sol_object_t *);
 sol_object_t *sol_list_sublist(sol_state_t *, sol_object_t *, int);
 sol_object_t *sol_list_get_index(sol_state_t *, sol_object_t *, int);
 void sol_list_set_index(sol_state_t *, sol_object_t *, int, sol_object_t *);
-void sol_list_insert(sol_state_t *, sol_object_t **, int, sol_object_t *);
-sol_object_t *sol_list_remove(sol_state_t *, sol_object_t **, int);
+void sol_list_insert(sol_state_t *, sol_object_t *, int, sol_object_t *);
+sol_object_t *sol_list_remove(sol_state_t *, sol_object_t *, int);
 sol_object_t *sol_list_copy(sol_state_t *, sol_object_t *);
 void sol_list_append(sol_state_t *, sol_object_t *, sol_object_t *);
-#define sol_list_push(st, ls, obj) sol_list_insert(st, &(ls), 0, obj);
-#define sol_list_pop(st, ls) sol_list_remove(st, &(ls), 0);
+#define sol_list_push(st, ls, obj) sol_list_insert(st, ls, 0, obj);
+#define sol_list_pop(st, ls) sol_list_remove(st, ls, 0);
 
 sol_object_t *sol_new_map(sol_state_t *);
 int sol_map_len(sol_state_t *, sol_object_t *);
 sol_object_t *sol_map_submap(sol_state_t *, sol_object_t *, sol_object_t *);
 sol_object_t *sol_map_get(sol_state_t *, sol_object_t *, sol_object_t *);
+sol_object_t *sol_map_get_name(sol_state_t *, sol_object_t *, char *);
 void sol_map_set(sol_state_t *, sol_object_t *, sol_object_t *, sol_object_t *);
+void sol_map_set_name(sol_state_t *, sol_object_t *, char *, sol_object_t *);
 void sol_map_set_existing(sol_state_t *, sol_object_t *, sol_object_t *, sol_object_t *);
 sol_object_t *sol_map_copy(sol_state_t *, sol_object_t *);
 void sol_map_merge(sol_state_t *, sol_object_t *, sol_object_t *);
@@ -248,7 +279,9 @@ sol_object_t *sol_cast_string(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_str_free(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_list_free(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_lcell_free(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_free(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_mcell_free(sol_state_t *, sol_object_t *);
 
 int sol_validate_list(sol_state_t *, sol_object_t *);
 int sol_validate_map(sol_state_t *, sol_object_t *);

state.c

@@ -1,7 +1,7 @@
 #include "sol.h"
 
 int sol_state_init(sol_state_t *state) {
-	sol_object_t *globals;
+	sol_object_t *globals, *debug, *iter;
 
 	state->None = NULL;
 	state->OutOfMemory = NULL;
@@ -27,17 +27,30 @@ int sol_state_init(sol_state_t *state) {
 	state->NullOps.band = sol_f_not_impl;
 	state->NullOps.bor = sol_f_not_impl;
 	state->NullOps.bxor = sol_f_not_impl;
+	state->NullOps.blsh = sol_f_not_impl;
+	state->NullOps.brsh = sol_f_not_impl;
 	state->NullOps.bnot = sol_f_not_impl;
 	state->NullOps.cmp = sol_f_default_cmp;
 	state->NullOps.call = sol_f_not_impl;
 	state->NullOps.index = sol_f_not_impl;
 	state->NullOps.setindex = sol_f_not_impl;
 	state->NullOps.len = sol_f_not_impl;
+	state->NullOps.iter = sol_f_not_impl;
 	state->NullOps.toint = sol_f_not_impl;
 	state->NullOps.tofloat = sol_f_not_impl;
 	state->NullOps.tostring = sol_f_not_impl;
 	state->NullOps.init = sol_f_no_op;
 	state->NullOps.free = sol_f_no_op;
+	
+	state->IntOps = state->NullOps;
+	state->FloatOps = state->NullOps;
+	state->StringOps = state->NullOps;
+	state->ListOps = state->NullOps;
+	state->LCellOps = state->NullOps;
+	state->MapOps = state->NullOps;
+	state->MCellOps = state->NullOps;
+	state->FuncOps = state->NullOps;
+	state->CFuncOps = state->NullOps;
 
 	state->IntOps.add = sol_f_int_add;
 	state->IntOps.sub = sol_f_int_sub;
@@ -46,148 +59,102 @@ int sol_state_init(sol_state_t *state) {
 	state->IntOps.band = sol_f_int_band;
 	state->IntOps.bor = sol_f_int_bor;
 	state->IntOps.bxor = sol_f_int_bxor;
+	state->IntOps.blsh = sol_f_int_blsh;
+	state->IntOps.brsh = sol_f_int_brsh;
 	state->IntOps.bnot = sol_f_int_bnot;
 	state->IntOps.cmp = sol_f_int_cmp;
-	state->IntOps.call = sol_f_not_impl;
-	state->IntOps.index = sol_f_not_impl;
-	state->IntOps.setindex = sol_f_not_impl;
-	state->IntOps.len = sol_f_not_impl;
 	state->IntOps.toint = sol_f_int_toint;
 	state->IntOps.tofloat = sol_f_int_tofloat;
 	state->IntOps.tostring = sol_f_int_tostring;
-	state->IntOps.init = sol_f_no_op;
-	state->IntOps.free = sol_f_no_op;
 
 	state->FloatOps.add = sol_f_float_add;
 	state->FloatOps.sub = sol_f_float_sub;
 	state->FloatOps.mul = sol_f_float_mul;
 	state->FloatOps.div = sol_f_float_div;
-	state->FloatOps.band = sol_f_not_impl;
-	state->FloatOps.bor = sol_f_not_impl;
-	state->FloatOps.bxor = sol_f_not_impl;
-	state->FloatOps.bnot = sol_f_not_impl;
 	state->FloatOps.cmp = sol_f_float_cmp;
-	state->FloatOps.call = sol_f_not_impl;
-	state->FloatOps.index = sol_f_not_impl;
-	state->FloatOps.setindex = sol_f_not_impl;
-	state->FloatOps.len = sol_f_not_impl;
 	state->FloatOps.toint = sol_f_float_toint;
 	state->FloatOps.tofloat = sol_f_float_tofloat;
 	state->FloatOps.tostring = sol_f_float_tostring;
-	state->FloatOps.init = sol_f_no_op;
-	state->FloatOps.free = sol_f_no_op;
 
 	state->StringOps.add = sol_f_str_add;
-	state->StringOps.sub = sol_f_not_impl;
 	state->StringOps.mul = sol_f_str_mul;
-	state->StringOps.div = sol_f_not_impl;
-	state->StringOps.band = sol_f_not_impl;
-	state->StringOps.bor = sol_f_not_impl;
-	state->StringOps.bxor = sol_f_not_impl;
-	state->StringOps.bnot = sol_f_not_impl;
 	state->StringOps.cmp = sol_f_str_cmp;
-	state->StringOps.call = sol_f_not_impl;
-	state->StringOps.index = sol_f_not_impl;
-	state->StringOps.setindex = sol_f_not_impl;
 	state->StringOps.len = sol_f_str_len;
+	state->StringOps.iter = sol_f_str_iter;
 	state->StringOps.toint = sol_f_str_toint;
 	state->StringOps.tofloat = sol_f_str_tofloat;
 	state->StringOps.tostring = sol_f_str_tostring;
-	state->StringOps.init = sol_f_no_op;
 	state->StringOps.free = sol_f_str_free;
 
 	state->ListOps.add = sol_f_list_add;
-	state->ListOps.sub = sol_f_not_impl;
 	state->ListOps.mul = sol_f_list_mul;
-	state->ListOps.div = sol_f_not_impl;
-	state->ListOps.band = sol_f_not_impl;
-	state->ListOps.bor = sol_f_not_impl;
-	state->ListOps.bxor = sol_f_not_impl;
-	state->ListOps.bnot = sol_f_not_impl;
-	state->ListOps.cmp = sol_f_default_cmp;
 	state->ListOps.call = sol_f_not_impl;
 	state->ListOps.index = sol_f_list_index;
 	state->ListOps.setindex = sol_f_list_setindex;
 	state->ListOps.len = sol_f_list_len;
-	state->ListOps.toint = sol_f_not_impl;
-	state->ListOps.tofloat = sol_f_not_impl;
+	state->ListOps.iter = sol_f_list_iter;
 	state->ListOps.tostring = sol_f_list_tostring;
-	state->ListOps.init = sol_f_no_op;
 	state->ListOps.free = sol_f_list_free;
+	
+	state->LCellOps = state->ListOps;
+	state->LCellOps.free = sol_f_lcell_free;
 
 	state->MapOps.add = sol_f_map_add;
-	state->MapOps.sub = sol_f_not_impl;
-	state->MapOps.mul = sol_f_not_impl;
-	state->MapOps.div = sol_f_not_impl;
-	state->MapOps.band = sol_f_not_impl;
-	state->MapOps.bor = sol_f_not_impl;
-	state->MapOps.bxor = sol_f_not_impl;
-	state->MapOps.bnot = sol_f_not_impl;
-	state->MapOps.cmp = sol_f_default_cmp;
-	state->MapOps.call = sol_f_not_impl;
+	state->MapOps.call = sol_f_map_call;
 	state->MapOps.index = sol_f_map_index;
 	state->MapOps.setindex = sol_f_map_setindex;
 	state->MapOps.len = sol_f_map_len;
-	state->MapOps.toint = sol_f_not_impl;
-	state->MapOps.tofloat = sol_f_not_impl;
+	state->MapOps.iter = sol_f_map_iter;
 	state->MapOps.tostring = sol_f_map_tostring;
-	state->MapOps.init = sol_f_no_op;
 	state->MapOps.free = sol_f_map_free;
+	
+	state->MCellOps = state->MapOps;
+	state->MCellOps.free = sol_f_mcell_free;
 
-	state->FuncOps.add = sol_f_not_impl;
-	state->FuncOps.sub = sol_f_not_impl;
-	state->FuncOps.mul = sol_f_not_impl;
-	state->FuncOps.div = sol_f_not_impl;
-	state->FuncOps.band = sol_f_not_impl;
-	state->FuncOps.bor = sol_f_not_impl;
-	state->FuncOps.bxor = sol_f_not_impl;
-	state->FuncOps.bnot = sol_f_not_impl;
-	state->FuncOps.cmp = sol_f_default_cmp;
 	state->FuncOps.call = sol_f_func_call;
-	state->FuncOps.index = sol_f_not_impl;
-	state->FuncOps.setindex = sol_f_not_impl;
-	state->FuncOps.len = sol_f_not_impl;
-	state->FuncOps.toint = sol_f_not_impl;
-	state->FuncOps.tofloat = sol_f_not_impl;
+	state->FuncOps.index = sol_f_func_index;
+	state->FuncOps.setindex = sol_f_func_setindex;
 	state->FuncOps.tostring = sol_f_func_tostring;
-	state->FuncOps.init = sol_f_no_op;
-	state->FuncOps.free = sol_f_no_op;
-
-	state->CFuncOps.add = sol_f_not_impl;
-	state->CFuncOps.sub = sol_f_not_impl;
-	state->CFuncOps.mul = sol_f_not_impl;
-	state->CFuncOps.div = sol_f_not_impl;
-	state->CFuncOps.band = sol_f_not_impl;
-	state->CFuncOps.bor = sol_f_not_impl;
-	state->CFuncOps.bxor = sol_f_not_impl;
-	state->CFuncOps.bnot = sol_f_not_impl;
-	state->CFuncOps.cmp = sol_f_default_cmp;
+
 	state->CFuncOps.call = sol_f_cfunc_call;
-	state->CFuncOps.index = sol_f_not_impl;
-	state->CFuncOps.setindex = sol_f_not_impl;
-	state->CFuncOps.len = sol_f_not_impl;
-	state->CFuncOps.toint = sol_f_not_impl;
-	state->CFuncOps.tofloat = sol_f_not_impl;
 	state->CFuncOps.tostring = sol_f_cfunc_tostring;
-	state->CFuncOps.init = sol_f_no_op;
-	state->CFuncOps.free = sol_f_no_op;
 
 	state->error = state->None;
 	state->scopes = sol_new_list(state);
 	if(sol_has_error(state)) goto cleanup;
 	globals = sol_new_map(state);
+	debug = sol_new_map(state);
+	iter = sol_new_map(state);
 	if(sol_has_error(state)) goto cleanup;
-	sol_list_insert(state, &(state->scopes), 0, globals);
+	sol_list_insert(state, state->scopes, 0, globals);
 	if(sol_has_error(state)) goto cleanup;
 	// I'm going to buffer all of these together because I can.
-	sol_map_set(state, globals, sol_new_string(state, "OutOfMemory"), state->OutOfMemory);
-	sol_map_set(state, globals, sol_new_string(state, "StopIteration"), state->StopIteration);
-	sol_map_set(state, globals, sol_new_string(state, "toint"), sol_new_cfunc(state, sol_f_toint));
-	sol_map_set(state, globals, sol_new_string(state, "tofloat"), sol_new_cfunc(state, sol_f_tofloat));
-	sol_map_set(state, globals, sol_new_string(state, "tostring"), sol_new_cfunc(state, sol_f_tostring));
-	sol_map_set(state, globals, sol_new_string(state, "try"), sol_new_cfunc(state, sol_f_try));
-	sol_map_set(state, globals, sol_new_string(state, "type"), sol_new_cfunc(state, sol_f_type));
-	sol_map_set(state, globals, sol_new_string(state, "prepr"), sol_new_cfunc(state, sol_f_prepr));
+	sol_map_set_name(state, globals, "OutOfMemory", state->OutOfMemory);
+	sol_map_set_name(state, globals, "StopIteration", state->StopIteration);
+	sol_map_set_name(state, globals, "toint", sol_new_cfunc(state, sol_f_toint));
+	sol_map_set_name(state, globals, "tofloat", sol_new_cfunc(state, sol_f_tofloat));
+	sol_map_set_name(state, globals, "tostring", sol_new_cfunc(state, sol_f_tostring));
+	sol_map_set_name(state, globals, "try", sol_new_cfunc(state, sol_f_try));
+	sol_map_set_name(state, globals, "type", sol_new_cfunc(state, sol_f_type));
+	sol_map_set_name(state, globals, "prepr", sol_new_cfunc(state, sol_f_prepr));
+	sol_map_set_name(state, globals, "print", sol_new_cfunc(state, sol_f_print));
+	sol_map_set_name(state, globals, "rawget", sol_new_cfunc(state, sol_f_rawget));
+	sol_map_set_name(state, globals, "rawset", sol_new_cfunc(state, sol_f_rawset));
+	sol_map_set_name(state, globals, "range", sol_new_cfunc(state, sol_f_range));
+	
+	sol_map_set_name(state, debug, "getref", sol_new_cfunc(state, sol_f_debug_getref));
+	sol_map_set_name(state, debug, "setref", sol_new_cfunc(state, sol_f_debug_setref));
+	sol_map_set_name(state, debug, "closure", sol_new_cfunc(state, sol_f_debug_closure));
+	sol_map_set_name(state, debug, "globals", sol_new_cfunc(state, sol_f_debug_globals));
+	sol_map_set_name(state, debug, "locals", sol_new_cfunc(state, sol_f_debug_locals));
+	sol_map_set_name(state, globals, "debug", debug);
+	sol_obj_free(debug);
+	
+	sol_map_set_name(state, iter, "str", sol_new_cfunc(state, sol_f_iter_str));
+	sol_map_set_name(state, iter, "list", sol_new_cfunc(state, sol_f_iter_list));
+	sol_map_set_name(state, iter, "map", sol_new_cfunc(state, sol_f_iter_map));
+	sol_map_set_name(state, globals, "iter", iter);
+	sol_obj_free(iter);
 	if(sol_has_error(state)) goto cleanup;
 
 	// We're all set!
@@ -224,7 +191,7 @@ sol_object_t *sol_state_resolve_name(sol_state_t *state, const char *name) {
 }
 
 void sol_state_assign(sol_state_t *state, sol_object_t *key, sol_object_t *val) {
-	sol_object_t *cur = state->scopes, *next;
+	sol_object_t *cur = state->scopes, *next, *active = NULL;
 
 	if(!cur) {
 		sol_set_error_string(state, "Global state does not exist");
@@ -234,10 +201,16 @@ void sol_state_assign(sol_state_t *state, sol_object_t *key, sol_object_t *val)
 	next = cur->lnext;
 	while(next) {
 		cur = next;
+		if(cur->lvalue) active = cur;
 		next = cur->lnext;
 	}
+	
+	if(!active) {
+		sol_set_error_string(state, "No scopes exist");
+		return;
+	}
 
-	sol_map_set(state, cur->lvalue, key, val);
+	sol_map_set(state, active->lvalue, key, val);
 }
 
 void sol_state_assign_name(sol_state_t *state, const char *name, sol_object_t *val) {
@@ -251,6 +224,8 @@ void sol_state_assign_name(sol_state_t *state, const char *name, sol_object_t *v
 
 void sol_state_assign_l(sol_state_t *state, sol_object_t *key, sol_object_t *val) {
 	sol_object_t *cur = state->scopes;
+	
+	while(cur && !cur->lvalue) cur = cur->lnext;
 
 	if(!cur) {
 		sol_set_error_string(state, "Local state does not exist");

test.sol

@@ -5,14 +5,16 @@ while a < 10 do
 end
 
 func mul9(b)
-	for i in range(len(b)) do
+	for i in range(#b) do
 		b[i] *= 9
 	end
 end
 
 l = [1 2 3 4 5]
 mul9(l)
-for i in iter(l) do print(i) end
+for i in l do print(i) end
+
+PI = 3.14159265358979
 
 d = {
 	integer = 1
@@ -22,10 +24,23 @@ d = {
 		health = 42.0
 	}
 	sublist = [1 1 2 3 5 8],
-	["this time with spaces"] = 2*PI,
+	["this time with spaces"] = PI*2,
 	[1 + 5] = 1 + 5
 }
 
-d["integer"]
-d.integer
+print(d)
+
+func bad(x)
+	x.c()
+end
+
+test1 = {c = func() end}
+test2 = {}
+
+print(try(bad, test1))
+print(try(bad, test2))
+
+print(d["integer"])
+print(d.integer)
 d.integer += 5
+print(d.integer)

tokenizer.lex

@@ -142,6 +142,10 @@ None { return NONE; }
 
 ">=" { return GREATEREQ; }
 
+">>" { return RSHIFT; }
+
+"<<" { return LSHIFT; }
+
 "{" { return LBRACE; }
 
 "}" { return RBRACE; }