Some improvements to debug output before I move on to a marshalling format

chunk.c

@@ -6,21 +6,34 @@ void krk_initChunk(KrkChunk * chunk) {
 	chunk->count = 0;
 	chunk->capacity = 0;
 	chunk->code = NULL;
+
+	chunk->linesCount = 0;
+	chunk->linesCapacity = 0;
 	chunk->lines = NULL;
 	chunk->filename = NULL;
 	krk_initValueArray(&chunk->constants);
 }
 
+static void addLine(KrkChunk * chunk, size_t line) {
+	if (chunk->linesCount && chunk->lines[chunk->linesCount-1].line == line) return;
+	if (chunk->linesCapacity < chunk->linesCount + 1) {
+		int old = chunk->linesCapacity;
+		chunk->linesCapacity = GROW_CAPACITY(old);
+		chunk->lines = GROW_ARRAY(KrkLineMap, chunk->lines, old, chunk->linesCapacity);
+	}
+	chunk->lines[chunk->linesCount] = (KrkLineMap){chunk->count, line};
+	chunk->linesCount++;
+}
+
 void krk_writeChunk(KrkChunk * chunk, uint8_t byte, size_t line) {
 	if (chunk->capacity < chunk->count + 1) {
 		int old = chunk->capacity;
 		chunk->capacity = GROW_CAPACITY(old);
 		chunk->code = GROW_ARRAY(uint8_t, chunk->code, old, chunk->capacity);
-		chunk->lines = GROW_ARRAY(size_t, chunk->lines, old, chunk->capacity);
 	}
 
 	chunk->code[chunk->count] = byte;
-	chunk->lines[chunk->count] = line;
+	addLine(chunk, line);
 	chunk->count++;
 }
 

chunk.h

@@ -89,6 +89,11 @@ typedef enum {
 	OP_INLINE_FUNCTION,
 } KrkOpCode;
 
+typedef struct {
+	size_t startOffset;
+	size_t line;
+} KrkLineMap;
+
 /**
  * Bytecode chunks
  */
@@ -96,7 +101,11 @@ typedef struct {
 	size_t  count;
 	size_t  capacity;
 	uint8_t * code;
-	size_t * lines;
+
+	size_t linesCount;
+	size_t linesCapacity;
+	KrkLineMap * lines;
+
 	KrkString * filename;
 	KrkValueArray constants;
 } KrkChunk;

compiler.c

@@ -312,7 +312,19 @@ static KrkFunction * endCompiler() {
 	KrkFunction * function = current->function;
 #ifdef ENABLE_DISASSEMBLY
 	if ((vm.flags & KRK_ENABLE_DISASSEMBLY) && !parser.hadError) {
-		krk_disassembleChunk(currentChunk(), function->name != NULL ? function->name->chars : "<module>");
+		krk_disassembleChunk(currentChunk(), function->name ? function->name->chars : "<module>");
+		fprintf(stderr, "Function metadata: requiredArgs=%d defaultArgs=%d upvalueCount=%d\n",
+			function->requiredArgs, function->defaultArgs, (int)function->upvalueCount);
+		fprintf(stderr, "__doc__: \"%s\"\n", function->docstring ? function->docstring->chars : "");
+		fprintf(stderr, "Constants: ");
+		for (size_t i = 0; i < currentChunk()->constants.count; ++i) {
+			fprintf(stderr, "%d: ", (int)i);
+			krk_printValueSafe(stderr, currentChunk()->constants.values[i]);
+			if (i != currentChunk()->constants.count - 1) {
+				fprintf(stderr, ", ");
+			}
+		}
+		fprintf(stderr, "\n");
 	}
 #endif
 

debug.c

@@ -4,7 +4,7 @@
 #include "vm.h"
 
 void krk_disassembleChunk(KrkChunk * chunk, const char * name) {
-	fprintf(stderr, "[%s]\n", name);
+	fprintf(stderr, "[%s from %s]\n", name, chunk->filename->chars);
 	for (size_t offset = 0; offset < chunk->count;) {
 		offset = krk_disassembleInstruction(chunk, offset);
 	}
@@ -12,16 +12,16 @@ void krk_disassembleChunk(KrkChunk * chunk, const char * name) {
 
 #define SIMPLE(opc) case opc: fprintf(stderr, "%s\n", #opc); return offset + 1;
 #define CONSTANT(opc,more) case opc: { size_t constant = chunk->code[offset + 1]; \
-	fprintf(stderr, "%-16s %4d '", #opc, (int)constant); \
+	fprintf(stderr, "%-16s %4d ", #opc, (int)constant); \
 	krk_printValueSafe(stderr, chunk->constants.values[constant]); \
-	fprintf(stderr,"' (type=%s)\n", krk_typeName(chunk->constants.values[constant])); \
+	fprintf(stderr," (type=%s)\n", krk_typeName(chunk->constants.values[constant])); \
 	more; \
 	return offset + 2; } \
 	case opc ## _LONG: { size_t constant = (chunk->code[offset + 1] << 16) | \
 	(chunk->code[offset + 2] << 8) | (chunk->code[offset + 3]); \
-	fprintf(stderr, "%-16s %4d '", #opc "_LONG", (int)constant); \
+	fprintf(stderr, "%-16s %4d ", #opc "_LONG", (int)constant); \
 	krk_printValueSafe(stderr, chunk->constants.values[constant]); \
-	fprintf(stderr,"' (type=%s)\n", krk_typeName(chunk->constants.values[constant])); \
+	fprintf(stderr," (type=%s)\n", krk_typeName(chunk->constants.values[constant])); \
 	more; \
 	return offset + 4; }
 #define OPERANDB(opc) case opc: { uint32_t operand = chunk->code[offset + 1]; \
@@ -46,12 +46,21 @@ void krk_disassembleChunk(KrkChunk * chunk, const char * name) {
 			(int)offset - 2, isLocal ? "local" : "upvalue", index); \
 	}
 
+size_t krk_lineNumber(KrkChunk * chunk, size_t offset) {
+	size_t line = 0;
+	for (size_t i = 0; i < chunk->linesCount; ++i) {
+		if (chunk->lines[i].startOffset > offset) break;
+		line = chunk->lines[i].line;
+	}
+	return line;
+}
+
 size_t krk_disassembleInstruction(KrkChunk * chunk, size_t offset) {
 	fprintf(stderr, "%04u ", (unsigned int)offset);
-	if (offset > 0 && chunk->lines[offset] == chunk->lines[offset - 1]) {
+	if (offset > 0 && krk_lineNumber(chunk, offset) == krk_lineNumber(chunk, offset - 1)) {
 		fprintf(stderr, "   | ");
 	} else {
-		fprintf(stderr, "%4d ", (int)chunk->lines[offset]);
+		fprintf(stderr, "%4d ", (int)krk_lineNumber(chunk, offset));
 	}
 	uint8_t opcode = chunk->code[offset];
 

debug.h

@@ -4,3 +4,4 @@
 
 extern void krk_disassembleChunk(KrkChunk * chunk, const char * name);
 extern size_t krk_disassembleInstruction(KrkChunk * chunk, size_t offset);
+extern size_t krk_lineNumber(KrkChunk * chunk, size_t offset);

value.c

@@ -59,6 +59,7 @@ void krk_printValueSafe(FILE * f, KrkValue printable) {
 		fprintf(f, "\"%s\"", AS_CSTRING(printable));
 	} else {
 		switch (AS_OBJECT(printable)->type) {
+			case OBJ_FUNCTION: fprintf(f, "<function %s>", AS_FUNCTION(printable)->name ? AS_FUNCTION(printable)->name->chars : "?"); break;
 			case OBJ_CLASS: fprintf(f, "<class %s>", AS_CLASS(printable)->name ? AS_CLASS(printable)->name->chars : "?"); break;
 			case OBJ_INSTANCE: fprintf(f, "<instance of %s>", AS_INSTANCE(printable)->_class->name->chars); break;
 			case OBJ_NATIVE: fprintf(f, "<nativefn %s>", ((KrkNative*)AS_OBJECT(printable))->name); break;

vm.c

@@ -51,7 +51,7 @@ static void dumpTraceback() {
 		size_t instruction = frame->ip - function->chunk.code - 1;
 		fprintf(stderr, "  File \"%s\", line %d, in %s\n",
 			(function->chunk.filename ? function->chunk.filename->chars : "?"),
-			(int)function->chunk.lines[instruction],
+			(int)krk_lineNumber(&function->chunk, instruction),
 			(function->name ? function->name->chars : "(unnamed)"));
 	}