From: ceriel Date: Wed, 2 Apr 1986 17:34:21 +0000 (+0000) Subject: newer version, safety commit X-Git-Tag: release-5-5~5326 X-Git-Url: https://git.ndcode.org/public/gitweb.cgi?a=commitdiff_plain;h=b89155a64a5c1ab4ae17271a2a5e0c36d017df87;p=ack.git newer version, safety commit --- diff --git a/lang/m2/comp/LLlex.c b/lang/m2/comp/LLlex.c index d003cc708..dedcca453 100644 --- a/lang/m2/comp/LLlex.c +++ b/lang/m2/comp/LLlex.c @@ -4,6 +4,7 @@ static char *RcsId = "$Header$"; #include #include +#include #include "input.h" #include "f_info.h" #include "Lpars.h" @@ -179,7 +180,7 @@ again: return tk->tk_symb = ch; default : - crash("bad STCOMP"); + assert(0); } case STIDF: @@ -373,7 +374,7 @@ Sdec: case STCHAR: default: - crash("bad character class %d", class(ch)); + assert(0); } /*NOTREACHED*/ } diff --git a/lang/m2/comp/declar.g b/lang/m2/comp/declar.g index f6c492e9d..48a715dfb 100644 --- a/lang/m2/comp/declar.g +++ b/lang/m2/comp/declar.g @@ -130,7 +130,12 @@ TypeDeclaration }: IDENT { df = define(dot.TOK_IDF, CurrentScope, D_TYPE); } '=' type(&tp) - { df->df_type = tp; } + { df->df_type = tp; + if ((df->df_flags&D_EXPORTED) && + tp->tp_fund == ENUMERATION) { + exprt_literals(tp->enm_enums, enclosing(currscope)); + } + } ; type(struct type **ptp;): @@ -338,7 +343,7 @@ PointerType(struct type **ptp;) } else tp = df->df_type; } - | %if (df = lookfor(dot.TOK_IDF, 0), df->df_kind == D_MODULE) + | %if (df = lookfor(dot.TOK_IDF, currscope, 0), df->df_kind == D_MODULE) type(&tp) | IDENT diff --git a/lang/m2/comp/def.H b/lang/m2/comp/def.H index 49d5bc05e..3bc322606 100644 --- a/lang/m2/comp/def.H +++ b/lang/m2/comp/def.H @@ -38,8 +38,8 @@ struct field { }; struct import { - int im_scopenr; /* Scope number from which imported */ -#define imp_scopenr df_value.df_import.im_scopenr + struct def *im_def; /* Scope number from which imported */ +#define imp_def df_value.df_import.im_def }; struct def { /* list of definitions for a name */ diff --git a/lang/m2/comp/def.c b/lang/m2/comp/def.c index 2d4bfc240..df198a824 100644 --- a/lang/m2/comp/def.c +++ b/lang/m2/comp/def.c @@ -8,6 +8,7 @@ static char *RcsId = "$Header$"; #include #include "Lpars.h" #include "def.h" +#include "type.h" #include "idf.h" #include "misc.h" #include "main.h" @@ -60,7 +61,9 @@ define(id, scope, kind) df->df_kind = kind; return df; } - error("identifier \"%s\" already declared", id->id_text); + if (kind != D_ERROR) { + error("identifier \"%s\" already declared", id->id_text); + } return df; } df = new_def(); @@ -98,12 +101,9 @@ lookup(id, scope) while (df) { if (df->df_scope == scope) { if (df->df_kind == D_IMPORT) { - df = lookup(id, df->imp_scopenr); + df = df->imp_def; assert(df != 0); return df; - /* ??? But this does damage to the self- - organizing character of the list - */ } if (df1) { df1->next = df->next; @@ -118,14 +118,14 @@ lookup(id, scope) return 0; } -/* From the current scope, the list of identifiers "ids" is - exported. Note this fact. If the export is not qualified, make - all the "ids" visible in the enclosing scope by defining them - in this scope as "imported". -*/ Export(ids, qualified) register struct id_list *ids; { + /* From the current scope, the list of identifiers "ids" is + exported. Note this fact. If the export is not qualified, make + all the "ids" visible in the enclosing scope by defining them + in this scope as "imported". + */ register struct def *df; while (ids) { @@ -142,53 +142,88 @@ Export(ids, qualified) } } -/* "ids" is a list of imported identifiers. - If "id" is a null-pointer, the identifiers are imported from the - enclosing scope. Otherwise they are imported from the module - indicated by "id", ehich must be visible in the enclosing scope. - An exception must be made for imports of the Compilation Unit. - This case is indicated by the value 0 of the flag "local". - In this case, if "id" is a null pointer, the "ids" identifiers - are all module identifiers. Their Definition Modules must be read. - Otherwise "id" is a module identifier whose Definition Module must - be read. "ids" then represents a list of identifiers defined in - this module. -*/ Import(ids, id, local) register struct id_list *ids; struct idf *id; { + /* "ids" is a list of imported identifiers. + If "id" is a null-pointer, the identifiers are imported from the + enclosing scope. Otherwise they are imported from the module + indicated by "id", ehich must be visible in the enclosing scope. + An exception must be made for imports of the Compilation Unit. + This case is indicated by the value 0 of the flag "local". + In this case, if "id" is a null pointer, the "ids" identifiers + are all module identifiers. Their Definition Modules must be + read. Otherwise "id" is a module identifier whose Definition + Module must be read. "ids" then represents a list of + identifiers defined in this module. + */ register struct def *df; int scope; int kind; + int imp_kind; +#define FROM_MODULE 0 +#define FROM_ENCLOSING 1 struct def *lookfor(); if (local) { kind = D_IMPORT; - if (!id) scope = enclosing(currscope)->sc_scope; + scope = enclosing(currscope)->sc_scope; + if (!id) imp_kind = FROM_ENCLOSING; else { - df = lookfor(id, 1); + imp_kind = FROM_MODULE; + df = lookfor(id, enclosing(currscope), 1); if (df->df_kind != D_MODULE) { + /* enter all "ids" with type D_ERROR */ + kind = D_ERROR; if (df->df_kind != D_ERROR) { error("identifier \"%s\" does not represent a module", id->id_text); } - /* enter all "ids" with type D_ERROR */ - kind = D_ERROR; - scope = enclosing(currscope)->sc_scope; } else scope = df->mod_scope; } while (ids) { - df = lookup(ids->id_ptr, scope); - if (!df) { - error("identifier \"%s\" not declared", - ids->id_ptr->id_text); + if (imp_kind == FROM_MODULE) { + if (!(df = lookup(ids->id_ptr, scope))) { +error("identifier \"%s\" not declared in qualifying module", +ids->id_ptr->id_text); + df = ill_df; + } + else + if (!(df->df_flags&(D_EXPORTED|D_QEXPORTED))) { +error("identifier \"%s\" not exported from qualifying module", +ids->id_ptr->id_text); + } + } + else { + df = lookfor(ids->id_ptr, enclosing(currscope), 0); + if (df->df_kind == D_ERROR) { +error("identifier \"%s\" not visible in enclosing scope", +ids->id_ptr->id_text); + } + } + define(ids->id_ptr, CurrentScope, kind)->imp_def = df; + if (df->df_kind == D_TYPE && + df->df_type->tp_fund == ENUMERATION) { + /* Also import all enumeration literals */ + exprt_literals(df->df_type->enm_enums, currscope); } - df = define(ids->id_ptr, CurrentScope, D_IMPORT); - df->imp_scopenr = scope; ids = ids->next; } return; } /* ???? */ } + +exprt_literals(df, toscope) + register struct def *df; + register struct scope *toscope; +{ + /* A list of enumeration literals is exported. This is implemented + as an import from the scope "toscope". + */ + while (df) { + define(df->df_idf, toscope->sc_scope, D_IMPORT)->imp_def = df; + df = df->enm_next; + } +} diff --git a/lang/m2/comp/enter.c b/lang/m2/comp/enter.c index 03b983301..5c37e1eea 100644 --- a/lang/m2/comp/enter.c +++ b/lang/m2/comp/enter.c @@ -60,16 +60,18 @@ EnterIdList(idlist, kind, flags, type, scope) } } -/* Look for an identifier in the current visibility range. - If it is not defined, give an error message, and - create a dummy definition. -*/ struct def * -lookfor(id, give_error) +lookfor(id, scope, give_error) struct idf *id; + struct scope *scope; { - register struct scope *sc = currscope; + /* Look for an identifier in the visibility range started by + "scope". + If it is not defined, give an error message, and + create a dummy definition. + */ struct def *df; + register struct scope *sc = scope; while (sc) { df = lookup(id, sc->sc_scope); @@ -77,5 +79,5 @@ lookfor(id, give_error) sc = nextvisible(sc); } if (give_error) error("Identifier \"%s\" not declared", id->id_text); - return define(id, CurrentScope, D_ERROR); + return define(id, scope->sc_scope, D_ERROR); } diff --git a/lang/m2/comp/expression.g b/lang/m2/comp/expression.g index 9d4357980..c46119156 100644 --- a/lang/m2/comp/expression.g +++ b/lang/m2/comp/expression.g @@ -21,11 +21,12 @@ number: qualident(int types; struct def **pdf; char *str;) { int scope; + int module; register struct def *df; struct def *lookfor(); } : IDENT { if (types) { - *pdf = df = lookfor(dot.TOK_IDF, 1); + *pdf = df = lookfor(dot.TOK_IDF, currscope, 1); if (df->df_kind == D_ERROR) types = 0; } } @@ -38,6 +39,7 @@ qualident(int types; struct def **pdf; char *str;) /* selector */ '.' IDENT { if (types) { + module = (df->df_kind == D_MODULE); df = lookup(dot.TOK_IDF, scope); if (!df) { error("identifier \"%s\" not declared", @@ -45,6 +47,11 @@ qualident(int types; struct def **pdf; char *str;) types = 0; df = ill_df; } + else + if (module && + !(df->df_flags&(D_EXPORTED|D_QEXPORTED))) { + error("identifier \"%s\" not exported from qualifying module", dot.TOK_IDF->id_text); + } } } ]* diff --git a/lang/m2/comp/program.g b/lang/m2/comp/program.g index 691b08ce6..c4c7b3d57 100644 --- a/lang/m2/comp/program.g +++ b/lang/m2/comp/program.g @@ -35,9 +35,13 @@ static char *RcsId = "$Header$"; ModuleDeclaration { struct idf *id; + struct def *df; } : - MODULE IDENT { open_scope(CLOSEDSCOPE, 0); + MODULE IDENT { id = dot.TOK_IDF; + df = define(id, CurrentScope, D_MODULE); + open_scope(CLOSEDSCOPE, 0); + df->mod_scope = CurrentScope; } priority? ';' import(1)* diff --git a/lang/m2/comp/scope.C b/lang/m2/comp/scope.C index 6eafc2374..ef2080d4a 100644 --- a/lang/m2/comp/scope.C +++ b/lang/m2/comp/scope.C @@ -118,7 +118,7 @@ rem_forwards(fo) savetok = dot; while (f = fo) { dot = f->fo_tok; - df = lookfor(dot.TOK_IDF, 1); + df = lookfor(dot.TOK_IDF, currscope, 1); if (!(df->df_kind & (D_TYPE | D_HTYPE | D_ERROR))) { error("identifier \"%s\" not a type", df->df_idf->id_text); }