diff --git a/oberon.c b/oberon.c
index 3837bf5b92702c744bcf7b883ff73395826063a8..c3a6f86ce77fc9d57002b7263e394f218b2140ce 100644 (file)
--- a/oberon.c
+++ b/oberon.c
scope -> list = list;
scope -> up = ctx -> decl;
+ if(scope -> up)
+ {
+ scope -> parent = scope -> up -> parent;
+ scope -> local = scope -> up -> local;
+ }
+
ctx -> decl = scope;
return scope;
}
memset(newvar, 0, sizeof *newvar);
newvar -> name = name;
newvar -> class = class;
+ newvar -> local = scope -> local;
+ newvar -> parent = scope -> parent;
x -> next = newvar;
static void
oberon_define_field(oberon_context_t * ctx, oberon_type_t * rec, char * name, oberon_type_t * type)
{
+ // TODO check base fields
+
oberon_object_t * x = rec -> decl;
while(x -> next && strcmp(x -> next -> name, name) != 0)
{
field -> name = name;
field -> class = OBERON_CLASS_FIELD;
field -> type = type;
+ field -> local = 1;
+ field -> parent = NULL;
rec -> num_decl += 1;
x -> next = field;
}
*/
+/*
static oberon_object_t *
oberon_define_proc(oberon_scope_t * scope, char * name, oberon_type_t * signature)
{
@@ -282,6 +295,7 @@ oberon_define_proc(oberon_scope_t * scope, char * name, oberon_type_t * signatur
proc -> type = signature;
return proc;
}
+*/
// =======================================================================
// SCANER
static void oberon_decl_seq(oberon_context_t * ctx);
static void oberon_statement_seq(oberon_context_t * ctx);
+static void oberon_initialize_decl(oberon_context_t * ctx);
static void
oberon_expect_token(oberon_context_t * ctx, int token)
}
}
+static void
+oberon_compare_signatures(oberon_context_t * ctx, oberon_type_t * a, oberon_type_t * b)
+{
+ if(a -> num_decl != b -> num_decl)
+ {
+ oberon_error(ctx, "number parameters not matched");
+ }
+
+ int num_param = a -> num_decl;
+ oberon_object_t * param_a = a -> decl;
+ oberon_object_t * param_b = b -> decl;
+ for(int i = 0; i < num_param; i++)
+ {
+ if(strcmp(param_a -> name, param_b -> name) != 0)
+ {
+ oberon_error(ctx, "param %i name not matched", i + 1);
+ }
+
+ if(param_a -> type != param_b -> type)
+ {
+ oberon_error(ctx, "param %i type not matched", i + 1);
+ }
+
+ param_a = param_a -> next;
+ param_b = param_b -> next;
+ }
+}
+
static void
oberon_make_return(oberon_context_t * ctx, oberon_expr_t * expr)
{
- if(ctx -> result_type -> class == OBERON_TYPE_VOID)
+ oberon_object_t * proc = ctx -> decl -> parent;
+ oberon_type_t * result_type = proc -> type -> base;
+
+ if(result_type -> class == OBERON_TYPE_VOID)
{
if(expr != NULL)
{
oberon_error(ctx, "procedure requires expression on result");
}
- oberon_autocast_to(ctx, expr, ctx -> result_type);
+ oberon_autocast_to(ctx, expr, result_type);
}
- ctx -> has_return = 1;
+ proc -> has_return = 1;
oberon_generate_return(ctx, expr);
}
static void
-oberon_proc_decl(oberon_context_t * ctx)
+oberon_proc_decl_body(oberon_context_t * ctx, oberon_object_t * proc)
{
- oberon_assert_token(ctx, PROCEDURE);
-
- char * name;
- name = oberon_assert_ident(ctx);
-
- oberon_scope_t * this_proc_def_scope = ctx -> decl;
- oberon_open_scope(ctx);
-
- oberon_type_t * signature;
- signature = oberon_new_type_ptr(OBERON_TYPE_VOID);
- oberon_opt_formal_pars(ctx, &signature);
-
- oberon_object_t * proc;
- proc = oberon_define_proc(this_proc_def_scope, name, signature);
-
- ctx -> result_type = signature -> base;
- ctx -> has_return = 0;
-
oberon_assert_token(ctx, SEMICOLON);
+ ctx -> decl = proc -> scope;
+
oberon_decl_seq(ctx);
- oberon_generator_init_type(ctx, signature);
- oberon_generator_init_proc(ctx, proc);
oberon_generate_begin_proc(ctx, proc);
}
oberon_assert_token(ctx, END);
- char * name2 = oberon_assert_ident(ctx);
- if(strcmp(name2, name) != 0)
+ char * name = oberon_assert_ident(ctx);
+ if(strcmp(name, proc -> name) != 0)
{
oberon_error(ctx, "procedure name not matched");
}
- if(signature -> base -> class == OBERON_TYPE_VOID)
+ if(proc -> type -> base -> class == OBERON_TYPE_VOID
+ && proc -> has_return == 0)
{
oberon_make_return(ctx, NULL);
}
- if(ctx -> has_return == 0)
+ if(proc -> has_return == 0)
{
oberon_error(ctx, "procedure requires return");
}
- ctx -> result_type = NULL;
oberon_generate_end_proc(ctx);
oberon_close_scope(ctx -> decl);
}
+static void
+oberon_proc_decl(oberon_context_t * ctx)
+{
+ oberon_assert_token(ctx, PROCEDURE);
+
+ int forward = 0;
+ if(ctx -> token == UPARROW)
+ {
+ oberon_assert_token(ctx, UPARROW);
+ forward = 1;
+ }
+
+ char * name;
+ name = oberon_assert_ident(ctx);
+
+ oberon_scope_t * proc_scope;
+ proc_scope = oberon_open_scope(ctx);
+ ctx -> decl -> local = 1;
+
+ oberon_type_t * signature;
+ signature = oberon_new_type_ptr(OBERON_TYPE_VOID);
+ oberon_opt_formal_pars(ctx, &signature);
+
+ oberon_initialize_decl(ctx);
+ oberon_generator_init_type(ctx, signature);
+ oberon_close_scope(ctx -> decl);
+
+ oberon_object_t * proc;
+ proc = oberon_find_object(ctx -> decl, name, 0);
+ if(proc != NULL)
+ {
+ if(proc -> class != OBERON_CLASS_PROC)
+ {
+ oberon_error(ctx, "mult definition");
+ }
+
+ if(forward == 0)
+ {
+ if(proc -> linked)
+ {
+ oberon_error(ctx, "mult procedure definition");
+ }
+ }
+
+ oberon_compare_signatures(ctx, proc -> type, signature);
+ }
+ else
+ {
+ proc = oberon_define_object(ctx -> decl, name, OBERON_CLASS_PROC);
+ proc -> type = signature;
+ proc -> scope = proc_scope;
+ oberon_generator_init_proc(ctx, proc);
+ }
+
+ proc -> scope -> parent = proc;
+
+ if(forward == 0)
+ {
+ proc -> linked = 1;
+ oberon_proc_decl_body(ctx, proc);
+ }
+}
+
static void
oberon_const_decl(oberon_context_t * ctx)
{
static void
oberon_initialize_object(oberon_context_t * ctx, oberon_object_t * x)
{
- printf("oberon_initialize_object: name %s class %i\n", x -> name, x -> class);
+ if(x -> initialized)
+ {
+ return;
+ }
+
+ x -> initialized = 1;
+
switch(x -> class)
{
case OBERON_CLASS_TYPE:
}
}
+static void
+oberon_prevent_undeclarated_procedures(oberon_context_t * ctx)
+{
+ oberon_object_t * x = ctx -> decl -> list;
+
+ while(x -> next)
+ {
+ if(x -> next -> class == OBERON_CLASS_PROC)
+ {
+ if(x -> next -> linked == 0)
+ {
+ oberon_error(ctx, "unresolved forward declaration");
+ }
+ }
+ x = x -> next;
+ }
+}
+
static void
oberon_decl_seq(oberon_context_t * ctx)
{
oberon_proc_decl(ctx);
oberon_assert_token(ctx, SEMICOLON);
}
+
+ oberon_prevent_undeclarated_procedures(ctx);
}
static void
{
if(desig -> result -> class != OBERON_TYPE_VOID)
{
- oberon_error(ctx, "procedure with result");
+ if(desig -> result -> class != OBERON_TYPE_PROCEDURE)
+ {
+ oberon_error(ctx, "procedure with result");
+ }
}
oberon_autocast_call(ctx, desig);