There is another identifier within the current
scope which has the same name (DECLARATION
CONFLICT).  This is not allowed.  You should
either rename this identifier or the other one.
@1
There is either NO DECLARATION or more than
one visible declaration for this applied
occurrence of an identifier.
@2
The only visible declaration for this applied
occurrence of an identifier belongs to a WRONG
NONTERMINAL CLASS. 
@3
The current declaration (document unit) is defined
by (in-)directly using its own declaration (CYCLIC
DEFINITION). This is forbidden. 
@4
Sorry! This increment is erroneous, but the editor's
implementor has forgotten to type in the corresponding
error message!
@11
Your class hierarchy ISN'T A LATTICE! This means that the
current class and another class marked with the same error
have at least two (in-) direct least upper superclasses. 

Therefore,

(1) Create a new common subclass of these superclasses,
(2) make the current class and its "sister" class both
    heirs of this new class and
(3) remove superflouus inheritance edges.

Wrong example:

     A_Class is_a C_Class, D_Class  
and  B_Class is_a C_Class, D_Class

Right example:

     C_D_Class is_a C_Class, D_Class
and  A_Class   is_a C_D_Class
and  B_Class   is_a C_D_Class

This is always possible and produces in allmost all cases
a class hierarchy which is easier to understand and better
to maintain.

This error may be eliminated by using the command

--> ElimThisError
@12
The actual parameter has NO CORRESPONDENT FORMAL PARAMETER
(the number of actual parameters is greater than the over-
all number of formal parameters)!
@16
No Error/Warning eliminated!
@21
Only intrinsic attributes
allowed at this position !
@22
There is NO ASSIGNMENT for this OUT-parameter !
@23
There are MULTIPLE ASSIGNMENTS for this OUT-parameter !
@24
You CAN'T DUPLICATE NODES by identical replacement.
Therefore, multiple references within a production's
right-hand side to one node of the left-hand side
are forbidden.
@25
You CAN'T DUPLICATE SETS of nodes by identical replacement.
Therefore, multiple references within a production's
right-hand side to one set of nodes of the left-hand side
are forbidden.
@51
WRONG (result) TYPE of function !
@52
The INPUT for this path expression belongs to a WRONG
CLASS which is not a subclass of the expected class.
E.g.:

  node_class A_Class is_a B_Class, C_Class end;
  node_class D_Class end;
  edge_type E1: A_Class -> B_Class;
  edge_type  E2: C_Class -> D_Class;

Then, `-E1-> & <-E2-' is erroneous with respect to any
reasonable definition of `erroneous', because B_Class,
the target class of E1, has no common subclass with
D_Class, the source class of `<-E2-'.

And `-E1-> & -E2->' is erroneous, too. But in this case,
the path expression may be transformed into a correct
one (with respect to the language's static semantics)
by the insertion of a type cast:

   `-E1-> & instance_of A_Class & -E2->'

Now, the new path expression explicitely contains the
information that only those target nodes of E1 edges
are possible source nodes of E2 edges which belong to
the common subclass of B_Class and C_Class.
@53
The RESULT of this path expression belongs to a WRONG
CLASS which is not a subclass of the expected target class
(e.g. the corresponding parameter profile's target class).
@54
The OPERAND of the `instance_of' operator MUST BE a SUBCLASS
(or type) of the current INPUT'S CLASS !
@55
ATTRIBUTE is UNDEFINED
for the current node's class !
@56
WRONG TYPE of expression !
@57
The actual parameter list contains NOT ENOUGH
PARAMETERS with respect to the number of par.
in the corresponding formal parameter list.
@58
The result class of the path expression is
the common superclass of the result classes
of its subexpressions. This class DOESN'T EXIST !
@59
The result class of the path expression is
the common subclass of the result classes of
its subexpressions. This class DOESN'T EXIST !
@60
The expression's TYPE is INCOMPATIBLE with
the attribute's type.
@61
The actual parameter's TYPE (class) is INCOMPATIBLE with
the corresponding formal parameter's type (class).
@62
MULTIPLE ASSIGNMENTS to the same intrinsic attribute
within one production are not permitted!
@63
There is MORE THAN ONE (RE-)DEFINITION of this attribute
(within this type/class) !
@64
A node class inherits attribute evaluation rules for
the same attribute from more than one (in-)direct
superclass.  This INHERITANCE CONFLICT must be resolved
explicitely by redefining the concerning attribute
(the adequate point of redefinition, the conflicting
evaluation rules and the attribute's declaration are
marked to be erroneous).

You may create a template for the new redefinition at
an adequate position by activating the command

--> ElimThisError
@65
An EDGE from a set of nodes or an optional node to a
set of nodes or an optional node is NOT ALLOWED for
readability reasons!
@66
The type of this conditional expression
must be BOOLEAN !!
@67
 A L I A S   B A N (G) !!

Don't use the same variable as OUT-
parameter within one parameter list
more than once !
@68
The evaluation of this (conditional) statement has
a FORBIDDEN graph or variable modifying SIDE EFFECT !
@69
An operator may NOT have MORE THAN TWO PARAMETERS !
(infix operators must have two parameters, and prefix/
postfix operators must have one parameter.)
@70
The value of the first OPERAND of a select expression
must be a NODE or a set of nodes.
@71
An intrinsic attribute's value may not depend on another 
attribute's value. Therefore, this attribute SELECTION
is FORBIDDEN here.
@72
ACCESS to (attributes of) node(s) on a production's
right-hand side production is NOT ALLOWED !
@73
A node CLASS as type of a new node is
NOT ALLOWED (use a node type instead)
@74
The old CONTEXT node's inferred CLASS
is NOT ALLOWED to be the new edge's
source/target class.
@75
A graphical definition of a path or
a restriction may NOT contain the
declaration of a SET OF NODES.
@76
The computation of this path expression should
deliver a result which is not equal to its input.
Therefore, RESTRICTIONS are NOT allowed here!
@77
The current expression plays the role of a boolean
expression. Therefore, a real PATH EXPRESSION IS NOT
ALLOWED here. Use the `def' operator to convert
the path expression into a restriction, e.g. convert:

  { -Next-> : -Next-> }

into

  { def -Next->: -Next-> }
@78
The underlying data model doesn't support parallel
edges with the same label. Therefore, EDGES between
identical start and target nodes must have DIFFERENT
LABELS!
@79
Application conditions referring to sets of nodes,
negative or optional nodes are not allowed for
readability reasons. Therefore, DON'T USE node sets,
negative or optional nodes as arguments of (path)
expressions within a rule's left-hand side or within
attribute conditions.
@80
DON'T ACCESS ATTRIBUTES of both left-hand
side and right-hand side nodes within one
expression in order to guarantee the following
property:

Any OUT-parameter's value either depends on
the host graph's state before the application
of the production or it depends on the host
graph's state after the application of the
production.
@81
This expression MUST BE PARTIAL. But its 
static analysis shows that its evaluation
always delivers at least one result.

Therefore, this expression can't play the
role of a boolean condition which is true
whenever its evaluation yields a defined
result and which is false whenever its
result is undefined (the empty set).
@82
The evaluation of this (unguarded) branch
always delivers at least one result. 
This has the consequence that all following 
branches will never be executed.
Therefore, all but last or guarded branches
MUST BE PARTIAL !

Note that in the case of loops also the
last unguarded branch must be partial in
order to guarantee proper termination of
the iteration.
@83
This expression MUST BE DETERMINISTIC !
But static analysis is not able to guarantee
that its evaluation always delivers at most
one possible result.

If you are sure that all actually used appli-
cations deliver a unique result, use the 'type
checking' operator in the following way (with
'type' being the type of 'exp'):

a) exp is expected to be total/defined:
  (exp : type[1:1]) = exp,  if card(exp) = 1.
  (exp : type[1:1]) = halt, if card(exp) # 1.

b) exp may be undefined (sometimes):
  (exp : type[0:1]) = exp,  if card(exp) = 1.
  (exp : type[0:1]) = nil,  if card(exp) # 1.
@84
This expression SHOULD BE NONDETERMINISTIC !
That means that static analysis mustn't be able
to prove that its evaluation always delivers
at most one result.
@85
This expression MUST BE TOTAL. But static
analysis is not able to guarantee that all
possible evaluation contexts allow for the
computation of at least one defined value.

If you are sure that all actually occurring
evaluations deliver a defined value, then use
the `halt' operator to indicate this fact:

    [ expression | halt ]

In this case, an undefined expression value 
in the first branch of `[ ... ]' doesn't
trigger backtracking (as is the usual case) but
results in the evaluation of `halt' in the
second branch (with immediate termination of
the whole execution machinery).
@86
The current operator should only be used to
indicate the assignment of a partial argument
to a variable with always defined value (the
attempt to assign an undefined value starts
backtracking). Therefore, the operator's argument
MUSTN'T BE TOTAL (at least for static analysis)!
@87
The type of this expression belongs to the WRONG STRATUS
of the type system. This means that the `type' is either
a node type but should be a node class or a node class
but should be a node type.

ATTENTION: This error message could be a consequence of
the fact that you are trying to evaluate path expressions
or intrinsic/derived attributes within the definition of
intrinsic/meta attributes.
@88
The body of a restriction MUST BE PARTIAL !
But its static analysis shows that its
evaluation always delivers at least one
result.  Therefore, this expression can't
play the role of a boolean condition which
is true whenever its evaluation yields a
defined result and which is false whenever
its result is undefined (the empty set).
@89
This applied occurrence of a built-in operator
has a WRONG NUMBER OF OPERANDS.
@90
You may NOT use TWO `ALL' operators to iterate
over both arguments simultaneously.
@91
Any operator/function with `all' as prefix for
one of its operands/arguments may NOT have MORE
THAN TWO ARGUMENTS.
@92
The RESULT TYPE of this operator or function is
NOT COMPATIBLE with the the formal type of that
operand or argument which hasn't `all' as its
prefix.
Therefore, the result of the first application
may not be used as an input to the second application. 
Remember that

  f(x, all(y1 or ... or yn)) =
  f(...f(x,y1)...), yn)
@93
Out-Parameter expected
@94
In-Parameter expected
@95
The evaluation of this statement may not modify
the host graph's state. Therefore, the call of a
PRODUCTION or TRANSACTION is strictly FORBIDDEN.
@96
The current attribute points to a node in the
host graph and is nothing else but a labeled
edge (bidirectional link) in the host graph.

Deletions and insertions of edges should be
specified by using productions and by writing
assignments.  Therefore, any ASSIGNMENT to a
node-valued attribute is FORBIDDEN.
@97
The evaluation of `SELF' delivers an UNDEFINED result
because there exists no implicitely defined reference
node within the current context.
@98
Imported functions may only have
STANDARD TYPES or IMPORTED TYPES
as formal parameter types.
@99
In order to use this variable, 
you have to initialize it !!!
@102
Index cannot be created for set-valued/nondeterministic
attributes.
@103
Either source or target of this edge must be a
unique node, the existence of which is required
(a simple solid rectangle and not a dashed or
double or crossed-out rectangle).
@104
The source (target) of this edge is a unique
node and the edge itself has an out- (in-)
fanout of at most one. Therefore, the target
(source) of this edge is a UNIQUE node, too
(a simple solid rectangle and not a dashed or
double rectangle).
@105
Either source or target of this edge must be a
unique node (a simple rectangle and not a double
rectangle).
@106
An identically replaced node on a rule's left-hand
side must be of the same kind as on its right-hand
side (the graphical representation must be the
same).
@107
A `empty' operator's argument MUSTN'T BE TOTAL !
This has the following reason: a total argument
always delivers at least one result. Therefore,
the surrounding `empty' expression is equal to
`true' and should be replaced by this constant.
@108
Paths and restrictions with parameters may
not be static (materialized).
@109
A meta attribute may not have a node value
(use only integer/string/... and node types
as values).
@110
A "for_all" or "exist" variable is not allowed
to be either partial or nondeterministic.
@111
The textual embedding part of a production may not
contain references to set nodes (because set nodes
shall be used for constructing graphical embeddings,
and embeddings of embeddings are not useful).
@112
The all operator may not be used together with
this standard operator. 
Allowed standard operators for left-all are:
+, *
Allowed standard operators for right-all are:
+, -, *, /, %
@113
Surrounding expression of all must be function
with two arguments or binary operator.
@114
The result type of this function must be
BOOLEAN!
@115
The type of this variable must be BOOLEAN!
@116
@117
The purpose of a folding-statement is to allow
some nodes from the left-hand-side of a production
to be matched by the same node in the host graph.

This folding-statement contains as well nodes
to be deleted as nodes to be preserved. If they
are matched by the same node in the host graph,
this node would have to be deleted and preserved
at the same time - which, of course, is impossible.

So you have to change this folding-statement:
It may contain either nodes to be deleted or
nodes to be preserved, but not both.
@118
There are nodes of different types within this
fold. This is not allowed!
@121
It doesn't make any sense to identically replace
a negative node!
@122
A negative node must not be the source
of a path condition.
@123
Referring to a negative within texutal embedding
doesn't make sense: Negative nodes are nodes 
that do NOT exist in the host graph and there-
fore there aren't any edges connected to these
non-existing nodes. Consequently, these non-
existing edges neither may be copied nor
removed.
@124
Referring to a negative within folds
is forbidden for readability reasons.
@125
The 'all' operator may only be used to iterate through sets
which are an argument of a binary function call or an infix 
operator. Iteration of path expressions is an implicit 
property of their definition (and therefore not useful)
and iterated application of productions, transactions etc.
should be done using the 'for_all' statement.
@126
'Index' or 'Key' not allowed for
node type valued attributes.
@127
Negative nodes are not allowed within expressions.
@128
The not-all argument must be 
element valued.
@129
Sorry, this feature hasn't been implemented yet.
@130
The result type of an all-iterated 
function/operator must be type compatible 
with the non-all increment.
@131
You cannot typecast this expression since its type 
is a standard type. If you deal with an expression 
of the form Node.Attr you have to put brackets
around it, in order to obtain the result that you 
probably want.
@132
Inverse traversal of path is only supported if
path (declaration) is static, i.e. the result of
the path call is stored in the form of additional
edges in the graph.
@133
Out parameters of a Star (*) production must be
optional sets [0:n], out parameters of a Plus (+)
production must be optional sets [0:n] or 
obligate sets [1:n].
@135
Tests or Queries must be partial !

The default-setting is [0:n] if it has Out-Parameters,
[0:1] otherwise. Therefore replace the 'OptQualifier'
with

      [0:1]  (if it has Out-Parameters,
              but should be deterministic)

or    [0:n]  (can be left out,
              if it has no Out-Parameters)
@136
Your Test/Query has no Out-Parameter and that's why it is
deterministic. If you want to specify an Opt-Qualifier,
please change it to 
                         [0:1]

(Remember: That's the default-setting in this case)
@137
This Identifier is an Out-Parameter which 
may not be used in this expression!
@138
This Production or Transaction must be safe!
@139
Node declarations may be from 
constraint's left side only!
@140
Access to Constraint-Attributes not allowed!
@141
An EnsureStat is only allowed in Constraints!
@142
Star/Plus-tests must have at least one 
(set-valued) out-parameter !
@143
Attribute assignments for set or optional variables
are not allowed (not yet implemented). 

Please rewrite 

  SetOptNode.Att := ...

into 

 for_all n := elem(SetOptNode) do n.Att := ... end
@144
Tests/queries without out-parameters can't compute
any result and may not modify the host graph's state.

Therefore they must be partial !  Any call would be
successful otherwise, which makes no sense !

So please replace the 'OptQualifier' with [0:1].
(Note : That's the default-setting in this case)
@145
Your transaction/query is specified to be deterministic,
but static analysis shows that this part of the body
is NONDETERMINISTIC !

Therefore make sure that it is deterministic.

You can use the CutStat e.g. Otherwise you should check,
if the transaction/query isn't nondeterministic.
@146
Your transaction/query is specified to be total, but static
analysis shows that this part of the body is PARTIAL !

If you want the body to be total, you can ensure this
by using the cut-statement :

Write          B : [1:1]    (if it should be deterministic)
        or     B : [1:n]    (if it should be nondeterministic)

You also can use the choose-statement for doing so :

     choose B else D end    ( D = [ halt | skip ] )
@147
This Statement has to be total, but 
static analysis shows that it is partial.
@148
This Statement has to be partial, but
static analysis shows that it is total.
@149
Sorry, this statement may not be the body
of a cut-statement
@150
This cut-statement does not match the declaration
of your transaction/query.
@151
The instance_of-Expression is only allowed 
within transactions or queries!
@152
This part of the local-list must be total,
but static analysis shows that it is PARTIAL !
@153
This part of the local-list must be deterministic,
but static analysis shows that it is NON-DETERMINISTIC !
@154
The use of a guard in the last branch of
a choose-statement makes this statement PARTIAL !

But static analysis shows that the transaction is 
declared to be total, so there mustn't be a guard
in the last branch !
@155
Assignment of a set-valued expression to a list of 
element-valued variables is not yet implemented.
Please specify a single declaration for each
variable.
@156
Each node can only be a member 
of at most one folding set. 
@201
Your specification is incomplete!
You have to EXPAND this PLACEHOLDER.
@202
There is NO APPLIED OCCURRENCE (or there
are too many applied occurrences) for this
declaration.
@211
There's already a transitive dependency
between these classes! This warning may be
eliminated by using the command

--> ElimThisError
@221
This IN-parameter IS NOT USED and therefore
obviously useless.
@241
The language has no built-in operator
precedence rules!! Therefore, please 
add parentheses!
@242
This list contains only one element. Use
a term instead of a list with one term.
@243
There is no Type available for this Variable.
@244
Assignment of a potentially PARTIAL expression
to a variable (formal parameter), which is not
allowed to have an undefined value, is dangerous:
The attempt to assign an undefined value triggers
backtracking! Therefore, please avoid assignments of
the following form (by changing the type definition
of TotalVar)

  TotalVar := PartialExpr

or rewrite the assignment into

 choose when empty(PartialExpr) then
   fail (* or do something else *)
 else
   TotalVar := [ PartialExpr | halt ]
 end
@245
Assignment of a potentially NONDETERMINISTIC
expression to a variable (formal parameter) which
is not allowed to hold a set of values is dangerous:
The assignment has to select one result out of all
possible results, randomly. A wrong selection may
be the reason for subsequent actions to fail. Then,
backtracking has to occur, and the execution has
to restart with the assignment of another randomly
chosen value! Therefore, replace

 Partial_V/Total_V := Set 

by

 Partial_V/Total_V := elem(Set)

in order to inform a reader of the specification
about intended nondeterminism which might cause
backtracking.

Being sure that the evaluation of this expression
always yields at most one result, you may also write
(with 'type' being the type of 'Set'):

a) Set is expected to contain exactly one element:
  (Set : type[1:1]) = Set,  if card(Set) = 1.
  (Set : type[1:1]) = halt, if card(Set) # 1.

b) Set contains at most one element:
  (Set : type[0:1]) = Set,  if card(Set) = 1.
  (Set : type[0:1]) = nil,  if card(Set) # 1.

@246
There are different assignments to the same attribute
of two or more nodes contained in one fold.
In case of a non-injective morphism (i.e. the image of 
the two nodes is the same), these assignments may
contradict each other.
@247
There must be at least two ApplNodeIds
within a Fold.
@248
This edge has been declared to be unique with
respect to its target node: For each (target)
node, there may only be one single incoming edge
of this type.
@249
This edge has been declared to be unique with
respect to its source node: For each (source)
node, there may only be one single outgoing edge
of this type.
@250
This test/query has no out-parameter and that's why it is
DETERMINISTIC. If you want to use an qualifier, you
should change it to 
                         [0:1]

(Note: That's the default-setting in this case)
@251
Static analysis shows that a match for this left side
of the production/test can be computed DETERMINISTICLY.

In order to inform the reader of this declaration
about the correct cardinality you should set the
OptPTQualifier to deterministic !

Note : This can speed up the runtime-behavior !
@252
CUT - WARNING !

This is a NONDETERMINISTIC operation ! It is used
inside a cut-statement which is declared to be
deterministic.

Because the cut-statement prevents backtracking,
some results may be lost !
@253
This node of the production/test left side is NONDETERMINISTIC,
graph search must select one of all possible nodes.

But the production/test is declared to be deterministic,
so backtracking is prevented: Other matches for the left side
with different matches for this node will not occur !
@254
Static analysis shows that the body of this query is TOTAL !

So note, that this query will always have success.
@255
Static analysis shows that the body of this cut-statement
is TOTAL !

Therefore, you should change the OptQualifer to

        [1:1]    (if the body should be deterministic)
        [1:n]    (if the body should be nondeterministic)

in order to inform a reader of this specification about
the correct cardinaltity of this cut-statement.
@256
Static analysis shows that the body of this cut-statement
is DETERMINISTIC !

Therefore, you should change the OptQualifer to

        [0:1]    (if the body is partial)
or      [1:1]    (if you can ensure that it is total)

in order to inform a reader of this specification about
the correct cardinaltity of this cut-statement.
@257
Assignment of a partial formal out-parameter to a total
actual out-parameter is dangerous. It triggers backtracking
if the evaluation of the call computes the empty set of
values for the out parameter (which cannot be assigned
to a total variable or parameter).

Please replace total actual out-parameter by partial
total variable, i.e. variable of form

   v : Type [0:1]   or   v : Type [0:n]
@258
Assignment of a set-valued (nondeterministic) formal
out-parameter to a element-valued actual out-parameter
is dangerous. It creates sometimes unwanted nondeterminism
by assigning an arbitrarily selected value of the
computed set to the actual out-parameter.
 
Please replace element-valued actual out-parameter by 
set-valued variable, i.e. variable of form
 
   v : Type [0:n]   or   v : Type [1:n]
@301
This part of the document has been changed 
in both versions.
@302
This part of the document has been added or 
changed in this version.
@303
WARNING: Actual binding does not correspond
         to expected binding -
         Modification impossible!
@304
ATTENTION: Expected binding ambiguous, but
           only one actually possible -
           automatically bound!
@305
ATTENTION: Automatically bound!
@306
ATTENTION: No binding possible!
@351
This applied identifier
has lost its declaration.
@352
This identifier has been
bound to a new declaration.
