add --output option to write bytecode to file

cmd/main.c

@@ -4,11 +4,127 @@
 #include "parse/lex.h"
 #include "io.h"
 #include "bitset.h"
+#include "bytecode.h"
 
 #include <stdio.h>
 #include <string.h>
 
-void step_through(struct l2_vm *vm) {
+static int do_print_bytecode = 0;
+static int do_print_tokens = 0;
+static int do_step = 0;
+static int do_serialize_bytecode = 0;
+static char *input_filename = "-";
+
+static int serialize_bytecode(FILE *outf, l2_word *data, size_t len) {
+	char header[4] = { 0x1b, 0x6c, 0x32, 0x63 };
+	if (fwrite(header, 1, 4, outf) < 4) {
+		fprintf(stderr, "Write error\n");
+		return -1;
+	}
+
+	char version[4] = {
+		(l2_bytecode_version & 0xff000000ul) >> 24,
+		(l2_bytecode_version & 0x00ff0000ul) >> 16,
+		(l2_bytecode_version & 0x0000ff00ul) >> 8,
+		(l2_bytecode_version & 0x000000fful) >> 0,
+	};
+	if (fwrite(version, 1, 4, outf) < 4) {
+		fprintf(stderr, "Write error\n");
+		return -1;
+	}
+
+	for (size_t i = 0; i < len; ++i) {
+		l2_word word = data[i];
+		char *dest = (char *)&data[i];
+		dest[0] = (word & 0xff000000ul) >> 24;
+		dest[1] = (word & 0x00ff0000ul) >> 16;
+		dest[2] = (word & 0x0000ff00ul) >> 8;
+		dest[3] = (word & 0x000000fful) >> 0;
+	}
+
+	if (fwrite(data, 4, len, outf) < len) {
+		fprintf(stderr, "Write error\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+static int load_bytecode(FILE *inf, struct l2_io_writer *w) {
+	// Header is already read by main
+
+	char version_buf[4];
+	if (fread(version_buf, 1, 4, inf) < 4) {
+		fprintf(stderr, "Read error\n");
+		return -1;
+	}
+
+	int version = 0 |
+		((unsigned int)version_buf[0]) << 24 |
+		((unsigned int)version_buf[1]) << 16 |
+		((unsigned int)version_buf[2]) << 8 |
+		((unsigned int)version_buf[3]) << 0;
+	if (version != l2_bytecode_version) {
+		fprintf(
+				stderr, "Version mismatch! Bytecode file uses bytecode version %i"
+				", but your build of lang2 uses bytecode version %i\n",
+				version, l2_bytecode_version);
+		return -1;
+	}
+
+	struct l2_bufio_writer writer;
+	l2_bufio_writer_init(&writer, w);
+
+	char buffer[4096];
+
+	while (1) {
+		size_t n = fread(buffer, 1, sizeof(buffer), inf);
+		if (n < 4) {
+			l2_bufio_flush(&writer);
+			return 0;
+		}
+
+		for (size_t i = 0; i < n; i += 4) {
+			l2_word word = 0 |
+				((unsigned int)buffer[i + 0]) << 24 |
+				((unsigned int)buffer[i + 1]) << 16 |
+				((unsigned int)buffer[i + 2]) << 8 |
+				((unsigned int)buffer[i + 3]) << 0;
+			l2_bufio_put_n(&writer, &word, 4);
+		}
+
+	}
+}
+
+static int parse_text(FILE *inf, struct l2_io_writer *w) {
+	// Init lexer with its input reader
+	struct l2_io_file_reader r;
+	r.r.read = l2_io_file_read;
+	r.f = inf;
+	struct l2_lexer lexer;
+	l2_lexer_init(&lexer, &r.r);
+	if (do_print_tokens) {
+		lexer.do_log_tokens = 1;
+	}
+
+	// Init gen with its output writer
+	struct l2_generator gen;
+	l2_gen_init(&gen, w);
+
+	struct l2_parse_error err;
+	if (l2_parse_program(&lexer, &gen, &err) < 0) {
+		fprintf(stderr, "Parse error: %s:%i:%i: %s\n",
+				input_filename, err.line, err.ch, err.message);
+		l2_gen_free(&gen);
+		fclose(inf);
+		return -1;
+	}
+
+	l2_gen_free(&gen);
+	return 0;
+}
+
+static void step_through(struct l2_vm *vm) {
 	printf("=====\n\nInitial state:\n");
 	l2_vm_print_state(vm);
 
@@ -17,7 +133,10 @@ void step_through(struct l2_vm *vm) {
 		size_t iptr = vm->iptr;
 		printf("\n======\n\n(%d) Will run instr: ", vm->iptr);
 		l2_vm_print_op(vm->ops, vm->opcount, &iptr);
-		fgets(buf, sizeof(buf), stdin);
+		if (fgets(buf, sizeof(buf), stdin) == NULL) {
+			break;
+		}
+
 		l2_vm_step(vm);
 		l2_vm_print_state(vm);
 	}
@@ -27,19 +146,17 @@ static void usage(const char *argv0) {
 	printf("Usage: %s [options] [input|-]\n", argv0);
 	printf("\n");
 	printf("Options:\n");
-	printf("  --help:      Print this help text\n");
-	printf("  --bytecode:  Print the generated bytecode, don't execute\n");
-	printf("  --tokens:    Print the tokens as the program is parsed, don't execute\n");
-	printf("  --step:      Step through the program\n");
+	printf("  --help:            Print this help text\n");
+	printf("  --bytecode:        Print the generated bytecode, don't execute\n");
+	printf("  --tokens:          Print the tokens as the program is parsed, don't execute\n");
+	printf("  --step:            Step through the program\n");
+	printf("  --output,-o <out>: Write bytecode to file\n");
 }
 
 int main(int argc, char **argv) {
-	int do_print_bytecode = 0;
-	int do_print_tokens = 0;
-	int do_step = 0;
-
 	int was_inf_set = 0;
 	FILE *inf = stdin;
+	FILE *outbc = NULL;
 
 	int dashes = 0;
 	for (int i = 1; i < argc; ++i) {
@@ -52,11 +169,31 @@ int main(int argc, char **argv) {
 			do_print_tokens = 1;
 		} else if (!dashes && strcmp(argv[i], "--step") == 0) {
 			do_step = 1;
+		} else if (!dashes && (
+				strcmp(argv[i], "--output") == 0 || strcmp(argv[i], "-o") == 0)) {
+			if (i == argc - 1) {
+				fprintf(stderr, "%s expects an argument\n", argv[i]);
+				return 1;
+			}
+
+			do_serialize_bytecode = 1;
+			i += 1;
+			if (strcmp(argv[i], "-") == 0) {
+				outbc = stdout;
+			} else {
+				outbc = fopen(argv[i], "w");
+				if (outbc == NULL) {
+					perror(argv[i]);
+					return 1;
+				}
+			}
 		} else if (strcmp(argv[i], "--") == 0) {
 			dashes = 1;
 		} else if (strcmp(argv[i], "-") == 0) {
+			input_filename = "-";
 			inf = stdin;
 		} else if (!was_inf_set) {
+			input_filename = argv[i];
 			inf = fopen(argv[i], "r");
 			was_inf_set = 1;
 			if (inf == NULL) {
@@ -70,45 +207,55 @@ int main(int argc, char **argv) {
 		}
 	}
 
-	// Init lexer with its input reader
-	struct l2_io_file_reader r;
-	r.r.read = l2_io_file_read;
-	r.f = inf;
-	struct l2_lexer lexer;
-	l2_lexer_init(&lexer, &r.r);
-	if (do_print_tokens) {
-		lexer.do_log_tokens = 1;
-	}
-
-	// Init gen with its output writer
-	struct l2_io_mem_writer w = {0};
-	w.w.write = l2_io_mem_write;
-	struct l2_generator gen;
-	l2_gen_init(&gen, &w.w);
+	struct l2_io_mem_writer bytecode_writer = {0};
+	bytecode_writer.w.write = l2_io_mem_write;
 
-	struct l2_parse_error err;
-	if (l2_parse_program(&lexer, &gen, &err) < 0) {
-		fprintf(stderr, "Parse error: %s:%i:%i: %s\n",
-				(argc == 2 ? argv[1] : "-"), err.line, err.ch, err.message);
-		l2_gen_free(&gen);
-		fclose(inf);
+	// 
+	int headerbyte = fgetc(inf);
+	if (headerbyte == EOF || ungetc(headerbyte, inf) == EOF) {
+		fprintf(stderr, "%s: Reading file failed.\n", input_filename);
 		return 1;
 	}
 
-	l2_gen_free(&gen);
+	// Detect whether input is compiled bytecode or not
+	// (compile bytecode starts with (ESC) 'l' '2' 'c')
+	unsigned char header[4];
+	if (
+			headerbyte == 0x1b &&
+			fread(header, 1, 4, inf) >= 4 &&
+			header[0] == 0x1b && header[1] == 0x6c &&
+			header[2] == 0x32 && header[3] == 0x63) {
+		if (load_bytecode(inf, &bytecode_writer.w) < 0) {
+			return 1;
+		}
+	} else if (headerbyte == 0x1b) {
+		fprintf(
+				stderr, "%s: Corrupt file? Start byte is 0x1b (ESC)"
+				"but the header is wrong\n",
+				input_filename);
+		return 1;
+	} else {
+		if (parse_text(inf, &bytecode_writer.w) < 0) {
+			return 1;
+		}
+	}
 	fclose(inf);
 
 	if (do_print_bytecode) {
-		l2_vm_print_bytecode(w.mem, w.len / sizeof(l2_word));
+		l2_vm_print_bytecode(bytecode_writer.mem, bytecode_writer.len / sizeof(l2_word));
+	}
+
+	if (do_serialize_bytecode) {
+		serialize_bytecode(outbc, bytecode_writer.mem, bytecode_writer.len / sizeof(l2_word));
 	}
 
-	if (do_print_bytecode || do_print_tokens) {
-		free(w.mem);
+	if (do_print_bytecode || do_print_tokens || do_serialize_bytecode) {
+		free(bytecode_writer.mem);
 		return 0;
 	}
 
 	struct l2_vm vm;
-	l2_vm_init(&vm, w.mem, w.len / sizeof(l2_word));
+	l2_vm_init(&vm, bytecode_writer.mem, bytecode_writer.len / sizeof(l2_word));
 
 	if (do_step) {
 		step_through(&vm);
@@ -117,5 +264,5 @@ int main(int argc, char **argv) {
 	}
 
 	l2_vm_free(&vm);
-	free(w.mem);
+	free(bytecode_writer.mem);
 }

include/lang2/bytecode.h

@@ -5,6 +5,8 @@
 
 typedef uint32_t l2_word;
 
+#define l2_bytecode_version 1
+
 enum l2_opcode {
 	/*
 	 * Do nothing.