X-Git-Url: http://deadsoftware.ru/gitweb?p=dsw-obn.git;a=blobdiff_plain;f=oberon.c;h=e12ee36174e9fd9cfd9a870225dea8528d46e8f8;hp=28a351a6fdbfd4e315d4b2959b40a3b440a85f1e;hb=c15b86365824545bdee7d813ce0c796f1bdff592;hpb=679da1b129ba6077d1c44ebdf260d3813afdcf65

diff --git a/oberon.c b/oberon.c
index 28a351a..e12ee36 100644
--- a/oberon.c
+++ b/oberon.c
@@ -52,7 +52,8 @@ enum {
 	POINTER,
 	TO,
 	UPARROW,
-	NIL
+	NIL,
+	IMPORT
 };
 
 // =======================================================================
@@ -108,11 +109,8 @@ oberon_new_type_boolean(int size)
 static oberon_scope_t *
 oberon_open_scope(oberon_context_t * ctx)
 {
-	oberon_scope_t * scope = malloc(sizeof *scope);
-	memset(scope, 0, sizeof *scope);
-
-	oberon_object_t * list = malloc(sizeof *list);
-	memset(list, 0, sizeof *list);
+	oberon_scope_t * scope = calloc(1, sizeof *scope);
+	oberon_object_t * list = calloc(1, sizeof *list);
 
 	scope -> ctx = ctx;
 	scope -> list = list;
@@ -415,6 +413,10 @@ oberon_read_ident(oberon_context_t * ctx)
 	{
 		ctx -> token = NIL;
 	}
+	else if(strcmp(ident, "IMPORT") == 0)
+	{
+		ctx -> token = IMPORT;
+	}
 }
 
 static void
@@ -985,6 +987,34 @@ oberon_make_record_selector(oberon_context_t * ctx, oberon_expr_t * expr, char *
 	|| ((x) == DOT) \
 	|| ((x) == UPARROW))
 
+static oberon_object_t *
+oberon_qualident(oberon_context_t * ctx, char ** xname, int check)
+{
+	char * name;
+	oberon_object_t * x;
+
+	name = oberon_assert_ident(ctx);
+	x = oberon_find_object(ctx -> decl, name, check);
+
+	if(x != NULL)
+	{
+		if(x -> class == OBERON_CLASS_MODULE)
+		{
+			oberon_assert_token(ctx, DOT);
+			name = oberon_assert_ident(ctx);
+			/* Наличие объектов в левых модулях всегда проверяется */
+			x = oberon_find_object(x -> module -> decl, name, 1);
+		}
+	}
+
+	if(xname)
+	{
+		*xname = name;
+	}
+
+	return x;
+}
+
 static oberon_expr_t *
 oberon_designator(oberon_context_t * ctx)
 {
@@ -992,8 +1022,7 @@ oberon_designator(oberon_context_t * ctx)
 	oberon_object_t * var;
 	oberon_expr_t * expr;
 
-	name = oberon_assert_ident(ctx);
-	var = oberon_find_object(ctx -> decl, name, 1);
+	var = oberon_qualident(ctx, NULL, 1);
 
 	switch(var -> class)
 	{
@@ -1498,8 +1527,14 @@ oberon_formal_pars(oberon_context_t * ctx, oberon_type_t * signature)
 	if(ctx -> token == COLON)
 	{
 		oberon_assert_token(ctx, COLON);
-		// TODO get by qualident
-		oberon_type(ctx, &signature -> base);
+
+		oberon_object_t * typeobj;
+		typeobj = oberon_qualident(ctx, NULL, 1);
+		if(typeobj -> class != OBERON_CLASS_TYPE)
+		{
+			oberon_error(ctx, "function result is not type");
+		}
+		signature -> base = typeobj -> type;
 	}
 }
 
@@ -1734,8 +1769,10 @@ oberon_qualident_type(oberon_context_t * ctx, oberon_type_t ** type)
 	char * name;
 	oberon_object_t * to;
 
-	name = oberon_assert_ident(ctx);
-	to = oberon_find_object(ctx -> decl, name, 0);
+	to = oberon_qualident(ctx, &name, 0);
+
+	//name = oberon_assert_ident(ctx);
+	//to = oberon_find_object(ctx -> decl, name, 0);
 
 	if(to != NULL)
 	{
@@ -2027,6 +2064,7 @@ oberon_prevent_recursive_object(oberon_context_t * ctx, oberon_object_t * x)
 			break;
 		case OBERON_CLASS_CONST:
 		case OBERON_CLASS_PROC:
+		case OBERON_CLASS_MODULE:
 			break;
 		default:
 			oberon_error(ctx, "oberon_prevent_recursive_object: wat");
@@ -2145,9 +2183,10 @@ oberon_initialize_object(oberon_context_t * ctx, oberon_object_t * x)
 			break;
 		case OBERON_CLASS_CONST:
 		case OBERON_CLASS_PROC:
+		case OBERON_CLASS_MODULE:
 			break;
 		default:
-			oberon_error(ctx, "oberon_prevent_recursive_object: wat");
+			oberon_error(ctx, "oberon_initialize_object: wat");
 			break;
 	}
 }
@@ -2281,10 +2320,74 @@ oberon_statement_seq(oberon_context_t * ctx)
 	}
 }
 
+static void
+oberon_import_module(oberon_context_t * ctx, char * alias, char * name)
+{
+	oberon_module_t * m = ctx -> module_list;
+	while(m && strcmp(m -> name, name) != 0)
+	{
+		m = m -> next;
+	}
+
+	if(m == NULL)
+	{
+		const char * code;
+		code = ctx -> import_module(name);
+		if(code == NULL)
+		{
+			oberon_error(ctx, "no such module");
+		}
+
+		m = oberon_compile_module(ctx, code);
+		assert(m);
+	}
+
+	if(m -> ready == 0)
+	{
+		oberon_error(ctx, "cyclic module import");
+	}
+
+	oberon_object_t * ident;
+	ident = oberon_define_object(ctx -> decl, alias, OBERON_CLASS_MODULE);
+	ident -> module = m;
+}
+
+static void
+oberon_import_decl(oberon_context_t * ctx)
+{
+	char * alias;
+	char * name;
+
+	alias = name = oberon_assert_ident(ctx);
+	if(ctx -> token == ASSIGN)
+	{
+		oberon_assert_token(ctx, ASSIGN);
+		name = oberon_assert_ident(ctx);
+	}
+
+	oberon_import_module(ctx, alias, name);
+}
+
+static void
+oberon_import_list(oberon_context_t * ctx)
+{
+	oberon_assert_token(ctx, IMPORT);
+
+	oberon_import_decl(ctx);
+	while(ctx -> token == COMMA)
+	{
+		oberon_assert_token(ctx, COMMA);
+		oberon_import_decl(ctx);
+	}
+
+	oberon_assert_token(ctx, SEMICOLON);
+}
+
 static void
 oberon_parse_module(oberon_context_t * ctx)
 {
-	char *name1, *name2;
+	char * name1;
+	char * name2;
 	oberon_read_token(ctx);
 
 	oberon_assert_token(ctx, MODULE);
@@ -2292,12 +2395,24 @@ oberon_parse_module(oberon_context_t * ctx)
 	oberon_assert_token(ctx, SEMICOLON);
 	ctx -> mod -> name = name1;
 
+	oberon_object_t * this_module;
+	this_module = oberon_define_object(ctx -> decl, name1, OBERON_CLASS_MODULE);
+	this_module -> module = ctx -> mod;
+
+	if(ctx -> token == IMPORT)
+	{
+		oberon_import_list(ctx);
+	}
+
+	ctx -> decl -> parent = this_module;
+
 	oberon_decl_seq(ctx);
 
+	oberon_generate_begin_module(ctx);
+
 	if(ctx -> token == BEGIN)
 	{
 		oberon_assert_token(ctx, BEGIN);
-		oberon_generate_begin_module(ctx);
 		oberon_statement_seq(ctx);
 		oberon_generate_end_module(ctx);
 	}
@@ -2375,15 +2490,16 @@ oberon_make_abs_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_
 }
 
 oberon_context_t *
-oberon_create_context()
+oberon_create_context(ModuleImportCallback import_module)
 {
-	oberon_context_t * ctx = malloc(sizeof *ctx);
-	memset(ctx, 0, sizeof *ctx);
+	oberon_context_t * ctx = calloc(1, sizeof *ctx);
 
 	oberon_scope_t * world_scope;
 	world_scope = oberon_open_scope(ctx);
 	ctx -> world_scope = world_scope;
 
+	ctx -> import_module = import_module;
+
 	oberon_generator_init_context(ctx);
 
 	register_default_types(ctx);
@@ -2400,21 +2516,41 @@ oberon_destroy_context(oberon_context_t * ctx)
 }
 
 oberon_module_t *
-oberon_compile_module(oberon_context_t * ctx, const char * code)
+oberon_compile_module(oberon_context_t * ctx, const char * newcode)
 {
-	oberon_module_t * mod = malloc(sizeof *mod);
-	memset(mod, 0, sizeof *mod);
-	ctx -> mod = mod;
+	const char * code = ctx -> code;
+	int code_index = ctx -> code_index;
+	char c = ctx -> c;
+	int token = ctx -> token;
+	char * string = ctx -> string;
+	int integer = ctx -> integer;
+	oberon_scope_t * decl = ctx -> decl;
+	oberon_module_t * mod = ctx -> mod;
 
 	oberon_scope_t * module_scope;
 	module_scope = oberon_open_scope(ctx);
-	mod -> decl = module_scope;
 
-	oberon_init_scaner(ctx, code);
+	oberon_module_t * module;
+	module = calloc(1, sizeof *module);
+	module -> decl = module_scope;
+	module -> next = ctx -> module_list;
+
+	ctx -> mod = module;
+	ctx -> module_list = module;
+
+	oberon_init_scaner(ctx, newcode);
 	oberon_parse_module(ctx);
 
-	oberon_generate_code(ctx);
+	module -> ready = 1;
+
+	ctx -> code = code;
+	ctx -> code_index = code_index;
+	ctx -> c = c;
+	ctx -> token = token;
+	ctx -> string = string;
+	ctx -> integer = integer;
+	ctx -> decl = decl;
+	ctx -> mod = mod;
 
-	ctx -> mod = NULL;
-	return mod;
+	return module;
 }