Generating Software from Specifications WS 2013/14 - File QualNamesSol.fw
@=~
~p maximum_input_line_length = infinity
This file contains the specification of a processor
for structured types and qualified names.
The following tasks are to be solved:
1. Read and understand name analysis and type analysis as
specified below. The specification is NOT explained.
Insert explanations according to your understanding.
2. A processor can be generated from this specification.
However, it does not work as expected. Compare its results
at least for the given examples to the expected results.
The author of this specification has failed to specify
necessary preconditions explicily for several computations.
Add those necessary dependences, and test the corrected analysis.
The following file contains correct input for the processor.
Under Algol-like scope rules the order of declarations and uses
of identifiers is irrelevant:
~O~<QualNames.ok~>~{~-
{
l.a = 42; l.next = l;
b.a = l.next.next.a;
b.left = nil; b.right = nil;
list l;
btree b;
type list = (int a; list next;)
type btree = (int a; btree left; btree right;)
}
~}
The following file contains erroneous input for the processor:
~O~<QualNames.err~>~{~-
{
type list = (int a; list next;)
list l;
l.a = nil;
l.next = 42;
v.a = 42;
l.next = b;
type btree = (int a; btree left; btree right;)
btree b;
int b;
type xlist = (int a; list next; list a;)
}
~}
The following file contains the messages expected for the above example
~O~<QualNames.msg~>~{~-
"QualNames.err", line 9:9 ERROR: multiply defined: b
"QualNames.err", line 10:7 ERROR: multiply defined: b
"QualNames.err", line 11:21 ERROR: multiply defined: a
"QualNames.err", line 11:40 ERROR: multiply defined: a
"QualNames.err", line 4:3 ERROR: wrong type in assignment
"QualNames.err", line 5:3 ERROR: wrong type in assignment
"QualNames.err", line 6:3 ERROR: identifier is not defined: v
"QualNames.err", line 6:5 ERROR: identifier is not defined: a
"QualNames.err", line 7:3 ERROR: wrong type in assignment
~}
The following file specifies the concrete syntax:
~O~<QualNames.con~>~{
Program: '{' Constructs '}'.
Constructs: Constructs Construct / Construct.
Construct: TypeDecl.
Construct: VariableDecl.
Construct: Assignment.
TypeDecl: 'type' TypeDefName '=' Record.
TypeDefName: Identifier.
Record: '(' Fields ')'.
Fields: Fields Field / Field.
Field: Type FieldDefName ';'.
FieldDefName: Identifier.
Type: 'int' / TypeUseName.
TypeUseName: Identifier.
VariableDecl: Type VarDefName ';'.
VarDefName: Identifier.
QualifiedName: VarUseName / QualifiedName '.' FieldUseName.
VarUseName: Identifier.
FieldUseName: Identifier.
Assignment: QualifiedName '=' Expression ';'.
Expression: QualifiedName / Number / 'nil'.
~}
The following file specifies the non-literal tokens:
~O~<QualNames.gla~>~{
Identifier: C_IDENTIFIER
Number: C_INTEGER
C_COMMENT
~}
Basic Name Analysis
-------------------
The following file instantiates the basic name analysis module
from Eli's specification modules which establishes
bindings according to Algol-like scope rules:
~O~<Name.specs~>~{
$/Name/AlgScope.gnrc:inst
$/Tech/Strings.specs
~}
EXPLAIN:
The class symbol IdentOcc provides the computation of the
Sym attribute for occurrences of names.
The module roles for the root, the range, the defining and the
applied occurrences are associated:
~O~<IdentOcc.lido~>~{
CLASS SYMBOL IdentOcc: Sym: int;
CLASS SYMBOL IdentOcc COMPUTE
SYNT.Sym = TERM;
END;
SYMBOL Program INHERITS RootScope END;
SYMBOL Record INHERITS RangeScope END;
SYMBOL TypeDefName INHERITS IdentOcc, IdDefScope END;
SYMBOL VarDefName INHERITS IdentOcc, IdDefScope END;
SYMBOL FieldDefName INHERITS IdentOcc, IdDefScope END;
SYMBOL TypeUseName INHERITS IdentOcc, IdUseEnv, ChkIdUse END;
SYMBOL VarUseName INHERITS IdentOcc, IdUseEnv, ChkIdUse END;
~}
EXPLAIN:
An identifier must not be definied more than once in any range:
MISSING DEPENDENCE:
A processor generated from the specification given in the task
does not give error messages on multiple definitions of the
same identifier.
The GetDefs operation must not be called before all calls of
the SetDefs operation are executed. That dependence is
established by the well-known dependence pattern on the
attributes Program.GotDefs and UniqueDefName.GotDefs.
~O~<UniqueDefs.pdl~>~{~-
Defs: int;
~}
~O~<UniqueDefs.lido~>~{~-
SYMBOL Program COMPUTE
SYNT.GotDefs = CONSTITUENTS UniqueDefName.GotDefs;
END;
CLASS SYMBOL UniqueDefName COMPUTE
SYNT.GotDefs = SetDefs (THIS.Key, 1, 2);
IF (GT (GetDefs (THIS.Key, 0), 1),
message (ERROR, CatStrStr ("multiply defined: ", StringTable (THIS.Sym)),
0, COORDREF))
<- INCLUDING Program.GotDefs;
END;
SYMBOL TypeDefName INHERITS UniqueDefName END;
SYMBOL VarDefName INHERITS UniqueDefName END;
SYMBOL FieldDefName INHERITS UniqueDefName END;
~}
Name Analysis for Qualified Names
---------------------------------
EXPLAIN:
Record types have an environment as their property,
where the field names are bound in.
~O~<ScopeProperty.pdl~>~{~-
Scope: Environment; "envmod.h"
~}
That property is set in the defining context of a type name.
The scope property is accessed from the type of a QualifiedName.
Program.GotScope guarantees that the property is not used before
it is set for all type definitons.
The function KeyInScope is used to lookup a field name.
The dependence on Program.GotDefs guarantees that a lookup
is not tried before all definitions are processed.
MISSING DEPENDENCE:
A processor generated from the specification given in the task
does not find a binding for any used occurrence of a field name,
and indicates it by a message.
The GetScope operation must not be called before all calls of
the ResetScope operation are executed. That dependence is
established by the well-known dependence pattern on the
attributes Program.GotScope and TypeDefName.GotScope.
~O~<ScopeProperty.lido~>~{~-
SYMBOL Program COMPUTE
THIS.GotScope = CONSTITUENTS TypeDefName.GotScope;
END;
ATTR Env: Environment;
RULE: TypeDecl ::= 'type' TypeDefName '=' Record COMPUTE
TypeDefName.Env = Record.Env;
END;
SYMBOL TypeDefName COMPUTE
SYNT.GotScope = ResetScope (THIS.Key, THIS.Env);
END;
RULE: QualifiedName ::= QualifiedName '.' FieldUseName COMPUTE
FieldUseName.Env = GetScope (QualifiedName[2].Type, NoEnv)
<- INCLUDING Program.GotScope;
IF (EQ (QualifiedName[2].Type, intType),
message (ERROR, "wrong type of qualifier", 0, COORDREF));
END;
SYMBOL FieldUseName INHERITS IdentOcc, ChkIdUse COMPUTE
THIS.Key = KeyInScope (THIS.Env, THIS.Sym)
<- INCLUDING Program.GotDefs;
END;
~}
Type Analysis
-------------
EXPLAIN:
A type property and two types for int and for nil are
introduced.
~O~<TypeProperty.pdl~>~{~-
Type: DefTableKey;
intType;
nilType;
~}
The Type property of fields and of variables are set in their
definition contexts. It is accessed in applied occurrences
of fields or variables. The dependence on Program.GotType
guarantees that all types are set before any is accessed.
In qualified names the Type attribute is propagated upward from
VarUseName or the FieldUseName.
In the assignment context it is checked that the types
of both sides are the same, that nil is not used with int.
No message is given if one of the two types is NoKey, which
represents an unknown type due to an error which is reported
elsewhere.
MISSING DEPENDENCE:
The processor generated from the specification given in the task
does complain on "wrong type in assignment" if the definitions
of the involved variables precede the assignment in the program.
However, if the assignment precedes one of the definitions,
the message is not given. In the latter case the call of the
GetType operation has yielded NoKey instead of the defined
type key, and a message is suppressed.
The GetType operation in the FieldUseName must not be called
before all calls of the ResetType operation in the contexts
of VarDefName and FieldDefName are executed. That dependence is
established by the well-known dependence pattern on the
attributes Program.GotType, VarDefName.GotType and, FieldDefName.Type.
~O~<TypeProperty.lido~>~{~-
SYMBOL Program COMPUTE
SYNT.GotType =
CONSTITUENTS (VarDefName.GotType, FieldDefName.GotType);
END;
ATTR Type: DefTableKey;
RULE: Field ::= Type FieldDefName ';' COMPUTE
FieldDefName.Type = Type.Type;
END;
RULE: VariableDecl ::= Type VarDefName ';' COMPUTE
VarDefName.Type = Type.Type;
END;
RULE: Type ::= 'int' COMPUTE
Type.Type = intType;
END;
RULE: Type ::= TypeUseName COMPUTE
Type.Type = TypeUseName.Key;
END;
SYMBOL VarDefName COMPUTE
SYNT.GotType = ResetType (THIS.Key, THIS.Type);
END;
SYMBOL FieldDefName COMPUTE
SYNT.GotType = ResetType (THIS.Key, THIS.Type);
END;
SYMBOL VarUseName COMPUTE
SYNT.Type = GetType (THIS.Key, NoKey)
<- INCLUDING Program.GotType;
END;
SYMBOL FieldUseName COMPUTE
SYNT.Type = GetType (THIS.Key, NoKey)
<- INCLUDING Program.GotType;
END;
RULE: QualifiedName ::= VarUseName COMPUTE
QualifiedName.Type = VarUseName.Type;
END;
RULE: QualifiedName ::= QualifiedName '.' FieldUseName COMPUTE
QualifiedName[1].Type = FieldUseName.Type;
END;
RULE: Assignment ::= QualifiedName '=' Expression ';' COMPUTE
IF (
NOT (OR (OR (OR (EQ (QualifiedName.Type, NoKey),
EQ (Expression.Type, NoKey)),
EQ (QualifiedName.Type, Expression.Type)),
AND (EQ (Expression.Type, nilType),
NE (QualifiedName.Type, intType)))),
message (ERROR, "wrong type in assignment", 0, COORDREF));
END;
RULE: Expression ::= QualifiedName COMPUTE
Expression.Type = QualifiedName.Type;
END;
RULE: Expression ::= Number COMPUTE
Expression.Type = intType;
END;
RULE: Expression ::= 'nil' COMPUTE
Expression.Type = nilType;
END;
~}
Generiert mit Camelot | Probleme mit Camelot? | Geändert am: 08.01.2014