v0.13.1 (#470)

* v0.13.1

* clean up for C++

* avoid memleak

* fix fallthrough for mathc

* clean up list sorting implementation

* list sort WIP

* add list sorting logic but leave disabled for now

* update macOS pipelines

* clean up

* make list methods static

* allow defining globals from command line

* fix for C++

* fix mem leak

* fix version

* clean up compiler implementation

* Explicitly state that the function array does not need to be mutable (#476)

* clean up init of state

* fix bug with ref counting in comparison operators

* add newline

---------

Co-authored-by: Ryan Andersen <[email protected]>

Author: CoffeeTableEspresso

azure-pipelines.yml

@@ -198,7 +198,7 @@ jobs:
 - job: 
   displayName: "C Clang MacOS"
   pool:
-    vmImage: 'macOS-10.15'
+    vmImage: 'macOS-11'
   steps:
   - script: |
       set -e
@@ -218,7 +218,7 @@ jobs:
 - job: 
   displayName: "C++ Clang MacOS"
   pool:
-    vmImage: 'macOS-10.15'
+    vmImage: 'macOS-11'
   steps:
   - script: |
       set -e

compiler/parser.c

@@ -851,6 +851,12 @@ static struct Node *parse_match(struct Parser *const parser) {
 		eattok(parser, T_SEMI);
 	}
 	eattok(parser, T_RBRC);
+
+	struct Node *n = new_Undef(parser, line);
+	n->nodetype = N_PATANY;
+	body_append(parser, &pats, n);
+	body_append(parser, &guards, NULL);
+	body_append(parser, &bodies, new_Body(parser, line));
 	return new_Match(parser, expr, pats, guards, bodies, line);
 }
 
@@ -1266,10 +1272,23 @@ static struct Node *parse_string(struct Parser *const parser) {
 		eattok(parser, T_LBRC);
 		parser->lex.mode = L_NORMAL;
 		struct Node *expr = parse_expr(parser);
-		parser->lex.mode = L_INTERP;
 		const size_t line = parserline(parser);
+
+		// Handle format strings
+		if (matcheattok(parser, T_COLON)) {
+			struct Node *fmt = parse_id(parser);
+			fmt->nodetype = N_STR;
+			const size_t line = parserline(parser);
+			struct Node *block = new_Exprs(parser, line);
+			body_append(parser, &block, fmt);
+			static char tostr[] = "tostr";
+			expr = new_MethodCall(parser, block, expr, tostr, 1, line);
+		}
+
 		cur_node = new_BinOp(parser, T_TILDE, cur_node, expr, line);
 
+		parser->lex.mode = L_INTERP;
+
 		if (parser->lex.c == '}') {
 			parser->lex.c = lxgetc(parser->lex.file);
 		} else {

data-structures/YASL_ByteBuffer.h

@@ -21,7 +21,6 @@ void YASL_ByteBuffer_del(YASL_ByteBuffer *const bb);
 
 void YASL_ByteBuffer_extend(YASL_ByteBuffer *const bb, const byte *const bytes, const size_t bytes_len);
 #define YASL_ByteBuffer_add_byte BUFFER_PUSH(byte)
-// void YASL_ByteBuffer_add_byte(YASL_ByteBuffer *const buffer, const byte v);
 void YASL_ByteBuffer_add_vint(YASL_ByteBuffer *const bb, size_t val);
 void YASL_ByteBuffer_add_float(YASL_ByteBuffer *const bb, const yasl_float value);
 void YASL_ByteBuffer_add_int(YASL_ByteBuffer *const bb, const yasl_int value);

interpreter/VM.c

@@ -529,19 +529,21 @@ static void vm_CNCT(struct VM *const vm) {
 
 #define DEFINE_COMP(name, opstr, overload_name) \
 static void vm_##name(struct VM *const vm) {\
-	struct YASL_Object right = vm_pop(vm);\
-	struct YASL_Object left = vm_pop(vm);\
+	struct YASL_Object right = vm_peek(vm);\
+	struct YASL_Object left = vm_peek(vm, vm->sp -1);\
 	bool c;\
 	if (obj_isstr(&left) && obj_isstr(&right)) {\
+		vm_pop(vm);\
+		vm_pop(vm);\
 		vm_pushbool(vm, name(YASL_String_cmp(obj_getstr(&left), obj_getstr(&right)), 0));\
 		return;\
 	}\
 	if (obj_isnum(&left) && obj_isnum(&right)) {\
+		vm_pop(vm);\
+		vm_pop(vm);\
 		COMP(vm, left, right, name);\
 		return;\
 	}\
-	vm_push(vm, left);\
-	vm_push(vm, right);\
 	vm_call_binop_method_now(vm, left, right, overload_name, "%s not supported for operands of types %s and %s.",\
 	opstr,\
 	obj_typename(&left),\

interpreter/list_methods.c

@@ -395,71 +395,119 @@ int list_count(struct YASL_State *S) {
 	return 1;
 }
 
-static const int SORT_TYPE_EMPTY = 0;
-static const int SORT_TYPE_STR = -1;
-static const int SORT_TYPE_NUM = 1;
-void sort(struct YASL_Object *list, const size_t len) {
-	// Base cases
-	struct YASL_Object tmpObj;
-	if (len < 2) return;
-	if (len == 2) {
-		if (yasl_object_cmp(list[0], list[1]) > 0) {
-			tmpObj = list[0];
-			list[0] = list[1];
-			list[1] = tmpObj;
-		}
-		return;
+enum SortType {
+	SORT_TYPE_STR = -1,
+	SORT_TYPE_EMPTY = 0,
+	SORT_TYPE_NUM = 1
+};
+
+
+int custom_comp(struct YASL_State *S, struct YASL_Object a, struct YASL_Object b) {
+	YASL_duptop(S);
+	vm_push((struct VM *)S, a);
+	vm_push((struct VM *)S, b);
+	YASL_functioncall(S, 2);
+	if (!YASL_isbool(S)) {
+		YASL_print_err(S, "TypeError: Expected a function returning bool, got %s.", YASL_peektypename(S));
+		YASL_throw_err(S, YASL_TYPE_ERROR);
 	}
-
-	// YASL_Set sorting bounds
-	size_t left = 0;
-	size_t right = len - 1;
-
-	// Determine random midpoint to use (good average case)
-	const size_t randIndex = rand() % len;
-	const struct YASL_Object mid = list[randIndex];
-
-	// Determine exact number of items less than mid (mid's index)
-	// Furthermore, ensure list is not homogenous to avoid infinite loops
-	size_t ltCount = 0;
-	int seenDifferent = 0;
-	for (size_t i = 0; i < len; i++) {
-		if (yasl_object_cmp(list[i], mid) < 0) ltCount++;
-		if (seenDifferent == 0 && yasl_object_cmp(list[0], list[i]) != 0) seenDifferent = 1;
+	bool a_lt_b = YASL_popbool(S);
+
+	YASL_duptop(S);
+	vm_push((struct VM *)S, b);
+	vm_push((struct VM *)S, a);
+	YASL_functioncall(S, 2);
+	if (!YASL_isbool(S)) {
+		YASL_print_err(S, "TypeError: Expected a function returning bool, got %s.", YASL_peektypename(S));
+		YASL_throw_err(S, YASL_TYPE_ERROR);
 	}
-	if (seenDifferent == 0) return;
 
-	// Ensure all items are on the correct side of mid
-	while (left < right) {
-		while (yasl_object_cmp(list[left], mid) < 0) left++;
-		while (yasl_object_cmp(list[right], mid) >= 0) {
-			if (right == 0) break;
-			right--;
-		}
+	bool a_gt_b = YASL_popbool(S);
 
-		int cmp = yasl_object_cmp(list[left], list[right]);
-		if (cmp > 0 && left < right) {
-			tmpObj = list[right];
-			list[right] = list[left];
-			list[left++] = tmpObj;
-			if (right == 0) break;
-			right--;
-		} else if (cmp == 0) {
-			left++;
-			if (right == 0) break;
-			right--;
-		}
-	}
+	if (a_lt_b == a_gt_b) return 0;
+	return a_lt_b ? -1 : a_gt_b ? 1 : 0;
+}
 
-	// Let sort() finish that for us...
-	sort(list, ltCount);
-	sort(&list[ltCount], len - ltCount);
+#define CUSTOM_COMP(a, b) custom_comp(S, a, b)
+
+#define DEF_SORT(name, COMP) \
+static void name##sort(struct YASL_State *S, struct YASL_Object *list, const size_t len) {\
+	/* Base cases*/ \
+	struct YASL_Object tmpObj;\
+	if (len < 2) return;\
+	if (len == 2) {\
+		if (COMP(list[0], list[1]) > 0) {\
+			tmpObj = list[0];\
+			list[0] = list[1];\
+			list[1] = tmpObj;\
+		}\
+		return;\
+	}\
+\
+	/* YASL_Set sorting bounds */\
+	size_t left = 0;\
+	size_t right = len - 1;\
+\
+	/* Determine random midpoint to use (good average case) */\
+	const size_t randIndex = rand() % len;\
+	const struct YASL_Object mid = list[randIndex];\
+\
+	/* Determine exact number of items less than mid (mid's index)\
+	   Furthermore, ensure list is not homogeneous to avoid infinite loops */\
+	size_t ltCount = 0;\
+	bool seenDifferent = false;\
+	for (size_t i = 0; i < len; i++) {\
+		if (COMP(list[i], mid) < 0) ltCount++;\
+		if (seenDifferent == 0 && COMP(list[0], list[i]) != 0) seenDifferent = true;\
+	}\
+	if (!seenDifferent) return;\
+\
+	/* Ensure all items are on the correct side of mid */\
+	while (left < right) {\
+		while (COMP(list[left], mid) < 0) left++;\
+		while (COMP(list[right], mid) >= 0) {\
+			if (right == 0) break;\
+			right--;\
+		}\
+\
+		int cmp = COMP(list[left], list[right]);\
+		if (cmp > 0 && left < right) {\
+			tmpObj = list[right];\
+			list[right] = list[left];\
+			list[left++] = tmpObj;\
+			if (right == 0) break;\
+			right--;\
+		} else if (cmp == 0) {\
+			left++;\
+			if (right == 0) break;\
+			right--;\
+		}\
+	}\
+\
+	/* Let sort() finish that for us...*/ \
+	name##sort(S, list, ltCount);\
+	name##sort(S, &list[ltCount], len - ltCount);\
 }
 
+DEF_SORT(default, yasl_object_cmp)
+// DEF_SORT(fn, CUSTOM_COMP)
+
 // TODO: clean this up
 int list_sort(struct YASL_State *S) {
 	struct YASL_List *list = YASLX_checknlist(S, "list.sort", 0);
-	int type = SORT_TYPE_EMPTY;
+
+	/*
+	if (!YASL_isundef(S)) {
+		fnsort(S, list->items, list->count);
+		return 0;
+	}
+	 */
+
+	if (YASL_List_length(list) <= 1) {
+		return 0;
+	}
+
+	enum SortType type = SORT_TYPE_EMPTY;
 
 	int err = 0;
 	for (size_t i = 0; i < list->count; i++) {
@@ -489,7 +537,7 @@ int list_sort(struct YASL_State *S) {
 	}
 
 	if (type != SORT_TYPE_EMPTY) {
-		sort(list->items, list->count);
+		defaultsort(S, list->items, list->count);
 	}
 
 	return 0;

main.c

@@ -56,17 +56,47 @@ static inline void main_init_platform() {
 }
 
 static int main_file(int argc, char **argv) {
-	(void) argc;
-	struct YASL_State *S = YASL_newstate(argv[1]);
+	YASL_ByteBuffer *buffer = YASL_ByteBuffer_new(8);
+	struct YASL_State *S = YASL_newstate_bb(NULL, 0);
+	// Load Standard Libraries
+	YASLX_decllibs(S);
+
+	while (argc > 1 && !strncmp(argv[1], "-D", 2)) {
+		const char *equals = strchr(argv[1], '=');
+		if (!equals) {
+			fprintf(stderr, "Error: Expected an initial value for variable: %s\n", argv[1] + 2);
+			exit(EXIT_FAILURE);
+		}
+		const long int len = equals - argv[1] -2;
+		if (len <= 0) {
+			fprintf(stderr, "Error: Non-empty name required for variable: %s\n", argv[1] + 2);
+			exit(EXIT_FAILURE);
+		}
+		char *name = (char *)malloc(len + 1);
+		strncpy(name, argv[1] + 2, len);
+		name[len] = '\0';
+		puts(name);
+		YASL_declglobal(S, name);
+		YASL_pushundef(S);
+		YASL_setglobal(S, name);
+
+		YASL_ByteBuffer_extend(buffer, (unsigned char *)argv[1] + 2,  strlen(argv[1]) - 2 );
+		YASL_ByteBuffer_add_byte(buffer, '\n');
+		YASL_resetstate_bb(S, (char *)buffer->items, buffer->count);
+		buffer->count = 0;
+		YASL_execute(S);
+
+		argc--;
+		argv++;
+	}
+
+	YASL_resetstate(S, argv[argc - 1]);
 
 	if (!S) {
 		puts("ERROR: cannot open file.");
 		exit(EXIT_FAILURE);
 	}
 
-	// Load Standard Libraries
-	YASLX_decllibs(S);
-
 	YASL_declglobal(S, "args");
 	YASL_pushlist(S);
 	for (int i = 1; i < argc; i++) {
@@ -78,6 +108,7 @@ static int main_file(int argc, char **argv) {
 	int status = YASL_execute(S);
 
 	YASL_delstate(S);
+	YASL_ByteBuffer_del(buffer);
 
 	return status;
 }
@@ -87,7 +118,7 @@ static int main_compile(int argc, char **argv) {
 	struct YASL_State *S = YASL_newstate(argv[2]);
 
 	if (!S) {
-		puts("ERROR: cannot open file.");
+		fprintf(stderr, "Error: cannot open file.");
 		exit(EXIT_FAILURE);
 	}
 
@@ -113,7 +144,7 @@ static int main_gen_bytecode(int argc, char **argv) {
 	struct YASL_State *S = YASL_newstate(argv[2]);
 
 	if (!S) {
-		puts("ERROR: cannot open file.");
+		fprintf(stderr, "Error: cannot open file.");
 		exit(EXIT_FAILURE);
 	}
 
@@ -213,14 +244,17 @@ int main(int argc, char **argv) {
 }
 #else
 int main(int argc, char **argv) {
+	// These don't require any state, so just return immediately.
+	if (argc == 2 && !strcmp(argv[1], "-h")) {
+		return main_help(argc, argv);
+	} else if (argc == 2 && !strcmp(argv[1], "-V")) {
+		return main_version(argc, argv);
+	}
+
 	main_init_platform();
 
 	if (argc == 1) {
 		return main_REPL(argc, argv);
-	} else if (argc == 2 && !strcmp(argv[1], "-h")) {
-		return main_help(argc, argv);
-	} else if (argc == 2 && !strcmp(argv[1], "-V")) {
-		return main_version(argc, argv);
 	} else if (argc == 3 && !strcmp(argv[1], "-e")) {
 		return main_command_REPL(argc, argv);
 	} else if (argc == 3 && !strcmp(argv[1], "-E")) {

opcode.h

@@ -23,7 +23,6 @@ enum Opcode {
 	O_ASS = 0x50, // assert
 	O_ASSERT_STACK_HEIGHT = 0x58,
 
-
 	O_ADD = 0x60, // add two numbers
 	O_SUB = 0x61, // subtract two numbers
 	O_MUL = 0x62, // multiply two integers

test/errors/type/list/__lt.yasl

@@ -0,0 +1,2 @@
+echo [] < []
+

test/errors/type/list/__lt.yasl.err

@@ -0,0 +1 @@
+TypeError: < not supported for operands of types list and list. (line 1)

test/inputs.inl

@@ -129,6 +129,7 @@ static const char *inputs[] = {
   "test/inputs/match/alt/alt_nested_right.yasl",
   "test/inputs/match/alt/alt_nested_left.yasl",
   "test/inputs/match/alt/alt.yasl",
+  "test/inputs/match/fallthrough.yasl",
   "test/inputs/match/basic_1.yasl",
   "test/inputs/match/bool.yasl",
   "test/inputs/match/list/const_vlist.yasl",