Implement explicit imports (closes #44, closes KnightOS/KnightOS#179)

pixelherodev · Noam Preil · commit d98554931197 · 2019-09-28T00:58:09.000-04:00
diff --git a/assembler/assembler.c b/assembler/assembler.c
@@ -310,6 +310,7 @@ int try_add_label(struct assembler_state *state, char **line) {
 	sym->defined_address = state->current_area->data_length;
 	sym->exported = 1; /* TODO: Support explicit export */
 	list_add(state->current_area->symbols, sym);
+	list_add(state->object->imports, sym->name);
 	scas_log(L_DEBUG, "Added label '%s' (pre-linking value 0x%08X) from %s:%d", sym->name, sym->value,
 			(char *)stack_peek(state->file_name_stack), *(int *)stack_peek(state->line_number_stack));
 	/* Modify this line so that processing may continue */
@@ -354,7 +355,19 @@ int try_match_instruction(struct assembler_state *state, char **_line) {
 				result = evaluate_expression(expression, state->equates, &error, &symbol);
 			}
 			if (error == EXPRESSION_BAD_SYMBOL) {
-				/* TODO: Throw error if using explicit import */
+				if (scas_runtime.options.explicit_import) {
+					unresolved_symbol_t *unresolved_sym = malloc(sizeof(unresolved_symbol_t));
+					unresolved_sym->name = malloc(strlen(symbol)+1);
+					strcpy(unresolved_sym->name,symbol);
+					unresolved_sym->column = state->column;
+					unresolved_sym->line_number = *(int*)stack_peek(state->line_number_stack);
+					unresolved_sym->line = malloc(strlen(state->line) + 1);
+					strcpy(unresolved_sym->line,state->line);
+					const char *file_name = stack_peek(state->file_name_stack);
+					unresolved_sym->file_name = malloc(sizeof(file_name)+1);
+					strcpy(unresolved_sym->file_name,file_name);
+					list_add(state->object->unresolved,unresolved_sym);
+				}
 				scas_log(L_DEBUG, "Postponing evaluation of '%s' to linker", ref->value_provided);
 				late_immediate_t *late_imm = malloc(sizeof(late_immediate_t));
 				late_imm->instruction_address = state->current_area->data_length;
@@ -569,8 +582,25 @@ object_t *assemble(FILE *file, const char *file_name, assembler_settings_t *sett
 				fclose(cur);
 				stack_pop(state.file_stack);
 				stack_pop(state.source_map_stack);
-				scas_log(L_INFO, "Returning to file '%s'", (char *)stack_peek(state.file_name_stack));
+				scas_log(L_INFO, "Returning to file '%s'",
+					(char *)stack_peek(state.file_name_stack));
 			} else {
+				for (int i = 0; i < state.object->unresolved->length; i++) {
+					unresolved_symbol_t *sym = (unresolved_symbol_t*)
+						state.object->unresolved->items[i];
+					bool imported = false;
+					for (int j = 0; j < state.object->imports->length; j++) {
+						if (strcmp(sym->name, state.object->imports->items[j]) == 0) {
+							imported = true;
+							break;
+						}
+					}
+					if (!imported) {
+						add_error(state.errors, ERROR_UNKNOWN_SYMBOL,
+							sym->line_number, sym->line, sym->column,
+							sym->file_name, sym->name);
+					}
+				}
 				break;
 			}
 		}
diff --git a/assembler/directives.c b/assembler/directives.c
@@ -1,4 +1,5 @@
 #include "directives.h"
+#include "assembler.h"
 #include "errors.h"
 #include "functions.h"
 #include "expression.h"
@@ -22,6 +23,10 @@
 		*(int*)stack_peek(state->line_number_stack), \
 		state->line, COLUMN, stack_peek(state->file_name_stack) , ##__VA_ARGS__);
 
+#define WARN(WARN_CODE, COLUMN, ...) add_warning(state->warnings, WARN_CODE, \
+		*(int*)stack_peek(state->line_number_stack), \
+		state->line, COLUMN, stack_peek(state->file_name_stack) , ##__VA_ARGS__);
+
 #define MAP_SOURCE(LENGTH) if (!state->expanding_macro && state->auto_source_maps) { \
 			add_source_map((source_map_t *)stack_peek(state->source_map_stack), \
 			*(int*)stack_peek(state->line_number_stack), state->line, \
@@ -226,7 +231,27 @@ int handle_db(struct assembler_state *state, char **argv, int argc) {
 			}
 
 			if (error == EXPRESSION_BAD_SYMBOL) {
-				/* TODO: Throw error if using explicit import */
+				
+				if (scas_runtime.options.explicit_import) {
+					tokenized_expression_t *changed_expression = malloc(sizeof(tokenized_expression_t));
+					memcpy(changed_expression, expression, sizeof(tokenized_expression_t));
+					int ignored_error;
+					char *fixed_symbol;
+					transform_local_labels(changed_expression, state->last_global_label);
+					evaluate_expression(expression, state->equates, &ignored_error, &fixed_symbol);
+					unresolved_symbol_t *unresolved_sym = malloc(sizeof(unresolved_symbol_t));
+					unresolved_sym->name = malloc(strlen(fixed_symbol) + 1);
+					strcpy(unresolved_sym->name, fixed_symbol);
+					unresolved_sym->column = state->column;
+					unresolved_sym->line_number = *(int*)stack_peek(state->line_number_stack);
+					unresolved_sym->line = malloc(strlen(state->line) + 1);
+					strcpy(unresolved_sym->line, state->line);
+					const char *file_name=stack_peek(state->file_name_stack);
+					unresolved_sym->file_name = malloc(sizeof(file_name) + 1);
+					strcpy(unresolved_sym->file_name, file_name);
+					list_add(state->object->unresolved, unresolved_sym);
+				}
+				
 				scas_log(L_DEBUG, "Postponing evaluation of '%s' to linker", argv[i]);
 				late_immediate_t *late_imm = malloc(sizeof(late_immediate_t));
 				late_imm->address = state->current_area->data_length;
@@ -408,7 +433,26 @@ int handle_dw(struct assembler_state *state, char **argv, int argc) {
 		}
 
 		if (error == EXPRESSION_BAD_SYMBOL) {
-			/* TODO: Throw error if using explicit import */
+			if (scas_runtime.options.explicit_import) {
+				tokenized_expression_t *changed_expression = malloc(sizeof(tokenized_expression_t));
+				memcpy(changed_expression, expression, sizeof(tokenized_expression_t));
+				int ignored_error;
+				char *fixed_symbol;
+				transform_local_labels(changed_expression, state->last_global_label);
+				evaluate_expression(expression, state->equates, &ignored_error, &fixed_symbol);
+				unresolved_symbol_t *unresolved_sym = malloc(sizeof(unresolved_symbol_t));
+				unresolved_sym->name = malloc(strlen(fixed_symbol) + 1);
+				strcpy(unresolved_sym->name,fixed_symbol);
+				unresolved_sym->column = state->column;
+				unresolved_sym->line_number = *(int*)stack_peek(state->line_number_stack);
+				unresolved_sym->line = malloc(strlen(state->line) + 1);
+				strcpy(unresolved_sym->line, state->line);
+				const char *file_name = stack_peek(state->file_name_stack);
+				unresolved_sym->file_name = malloc(sizeof(file_name) + 1);
+				strcpy(unresolved_sym->file_name, file_name);
+				list_add(state->object->unresolved, unresolved_sym);
+			}
+
 			scas_log(L_DEBUG, "Postponing evaluation of '%s' to linker", argv[i]);
 			late_immediate_t *late_imm = malloc(sizeof(late_immediate_t));
 			late_imm->address = state->current_area->data_length;
@@ -750,6 +794,22 @@ int handle_export(struct assembler_state *state, char **argv, int argc) {
 	return 1;
 }
 
+int handle_import(struct assembler_state *state, char **argv, int argc) {
+	if (!scas_runtime.options.explicit_import) {
+		WARN(WARNING_NO_EFFECT, state->column,
+				".import", "explicit_import is not enabled");
+	}
+	else {
+		for (int i = 0; i < argc; ++i) {
+			scas_log(L_DEBUG, "Importing '%s'",argv[i]);
+			char *imported = malloc(strlen(argv[i]) + 1);
+			strcpy(imported, argv[i]);
+			list_add(state->object->imports, imported);
+		}
+	}
+	return 1;
+}
+
 int handle_if(struct assembler_state *state, char **argv, int argc) {
 	if (state->if_stack->length != 0 && !*(int *)stack_peek(state->if_stack)) {
 		/* Push up another falsy if if we're already in a falsy if */
@@ -971,7 +1031,10 @@ int handle_list(struct assembler_state *state, char **argv, int argc) {
 int handle_map(struct assembler_state *state, char **argv, int argc) {
 	// .map filename, lineno, code
 	free(((source_map_t *)stack_peek(state->source_map_stack))->file_name);
-	((source_map_t*)stack_peek(state->source_map_stack))->file_name = strdup(argv[0]);
+	((source_map_t*)stack_peek(state->source_map_stack))->file_name = 
+			malloc(strlen(argv[0]) + 1);
+	strcpy(((source_map_t*)stack_peek(state->source_map_stack))->file_name,
+			argv[0]);
 	add_source_map((source_map_t *)stack_peek(state->source_map_stack),
 		atoi(argv[1]), argv[2], state->PC, 1); // TODO: figure out actual length
 	return 1;
@@ -1123,7 +1186,7 @@ struct directive directives[] = {
 	{ "if", handle_if, 0 },
 	{ "ifdef", handle_ifdef, 0 },
 	{ "ifndef", handle_ifndef, 0 },
-	{ "import", handle_nop, DELIM_COMMAS | DELIM_WHITESPACE }, /* TODO */
+	{ "import", handle_import, DELIM_COMMAS | DELIM_WHITESPACE },
 	{ "incbin", handle_incbin, DELIM_COMMAS | DELIM_WHITESPACE },
 	{ "include", handle_include, DELIM_COMMAS | DELIM_WHITESPACE },
 	{ "lclequ", handle_equ, DELIM_COMMAS | DELIM_WHITESPACE },
diff --git a/common/errors.c b/common/errors.c
@@ -32,6 +32,8 @@ const char *get_error_string(error_t *error) {
 
 const char *get_warning_string(warning_t *warning) {
 	switch (warning->code) {
+		case WARNING_NO_EFFECT:
+			return "'%s' has no effect %s";
 		default:
 			return NULL;
 	}
@@ -67,6 +69,36 @@ void add_error(list_t *errors, int code, size_t line_number, const char *line,
 			line_number, column);
 }
 
+void add_warning(list_t *warnings, int code, size_t line_number,
+		const char *line, int column, const char *file_name, ...) {
+	warning_t *warning = malloc(sizeof(warning_t));
+	warning->code = code;
+	warning->line_number = line_number;
+	warning->file_name = malloc(strlen(file_name) + 1);
+	strcpy(warning->file_name, file_name);
+	warning->line = malloc(strlen(line) + 1);
+	strcpy(warning->line, line);
+	warning->column = column;
+
+	const char *fmt = get_warning_string(warning);
+
+	va_list args;
+	va_start(args, file_name);
+	int len = vsnprintf(NULL, 0, fmt, args);
+	va_end(args);
+
+	char *buf = malloc(len + 1);
+	va_start(args, file_name);
+	vsnprintf(buf, len + 1, fmt, args);
+	va_end(args);
+
+	warning->message = buf;
+
+	list_add(warnings, warning);
+	scas_log(L_ERROR, "Added warning '%s' at %s:%d:%d", buf, file_name,
+			line_number, column);
+}
+
 /* Locates the address in the source maps provided to get the file name and line number */
 void add_error_from_map(list_t *errors, int code, list_t *maps, uint64_t address, ...) {
 	source_map_t *map;
diff --git a/common/objects.c b/common/objects.c
@@ -14,11 +14,15 @@ object_t *create_object() {
 	object_t *o = malloc(sizeof(object_t));
 	o->areas = create_list();
 	o->exports = create_list();
+	o->imports = create_list();
+	o->unresolved = create_list();
 	return o;
 }
 
 void object_free(object_t *o) {
 	list_free(o->areas);
+	list_free(o->unresolved);
+	list_free(o->imports);
 }
 
 area_t *create_area(const char *name) {
diff --git a/include/assembler.h b/include/assembler.h
@@ -48,5 +48,6 @@ struct assembler_state {
 };
 
 object_t *assemble(FILE *file, const char *file_name, assembler_settings_t *settings);
-
+void transform_local_labels(tokenized_expression_t *expression, const char *last_global_label);
+	
 #endif
diff --git a/include/errors.h b/include/errors.h
@@ -15,6 +15,10 @@ enum {
     ERROR_DUPLICATE_SYMBOL,
 };
 
+enum {
+	WARNING_NO_EFFECT = 1,
+};
+
 typedef struct {
     int code;
     size_t line_number;
@@ -39,5 +43,7 @@ void add_error(list_t *errors, int code, size_t line_number, const char *line,
         int column, const char *file_name, ...);
 void add_error_from_map(list_t *errors, int code, list_t *maps, uint64_t
         address, ...);
+void add_warning(list_t *warnings, int code, size_t line_number,
+		const char *line, int column, const char *file_name, ...);
 
 #endif
diff --git a/include/objects.h b/include/objects.h
@@ -25,6 +25,14 @@ typedef struct {
     int exported;
 } symbol_t;
 
+typedef struct {
+	char *name;
+	size_t line_number;
+	char *line;
+	int column;
+	char *file_name;
+} unresolved_symbol_t;
+
 typedef struct {
     tokenized_expression_t *expression;
     uint64_t width;
@@ -63,6 +71,8 @@ typedef struct {
     list_t *areas;
     /* Only used for assembly */
     list_t *exports;
+    list_t *imports;
+    list_t *unresolved;
 } object_t;
 
 object_t *create_object();

Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,15 @@ object_t *create_object() {`
`14`	`14`	`object_t *o = malloc(sizeof(object_t));`
`15`	`15`	`o->areas = create_list();`
`16`	`16`	`o->exports = create_list();`
	`17`	`+ o->imports = create_list();`
	`18`	`+ o->unresolved = create_list();`
`17`	`19`	`return o;`
`18`	`20`	`}`
`19`	`21`
`20`	`22`	`void object_free(object_t *o) {`
`21`	`23`	`list_free(o->areas);`
	`24`	`+ list_free(o->unresolved);`
	`25`	`+ list_free(o->imports);`
`22`	`26`	`}`
`23`	`27`
`24`	`28`	`area_t create_area(const char name) {`