Initial revision
This commit is contained in:
ceriel
237
lang/m2/m2mm/program.g
Normal file
237
lang/m2/m2mm/program.g
Normal file
@@ -0,0 +1,237 @@
|
||||
/*
|
||||
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
* See the copyright notice in the ACK home directory, in the file "Copyright".
|
||||
*
|
||||
* Author: Ceriel J.H. Jacobs
|
||||
*/
|
||||
|
||||
/* O V E R A L L S T R U C T U R E */
|
||||
|
||||
/* stripped down version of the one in the Modula-2 compiler */
|
||||
|
||||
/* $Header$ */
|
||||
|
||||
/*
|
||||
The grammar as given by Wirth is already almost LL(1); the
|
||||
main problem is that the full form of a qualified designator
|
||||
may be:
|
||||
[ module_ident '.' ]* IDENT [ '.' field_ident ]*
|
||||
which is quite confusing to an LL(1) parser. Rather than
|
||||
resorting to context-sensitive techniques, I have decided
|
||||
to render this as:
|
||||
IDENT [ '.' IDENT ]*
|
||||
on the grounds that it is quite natural to consider the first
|
||||
IDENT to be the name of the object and regard the others as
|
||||
field identifiers.
|
||||
*/
|
||||
|
||||
{
|
||||
#include "main.h"
|
||||
#include "idf.h"
|
||||
#include "f_info.h"
|
||||
#include "LLlex.h"
|
||||
|
||||
struct lnk *
|
||||
new_lnk()
|
||||
{
|
||||
static struct lnk *p;
|
||||
static int cnt;
|
||||
extern char *calloc();
|
||||
|
||||
if (cnt--) return p++;
|
||||
p = (struct lnk *)calloc(50, sizeof(struct lnk));
|
||||
cnt = 49;
|
||||
return p++;
|
||||
}
|
||||
}
|
||||
|
||||
%lexical LLlex;
|
||||
|
||||
%start CompUnit, CompilationUnit;
|
||||
%start DefModule, DefinitionModule;
|
||||
|
||||
ModuleDeclaration :
|
||||
MODULE IDENT
|
||||
priority
|
||||
';'
|
||||
import((struct lnk **) 0)*
|
||||
export?
|
||||
block
|
||||
IDENT
|
||||
;
|
||||
|
||||
priority:
|
||||
[
|
||||
'[' ConstExpression ']'
|
||||
|
|
||||
]
|
||||
;
|
||||
|
||||
export :
|
||||
EXPORT
|
||||
[
|
||||
QUALIFIED
|
||||
|
|
||||
]
|
||||
IdentList ';'
|
||||
;
|
||||
|
||||
import(register struct lnk **p;)
|
||||
{
|
||||
register struct idf *fromid = 0;
|
||||
struct idf *id;
|
||||
}
|
||||
:
|
||||
{ if (p) while (*p) p = &((*p)->lnk_next); }
|
||||
[ FROM
|
||||
identifier(&id) { fromid = id;
|
||||
if (p) {
|
||||
if (AddToList(fromid->id_text, ".def")) {
|
||||
*p = new_lnk();
|
||||
(*p)->lnk_imp = fromid;
|
||||
}
|
||||
}
|
||||
}
|
||||
]?
|
||||
IMPORT
|
||||
identifier(&id) { if (! fromid && p) {
|
||||
if (AddToList(id->id_text, ".def")) {
|
||||
*p = new_lnk();
|
||||
(*p)->lnk_imp = id;
|
||||
p = &((*p)->lnk_next);
|
||||
}
|
||||
}
|
||||
}
|
||||
[
|
||||
',' identifier(&id)
|
||||
{ if (! fromid && p) {
|
||||
if (AddToList(id->id_text, ".def")) {
|
||||
*p = new_lnk();
|
||||
(*p)->lnk_imp = id;
|
||||
p = &((*p)->lnk_next);
|
||||
}
|
||||
}
|
||||
}
|
||||
]*
|
||||
';'
|
||||
/*
|
||||
When parsing a global module, this is the place where we must
|
||||
read already compiled definition modules.
|
||||
If the FROM clause is present, the identifier in it is a module
|
||||
name, otherwise the names in the import list are module names.
|
||||
*/
|
||||
;
|
||||
|
||||
DefinitionModule
|
||||
{
|
||||
struct idf *id;
|
||||
extern char *strrindex();
|
||||
}
|
||||
:
|
||||
DEFINITION
|
||||
MODULE identifier(&id)
|
||||
{ if (! ForeignFlag) {
|
||||
AddToList(id->id_text, ".mod");
|
||||
}
|
||||
if (! id->id_type) {
|
||||
id->id_type = DEFINITION;
|
||||
}
|
||||
else if (id->id_type != IMPLEMENTATION) {
|
||||
error("multiple declaration for module %s",
|
||||
id->id_text);
|
||||
}
|
||||
if (! id->id_dir) {
|
||||
id->id_dir = WorkingDir;
|
||||
}
|
||||
else if (strcmp(id->id_dir, WorkingDir)) {
|
||||
Gerror("definition and implementation of module %s reside in different directories", id->id_text);
|
||||
}
|
||||
id->id_def = strrindex(FileName, '/');
|
||||
if (! id->id_def) id->id_def = FileName;
|
||||
else (id->id_def)++;
|
||||
CurrentArg->a_idf = id;
|
||||
}
|
||||
';'
|
||||
import(&(id->id_defimports))*
|
||||
[
|
||||
export
|
||||
|
|
||||
/* empty */
|
||||
]
|
||||
definition* END IDENT
|
||||
'.'
|
||||
;
|
||||
|
||||
definition :
|
||||
CONST [ %persistent ConstantDeclaration ';' ]*
|
||||
|
|
||||
TYPE
|
||||
[ %persistent
|
||||
IDENT
|
||||
[ '=' type
|
||||
| /* empty */
|
||||
/*
|
||||
Here, the exported type has a hidden implementation.
|
||||
The export is said to be opaque.
|
||||
It is restricted to pointer types.
|
||||
*/
|
||||
]
|
||||
';'
|
||||
]*
|
||||
|
|
||||
VAR [ %persistent VariableDeclaration ';' ]*
|
||||
|
|
||||
ProcedureHeading
|
||||
';'
|
||||
;
|
||||
|
||||
ProgramModule
|
||||
{
|
||||
struct idf *id;
|
||||
}
|
||||
:
|
||||
MODULE
|
||||
identifier(&id) { if (! id->id_type) {
|
||||
id->id_type = state;
|
||||
}
|
||||
else if (id->id_type != DEFINITION ||
|
||||
state != IMPLEMENTATION) {
|
||||
error("multiple declaration for module %s",
|
||||
id->id_text);
|
||||
}
|
||||
if (! id->id_dir) {
|
||||
id->id_dir = WorkingDir;
|
||||
}
|
||||
else if (strcmp(id->id_dir, WorkingDir)) {
|
||||
Gerror("definition and implementation of module %s reside in different directories", id->id_text);
|
||||
}
|
||||
CurrentArg->a_idf = id;
|
||||
}
|
||||
priority
|
||||
';' import(&(id->id_modimports))*
|
||||
block IDENT
|
||||
'.'
|
||||
;
|
||||
|
||||
Module:
|
||||
DEFINITION
|
||||
{ fatal("Definition module in .mod file"); }
|
||||
| %default
|
||||
[
|
||||
IMPLEMENTATION { state = IMPLEMENTATION; }
|
||||
|
|
||||
/* empty */ { state = PROGRAM; }
|
||||
]
|
||||
ProgramModule
|
||||
;
|
||||
|
||||
CompilationUnit:
|
||||
Module
|
||||
;
|
||||
|
||||
identifier(struct idf **id;):
|
||||
IDENT
|
||||
{ extern char idfbuf[];
|
||||
*id = str2idf(idfbuf);
|
||||
}
|
||||
;
|
||||
Reference in New Issue
Block a user