Copyright (C) 1990, Digital Equipment Corporation.
All rights reserved.
See the file COPYRIGHT for a full description.
Last modified on Mon Aug 8 16:10:01 PDT 1994 by kalsow
modified on Fri Jan 28 10:57:13 PST 1994 by detlefs
MODULE M3AST_AS_Iter;
IMPORT AST, M3AST_AS;
IMPORT M3AST_AS_F;
IMPORT AST_Iter;
IMPORT SeqM3AST_AS_IMPORTED,
SeqM3AST_AS_Used_interface_id, SeqM3AST_AS_Used_def_id,
SeqM3AST_AS_Import_item, SeqM3AST_AS_F_Interface_id,
SeqM3AST_AS_REVELATION, SeqM3AST_AS_DECL_REVL, SeqM3AST_AS_Const_decl,
SeqM3AST_AS_TYPE_DECL, SeqM3AST_AS_Var_decl, SeqM3AST_AS_Exc_decl,
SeqM3AST_AS_Var_id, SeqM3AST_AS_Enum_id,
SeqM3AST_AS_Field_id, SeqM3AST_AS_FORMAL_ID, SeqM3AST_AS_Qual_used_id,
SeqM3AST_AS_Fields, SeqM3AST_AS_Method, SeqM3AST_AS_M3TYPE,
SeqM3AST_AS_Formal_param, SeqM3AST_AS_CONS_ELEM,
SeqM3AST_AS_EXP, SeqM3AST_AS_Actual, SeqM3AST_AS_Case, SeqM3AST_AS_STM,
SeqM3AST_AS_Elsif, SeqM3AST_AS_Tcase, SeqM3AST_AS_Handler,
SeqM3AST_AS_Binding, SeqM3AST_AS_RANGE_EXP;
IMPORT M3AST_AS_Iter_rep;
PROCEDURE By_update(iter: By_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
END;
END By_update;
PROCEDURE By_next(iter: By_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END By_next;
TYPE
By_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.By;
OVERRIDES
next := By_next;
update := By_update;
END;
PROCEDURE Binding_update(iter: Binding_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_exp := nn;
END;
END Binding_update;
PROCEDURE Binding_next(iter: Binding_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Binding_next;
TYPE
Binding_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Binding;
OVERRIDES
next := Binding_next;
update := Binding_update;
END;
PROCEDURE Handler_update(iter: Handler_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Qual_used_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Qual_used_id.Update(iter.n.as_qual_id_s, iter.iter0,
nn);
RETURN ;
END;
| 1 =>
iter.n.as_id := nn;
RETURN ;
| 2 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter1) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter1, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Handler_update;
PROCEDURE Handler_next(iter: Handler_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
VAR
node0: M3AST_AS.Qual_used_id;
node1: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Qual_used_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_id;
EXIT;
| 2 =>
IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Handler_next;
TYPE
Handler_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Handler;
iter0: SeqM3AST_AS_Qual_used_id.Iter;
iter1: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Handler_next;
update := Handler_update;
END;
PROCEDURE Tcase_update(iter: Tcase_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_M3TYPE.Exhausted(iter.iter0) THEN
SeqM3AST_AS_M3TYPE.Update(iter.n.as_type_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_id := nn;
RETURN ;
| 2 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter1) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter1, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Tcase_update;
PROCEDURE Tcase_next(iter: Tcase_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.M3TYPE;
node1: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_M3TYPE.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_id;
EXIT;
| 2 =>
IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Tcase_next;
TYPE
Tcase_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Tcase;
iter0: SeqM3AST_AS_M3TYPE.Iter;
iter1: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Tcase_next;
update := Tcase_update;
END;
PROCEDURE Try_finally_update(iter: Try_finally_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Try_finally_update;
PROCEDURE Try_finally_next(iter: Try_finally_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Try_finally_next;
TYPE
Try_finally_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Try_finally;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Try_finally_next;
update := Try_finally_update;
END;
PROCEDURE Try_except_update(iter: Try_except_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Handler.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Handler.Update(iter.n.as_handler_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_else := nn;
RETURN ;
| 2 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter1) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter1, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Try_except_update;
PROCEDURE Try_except_next(iter: Try_except_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Handler;
node1: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Handler.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_else;
EXIT;
| 2 =>
IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Try_except_next;
TYPE
Try_except_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Try_except;
iter0: SeqM3AST_AS_Handler.Iter;
iter1: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Try_except_next;
update := Try_except_update;
END;
PROCEDURE Elsif_update(iter: Elsif_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Elsif_update;
PROCEDURE Elsif_next(iter: Elsif_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
EXIT;
| 1 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Elsif_next;
TYPE
Elsif_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Elsif;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Elsif_next;
update := Elsif_update;
END;
PROCEDURE Else_stm_update(iter: Else_stm_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Else_stm_update;
PROCEDURE Else_stm_next(iter: Else_stm_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Else_stm_next;
TYPE
Else_stm_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Else_stm;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Else_stm_next;
update := Else_stm_update;
END;
PROCEDURE Case_update(iter: Case_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_RANGE_EXP.Exhausted(iter.iter0) THEN
SeqM3AST_AS_RANGE_EXP.Update(iter.n.as_case_label_s, iter.iter0,
nn);
RETURN ;
END;
| 1 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter1) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter1, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Case_update;
PROCEDURE Case_next(iter: Case_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.RANGE_EXP;
node1: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_RANGE_EXP.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Case_next;
TYPE
Case_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Case;
iter0: SeqM3AST_AS_RANGE_EXP.Iter;
iter1: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Case_next;
update := Case_update;
END;
PROCEDURE Block_update(iter: Block_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_DECL_REVL.Exhausted(iter.iter0) THEN
SeqM3AST_AS_DECL_REVL.Update(iter.n.as_decl_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter1) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter1, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Block_update;
PROCEDURE Block_next(iter: Block_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.DECL_REVL;
node1: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_DECL_REVL.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Block_next;
TYPE
Block_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Block;
iter0: SeqM3AST_AS_DECL_REVL.Iter;
iter1: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Block_next;
update := Block_update;
END;
PROCEDURE With_st_update(iter: With_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Binding.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Binding.Update(iter.n.as_binding_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter1) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter1, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END With_st_update;
PROCEDURE With_st_next(iter: With_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
VAR
node0: M3AST_AS.Binding;
node1: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Binding.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END With_st_next;
TYPE
With_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.With_st;
iter0: SeqM3AST_AS_Binding.Iter;
iter1: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := With_st_next;
update := With_st_update;
END;
PROCEDURE While_st_update(iter: While_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END While_st_update;
PROCEDURE While_st_next(iter: While_st_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
EXIT;
| 1 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END While_st_next;
TYPE
While_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.While_st;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := While_st_next;
update := While_st_update;
END;
PROCEDURE Typecase_st_update(iter: Typecase_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_Tcase.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Tcase.Update(iter.n.as_tcase_s, iter.iter0, nn);
RETURN ;
END;
| 2 =>
iter.n.as_else := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Typecase_st_update;
PROCEDURE Typecase_st_next(iter: Typecase_st_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Tcase;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
EXIT;
| 1 =>
IF SeqM3AST_AS_Tcase.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 2 =>
r := iter.n.as_else;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Typecase_st_next;
TYPE
Typecase_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Typecase_st;
iter0: SeqM3AST_AS_Tcase.Iter;
OVERRIDES
next := Typecase_st_next;
update := Typecase_st_update;
END;
PROCEDURE Try_st_update(iter: Try_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_try_tail := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Try_st_update;
PROCEDURE Try_st_next(iter: Try_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_try_tail;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Try_st_next;
TYPE
Try_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Try_st;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Try_st_next;
update := Try_st_update;
END;
PROCEDURE Return_st_update(iter: Return_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
END;
END Return_st_update;
PROCEDURE Return_st_next(iter: Return_st_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Return_st_next;
TYPE
Return_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Return_st;
OVERRIDES
next := Return_st_next;
update := Return_st_update;
END;
PROCEDURE Repeat_st_update(iter: Repeat_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_exp := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Repeat_st_update;
PROCEDURE Repeat_st_next(iter: Repeat_st_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_exp;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Repeat_st_next;
TYPE
Repeat_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Repeat_st;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Repeat_st_next;
update := Repeat_st_update;
END;
PROCEDURE Raise_st_update(iter: Raise_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_qual_id := nn;
| 1 =>
iter.n.as_exp_void := nn;
END;
END Raise_st_update;
PROCEDURE Raise_st_next(iter: Raise_st_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_qual_id;
| 1 =>
r := iter.n.as_exp_void;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Raise_st_next;
TYPE
Raise_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Raise_st;
OVERRIDES
next := Raise_st_next;
update := Raise_st_update;
END;
PROCEDURE Loop_st_update(iter: Loop_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Loop_st_update;
PROCEDURE Loop_st_next(iter: Loop_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Loop_st_next;
TYPE
Loop_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Loop_st;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Loop_st_next;
update := Loop_st_update;
END;
PROCEDURE Lock_st_update(iter: Lock_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Lock_st_update;
PROCEDURE Lock_st_next(iter: Lock_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
EXIT;
| 1 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Lock_st_next;
TYPE
Lock_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Lock_st;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := Lock_st_next;
update := Lock_st_update;
END;
PROCEDURE If_st_update(iter: If_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
| 2 =>
IF NOT SeqM3AST_AS_Elsif.Exhausted(iter.iter1) THEN
SeqM3AST_AS_Elsif.Update(iter.n.as_elsif_s, iter.iter1, nn);
RETURN ;
END;
| 3 =>
iter.n.as_else := nn;
RETURN ;
END;
INC(iter.slot);
END;
END If_st_update;
PROCEDURE If_st_next(iter: If_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.STM;
node1: M3AST_AS.Elsif;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
EXIT;
| 1 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 2 =>
IF SeqM3AST_AS_Elsif.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
| 3 =>
r := iter.n.as_else;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END If_st_next;
TYPE
If_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.If_st;
iter0: SeqM3AST_AS_STM.Iter;
iter1: SeqM3AST_AS_Elsif.Iter;
OVERRIDES
next := If_st_next;
update := If_st_update;
END;
PROCEDURE For_st_update(iter: For_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
RETURN ;
| 1 =>
iter.n.as_from := nn;
RETURN ;
| 2 =>
iter.n.as_to := nn;
RETURN ;
| 3 =>
iter.n.as_by := nn;
RETURN ;
| 4 =>
IF NOT SeqM3AST_AS_STM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_STM.Update(iter.n.as_stm_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END For_st_update;
PROCEDURE For_st_next(iter: For_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.STM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
EXIT;
| 1 =>
r := iter.n.as_from;
EXIT;
| 2 =>
r := iter.n.as_to;
EXIT;
| 3 =>
r := iter.n.as_by;
EXIT;
| 4 =>
IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END For_st_next;
TYPE
For_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.For_st;
iter0: SeqM3AST_AS_STM.Iter;
OVERRIDES
next := For_st_next;
update := For_st_update;
END;
PROCEDURE Exit_st_update(<*UNUSED*> iter: Exit_st_iter;
<*UNUSED*> nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
END;
END Exit_st_update;
PROCEDURE Exit_st_next(<*UNUSED*>iter: Exit_st_iter;
<*UNUSED*>VAR r: AST.NODE): BOOLEAN RAISES {
}=
BEGIN
RETURN FALSE;
END Exit_st_next;
TYPE
Exit_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Exit_st;
OVERRIDES
next := Exit_st_next;
update := Exit_st_update;
END;
PROCEDURE Eval_st_update(iter: Eval_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
END;
END Eval_st_update;
PROCEDURE Eval_st_next(iter: Eval_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Eval_st_next;
TYPE
Eval_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Eval_st;
OVERRIDES
next := Eval_st_next;
update := Eval_st_update;
END;
PROCEDURE Case_st_update(iter: Case_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_Case.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Case.Update(iter.n.as_case_s, iter.iter0, nn);
RETURN ;
END;
| 2 =>
iter.n.as_else := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Case_st_update;
PROCEDURE Case_st_next(iter: Case_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
VAR
node0: M3AST_AS.Case;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
EXIT;
| 1 =>
IF SeqM3AST_AS_Case.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 2 =>
r := iter.n.as_else;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Case_st_next;
TYPE
Case_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Case_st;
iter0: SeqM3AST_AS_Case.Iter;
OVERRIDES
next := Case_st_next;
update := Case_st_update;
END;
PROCEDURE Call_st_update(iter: Call_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_call := nn;
END;
END Call_st_update;
PROCEDURE Call_st_next(iter: Call_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_call;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Call_st_next;
TYPE
Call_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Call_st;
OVERRIDES
next := Call_st_next;
update := Call_st_update;
END;
PROCEDURE Assign_st_update(iter: Assign_st_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_lhs_exp := nn;
| 1 =>
iter.n.as_rhs_exp := nn;
END;
END Assign_st_update;
PROCEDURE Assign_st_next(iter: Assign_st_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_lhs_exp;
| 1 =>
r := iter.n.as_rhs_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Assign_st_next;
TYPE
Assign_st_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Assign_st;
OVERRIDES
next := Assign_st_next;
update := Assign_st_update;
END;
PROCEDURE Actual_update(iter: Actual_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_exp_type := nn;
END;
END Actual_update;
PROCEDURE Actual_next(iter: Actual_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_exp_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Actual_next;
TYPE
Actual_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Actual;
OVERRIDES
next := Actual_next;
update := Actual_update;
END;
PROCEDURE Index_update(iter: Index_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_array := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_EXP.Exhausted(iter.iter0) THEN
SeqM3AST_AS_EXP.Update(iter.n.as_exp_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Index_update;
PROCEDURE Index_next(iter: Index_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.EXP;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_array;
EXIT;
| 1 =>
IF SeqM3AST_AS_EXP.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Index_next;
TYPE
Index_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Index;
iter0: SeqM3AST_AS_EXP.Iter;
OVERRIDES
next := Index_next;
update := Index_update;
END;
PROCEDURE Call_update(iter: Call_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_callexp := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_Actual.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Actual.Update(iter.n.as_param_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Call_update;
PROCEDURE Call_next(iter: Call_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Actual;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_callexp;
EXIT;
| 1 =>
IF SeqM3AST_AS_Actual.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Call_next;
TYPE
Call_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Call;
iter0: SeqM3AST_AS_Actual.Iter;
OVERRIDES
next := Call_next;
update := Call_update;
END;
PROCEDURE Select_update(iter: Select_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
| 1 =>
iter.n.as_id := nn;
END;
END Select_update;
PROCEDURE Select_next(iter: Select_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
| 1 =>
r := iter.n.as_id;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Select_next;
TYPE
Select_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Select;
OVERRIDES
next := Select_next;
update := Select_update;
END;
PROCEDURE UNARY_update(iter: UNARY_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
END;
END UNARY_update;
PROCEDURE UNARY_next(iter: UNARY_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END UNARY_next;
TYPE
UNARY_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.UNARY;
OVERRIDES
next := UNARY_next;
update := UNARY_update;
END;
PROCEDURE BINARY_update(iter: BINARY_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp1 := nn;
| 1 =>
iter.n.as_exp2 := nn;
END;
END BINARY_update;
PROCEDURE BINARY_next(iter: BINARY_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp1;
| 1 =>
r := iter.n.as_exp2;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END BINARY_next;
TYPE
BINARY_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.BINARY;
OVERRIDES
next := BINARY_next;
update := BINARY_update;
END;
PROCEDURE Propagate_update(iter: Propagate_iter;
<*UNUSED*> nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
END;
END Propagate_update;
PROCEDURE Propagate_next(<*UNUSED*> iter: Propagate_iter; <*UNUSED*> VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
RETURN FALSE;
END Propagate_next;
TYPE
Propagate_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Propagate;
OVERRIDES
next := Propagate_next;
update := Propagate_update;
END;
PROCEDURE Actual_elem_update(iter: Actual_elem_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_actual := nn;
END;
END Actual_elem_update;
PROCEDURE Actual_elem_next(iter: Actual_elem_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_actual;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Actual_elem_next;
TYPE
Actual_elem_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Actual_elem;
OVERRIDES
next := Actual_elem_next;
update := Actual_elem_update;
END;
PROCEDURE RANGE_EXP_elem_update(iter: RANGE_EXP_elem_iter; nn: AST.NODE)
RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_range_exp := nn;
END;
END RANGE_EXP_elem_update;
PROCEDURE RANGE_EXP_elem_next(iter: RANGE_EXP_elem_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_range_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END RANGE_EXP_elem_next;
TYPE
RANGE_EXP_elem_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.RANGE_EXP_elem;
OVERRIDES
next := RANGE_EXP_elem_next;
update := RANGE_EXP_elem_update;
END;
PROCEDURE Constructor_update(iter: Constructor_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_type := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_CONS_ELEM.Exhausted(iter.iter0) THEN
SeqM3AST_AS_CONS_ELEM.Update(iter.n.as_element_s, iter.iter0, nn);
RETURN ;
END;
| 2 =>
iter.n.as_propagate := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Constructor_update;
PROCEDURE Constructor_next(iter: Constructor_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.CONS_ELEM;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_type;
EXIT;
| 1 =>
IF SeqM3AST_AS_CONS_ELEM.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 2 =>
r := iter.n.as_propagate;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Constructor_next;
TYPE
Constructor_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Constructor;
iter0: SeqM3AST_AS_CONS_ELEM.Iter;
OVERRIDES
next := Constructor_next;
update := Constructor_update;
END;
PROCEDURE Range_update(iter: Range_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp1 := nn;
| 1 =>
iter.n.as_exp2 := nn;
END;
END Range_update;
PROCEDURE Range_next(iter: Range_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp1;
| 1 =>
r := iter.n.as_exp2;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Range_next;
TYPE
Range_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Range;
OVERRIDES
next := Range_next;
update := Range_update;
END;
PROCEDURE Range_EXP_update(iter: Range_EXP_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
END;
END Range_EXP_update;
PROCEDURE Range_EXP_next(iter: Range_EXP_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Range_EXP_next;
TYPE
Range_EXP_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Range_EXP;
OVERRIDES
next := Range_EXP_next;
update := Range_EXP_update;
END;
PROCEDURE Raisees_some_update(iter: Raisees_some_iter; nn: AST.NODE) RAISES {
}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Qual_used_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Qual_used_id.Update(iter.n.as_raisees_s, iter.iter0,
nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Raisees_some_update;
PROCEDURE Raisees_some_next(iter: Raisees_some_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Qual_used_id;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Qual_used_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Raisees_some_next;
TYPE
Raisees_some_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Raisees_some;
iter0: SeqM3AST_AS_Qual_used_id.Iter;
OVERRIDES
next := Raisees_some_next;
update := Raisees_some_update;
END;
PROCEDURE Formal_param_update(iter: Formal_param_iter; nn: AST.NODE) RAISES {
}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_FORMAL_ID.Exhausted(iter.iter0) THEN
SeqM3AST_AS_FORMAL_ID.Update(iter.n.as_id_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_formal_type := nn;
RETURN ;
| 2 =>
iter.n.as_default := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Formal_param_update;
PROCEDURE Formal_param_next(iter: Formal_param_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.FORMAL_ID;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_FORMAL_ID.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_formal_type;
EXIT;
| 2 =>
r := iter.n.as_default;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Formal_param_next;
TYPE
Formal_param_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Formal_param;
iter0: SeqM3AST_AS_FORMAL_ID.Iter;
OVERRIDES
next := Formal_param_next;
update := Formal_param_update;
END;
PROCEDURE Override_update(iter: Override_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_default := nn;
END;
END Override_update;
PROCEDURE Override_next(iter: Override_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_default;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Override_next;
TYPE
Override_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Override;
OVERRIDES
next := Override_next;
update := Override_update;
END;
PROCEDURE Method_update(iter: Method_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_type := nn;
| 1 =>
iter.n.as_id := nn;
| 2 =>
iter.n.as_default := nn;
END;
END Method_update;
PROCEDURE Method_next(iter: Method_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_type;
| 1 =>
r := iter.n.as_id;
| 2 =>
r := iter.n.as_default;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Method_next;
TYPE
Method_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Method;
OVERRIDES
next := Method_next;
update := Method_update;
END;
PROCEDURE Fields_update(iter: Fields_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Field_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Field_id.Update(iter.n.as_id_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_type := nn;
RETURN ;
| 2 =>
iter.n.as_default := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Fields_update;
PROCEDURE Fields_next(iter: Fields_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Field_id;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Field_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_type;
EXIT;
| 2 =>
r := iter.n.as_default;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Fields_next;
TYPE
Fields_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Fields;
iter0: SeqM3AST_AS_Field_id.Iter;
OVERRIDES
next := Fields_next;
update := Fields_update;
END;
PROCEDURE Brand_update(iter: Brand_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
END;
END Brand_update;
PROCEDURE Brand_next(iter: Brand_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Brand_next;
TYPE
Brand_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Brand;
OVERRIDES
next := Brand_next;
update := Brand_update;
END;
PROCEDURE Opaque_type_update(iter: Opaque_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_type := nn;
END;
END Opaque_type_update;
PROCEDURE Opaque_type_next(iter: Opaque_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Opaque_type_next;
TYPE
Opaque_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Opaque_type;
OVERRIDES
next := Opaque_type_next;
update := Opaque_type_update;
END;
PROCEDURE Packed_type_update(iter: Packed_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_exp := nn;
| 1 =>
iter.n.as_type := nn;
END;
END Packed_type_update;
PROCEDURE Packed_type_next(iter: Packed_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_exp;
| 1 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Packed_type_next;
TYPE
Packed_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Packed_type;
OVERRIDES
next := Packed_type_next;
update := Packed_type_update;
END;
PROCEDURE Ref_type_update(iter: Ref_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_trace_mode := nn;
| 1 =>
iter.n.as_brand := nn;
| 2 =>
iter.n.as_type := nn;
END;
END Ref_type_update;
PROCEDURE Ref_type_next(iter: Ref_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_trace_mode;
| 1 =>
r := iter.n.as_brand;
| 2 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Ref_type_next;
TYPE
Ref_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Ref_type;
OVERRIDES
next := Ref_type_next;
update := Ref_type_update;
END;
PROCEDURE Procedure_type_update(iter: Procedure_type_iter; nn: AST.NODE)
RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Formal_param.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Formal_param.Update(iter.n.as_formal_param_s, iter.
iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_result_type := nn;
RETURN ;
| 2 =>
iter.n.as_raises := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Procedure_type_update;
PROCEDURE Procedure_type_next(iter: Procedure_type_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Formal_param;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Formal_param.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_result_type;
EXIT;
| 2 =>
r := iter.n.as_raises;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Procedure_type_next;
TYPE
Procedure_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Procedure_type;
iter0: SeqM3AST_AS_Formal_param.Iter;
OVERRIDES
next := Procedure_type_next;
update := Procedure_type_update;
END;
PROCEDURE Set_type_update(iter: Set_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_type := nn;
END;
END Set_type_update;
PROCEDURE Set_type_next(iter: Set_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Set_type_next;
TYPE
Set_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Set_type;
OVERRIDES
next := Set_type_next;
update := Set_type_update;
END;
PROCEDURE Object_type_update(iter: Object_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_ancestor := nn;
RETURN ;
| 1 =>
iter.n.as_brand := nn;
RETURN ;
| 2 =>
IF NOT SeqM3AST_AS_Fields.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Fields.Update(iter.n.as_fields_s, iter.iter0, nn);
RETURN ;
END;
| 3 =>
IF NOT SeqM3AST_AS_Method.Exhausted(iter.iter1) THEN
SeqM3AST_AS_Method.Update(iter.n.as_method_s, iter.iter1, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Object_type_update;
PROCEDURE Object_type_next(iter: Object_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Fields;
node1: M3AST_AS.Method;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_ancestor;
EXIT;
| 1 =>
r := iter.n.as_brand;
EXIT;
| 2 =>
IF SeqM3AST_AS_Fields.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 3 =>
IF SeqM3AST_AS_Method.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Object_type_next;
TYPE
Object_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Object_type;
iter0: SeqM3AST_AS_Fields.Iter;
iter1: SeqM3AST_AS_Method.Iter;
OVERRIDES
next := Object_type_next;
update := Object_type_update;
END;
PROCEDURE Record_type_update(iter: Record_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Fields.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Fields.Update(iter.n.as_fields_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Record_type_update;
PROCEDURE Record_type_next(iter: Record_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Fields;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Fields.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Record_type_next;
TYPE
Record_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Record_type;
iter0: SeqM3AST_AS_Fields.Iter;
OVERRIDES
next := Record_type_next;
update := Record_type_update;
END;
PROCEDURE Array_type_update(iter: Array_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_M3TYPE.Exhausted(iter.iter0) THEN
SeqM3AST_AS_M3TYPE.Update(iter.n.as_indextype_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_elementtype := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Array_type_update;
PROCEDURE Array_type_next(iter: Array_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.M3TYPE;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_M3TYPE.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_elementtype;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Array_type_next;
TYPE
Array_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Array_type;
iter0: SeqM3AST_AS_M3TYPE.Iter;
OVERRIDES
next := Array_type_next;
update := Array_type_update;
END;
PROCEDURE Subrange_type_update(iter: Subrange_type_iter; nn: AST.NODE)
RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_range := nn;
END;
END Subrange_type_update;
PROCEDURE Subrange_type_next(iter: Subrange_type_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_range;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Subrange_type_next;
TYPE
Subrange_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Subrange_type;
OVERRIDES
next := Subrange_type_next;
update := Subrange_type_update;
END;
PROCEDURE Enumeration_type_update(iter: Enumeration_type_iter; nn: AST.NODE)
RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Enum_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Enum_id.Update(iter.n.as_id_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Enumeration_type_update;
PROCEDURE Enumeration_type_next(iter: Enumeration_type_iter; VAR r: AST.NODE)
: BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Enum_id;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Enum_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Enumeration_type_next;
TYPE
Enumeration_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Enumeration_type;
iter0: SeqM3AST_AS_Enum_id.Iter;
OVERRIDES
next := Enumeration_type_next;
update := Enumeration_type_update;
END;
PROCEDURE Root_type_update(iter: Root_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_trace_mode := nn;
END;
END Root_type_update;
PROCEDURE Root_type_next(iter: Root_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_trace_mode;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Root_type_next;
TYPE
Root_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Root_type;
OVERRIDES
next := Root_type_next;
update := Root_type_update;
END;
PROCEDURE Named_type_update(iter: Named_type_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_qual_id := nn;
END;
END Named_type_update;
PROCEDURE Named_type_next(iter: Named_type_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_qual_id;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Named_type_next;
TYPE
Named_type_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Named_type;
OVERRIDES
next := Named_type_next;
update := Named_type_update;
END;
PROCEDURE Concrete_reveal_update(iter: Concrete_reveal_iter; nn: AST.NODE)
RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_qual_id := nn;
| 1 =>
iter.n.as_type := nn;
END;
END Concrete_reveal_update;
PROCEDURE Concrete_reveal_next(iter: Concrete_reveal_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_qual_id;
| 1 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Concrete_reveal_next;
TYPE
Concrete_reveal_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Concrete_reveal;
OVERRIDES
next := Concrete_reveal_next;
update := Concrete_reveal_update;
END;
PROCEDURE Subtype_reveal_update(iter: Subtype_reveal_iter; nn: AST.NODE)
RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_qual_id := nn;
| 1 =>
iter.n.as_type := nn;
END;
END Subtype_reveal_update;
PROCEDURE Subtype_reveal_next(iter: Subtype_reveal_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_qual_id;
| 1 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Subtype_reveal_next;
TYPE
Subtype_reveal_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Subtype_reveal;
OVERRIDES
next := Subtype_reveal_next;
update := Subtype_reveal_update;
END;
PROCEDURE Concrete_decl_update(iter: Concrete_decl_iter; nn: AST.NODE)
RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_type := nn;
END;
END Concrete_decl_update;
PROCEDURE Concrete_decl_next(iter: Concrete_decl_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Concrete_decl_next;
TYPE
Concrete_decl_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Concrete_decl;
OVERRIDES
next := Concrete_decl_next;
update := Concrete_decl_update;
END;
PROCEDURE Subtype_decl_update(iter: Subtype_decl_iter; nn: AST.NODE) RAISES {
}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_type := nn;
END;
END Subtype_decl_update;
PROCEDURE Subtype_decl_next(iter: Subtype_decl_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Subtype_decl_next;
TYPE
Subtype_decl_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Subtype_decl;
OVERRIDES
next := Subtype_decl_next;
update := Subtype_decl_update;
END;
PROCEDURE Exc_decl_update(iter: Exc_decl_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_type := nn;
END;
END Exc_decl_update;
PROCEDURE Exc_decl_next(iter: Exc_decl_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_type;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Exc_decl_next;
TYPE
Exc_decl_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Exc_decl;
OVERRIDES
next := Exc_decl_next;
update := Exc_decl_update;
END;
PROCEDURE Var_decl_update(iter: Var_decl_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Var_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Var_id.Update(iter.n.as_id_s, iter.iter0, nn);
RETURN ;
END;
| 1 =>
iter.n.as_type := nn;
RETURN ;
| 2 =>
iter.n.as_default := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Var_decl_update;
PROCEDURE Var_decl_next(iter: Var_decl_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Var_id;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Var_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 1 =>
r := iter.n.as_type;
EXIT;
| 2 =>
r := iter.n.as_default;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Var_decl_next;
TYPE
Var_decl_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Var_decl;
iter0: SeqM3AST_AS_Var_id.Iter;
OVERRIDES
next := Var_decl_next;
update := Var_decl_update;
END;
PROCEDURE Const_decl_update(iter: Const_decl_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_type := nn;
| 2 =>
iter.n.as_exp := nn;
END;
END Const_decl_update;
PROCEDURE Const_decl_next(iter: Const_decl_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_type;
| 2 =>
r := iter.n.as_exp;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Const_decl_next;
TYPE
Const_decl_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Const_decl;
OVERRIDES
next := Const_decl_next;
update := Const_decl_update;
END;
PROCEDURE Proc_decl_update(iter: Proc_decl_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
| 1 =>
iter.n.as_type := nn;
| 2 =>
iter.n.as_body := nn;
END;
END Proc_decl_update;
PROCEDURE Proc_decl_next(iter: Proc_decl_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
| 1 =>
r := iter.n.as_type;
| 2 =>
r := iter.n.as_body;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Proc_decl_next;
TYPE
Proc_decl_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Proc_decl;
OVERRIDES
next := Proc_decl_next;
update := Proc_decl_update;
END;
PROCEDURE Exc_decl_s_update(iter: Exc_decl_s_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Exc_decl.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Exc_decl.Update(iter.n.as_exc_decl_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Exc_decl_s_update;
PROCEDURE Exc_decl_s_next(iter: Exc_decl_s_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Exc_decl;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Exc_decl.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Exc_decl_s_next;
TYPE
Exc_decl_s_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Exc_decl_s;
iter0: SeqM3AST_AS_Exc_decl.Iter;
OVERRIDES
next := Exc_decl_s_next;
update := Exc_decl_s_update;
END;
PROCEDURE Var_decl_s_update(iter: Var_decl_s_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Var_decl.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Var_decl.Update(iter.n.as_var_decl_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Var_decl_s_update;
PROCEDURE Var_decl_s_next(iter: Var_decl_s_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Var_decl;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Var_decl.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Var_decl_s_next;
TYPE
Var_decl_s_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Var_decl_s;
iter0: SeqM3AST_AS_Var_decl.Iter;
OVERRIDES
next := Var_decl_s_next;
update := Var_decl_s_update;
END;
PROCEDURE Type_decl_s_update(iter: Type_decl_s_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_TYPE_DECL.Exhausted(iter.iter0) THEN
SeqM3AST_AS_TYPE_DECL.Update(iter.n.as_type_decl_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Type_decl_s_update;
PROCEDURE Type_decl_s_next(iter: Type_decl_s_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.TYPE_DECL;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_TYPE_DECL.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Type_decl_s_next;
TYPE
Type_decl_s_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Type_decl_s;
iter0: SeqM3AST_AS_TYPE_DECL.Iter;
OVERRIDES
next := Type_decl_s_next;
update := Type_decl_s_update;
END;
PROCEDURE Const_decl_s_update(iter: Const_decl_s_iter; nn: AST.NODE) RAISES {
}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Const_decl.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Const_decl.Update(iter.n.as_const_decl_s, iter.iter0,nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Const_decl_s_update;
PROCEDURE Const_decl_s_next(iter: Const_decl_s_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Const_decl;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Const_decl.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Const_decl_s_next;
TYPE
Const_decl_s_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Const_decl_s;
iter0: SeqM3AST_AS_Const_decl.Iter;
OVERRIDES
next := Const_decl_s_next;
update := Const_decl_s_update;
END;
PROCEDURE Revelation_s_update(iter: Revelation_s_iter; nn: AST.NODE) RAISES {
}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_REVELATION.Exhausted(iter.iter0) THEN
SeqM3AST_AS_REVELATION.Update(iter.n.as_reveal_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Revelation_s_update;
PROCEDURE Revelation_s_next(iter: Revelation_s_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.REVELATION;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_REVELATION.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Revelation_s_next;
TYPE
Revelation_s_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Revelation_s;
iter0: SeqM3AST_AS_REVELATION.Iter;
OVERRIDES
next := Revelation_s_next;
update := Revelation_s_update;
END;
PROCEDURE From_import_update(iter: From_import_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_intf_id := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_Used_def_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Used_def_id.Update(iter.n.as_id_s, iter.iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END From_import_update;
PROCEDURE From_import_next(iter: From_import_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.Used_def_id;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_intf_id;
EXIT;
| 1 =>
IF SeqM3AST_AS_Used_def_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END From_import_next;
TYPE
From_import_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.From_import;
iter0: SeqM3AST_AS_Used_def_id.Iter;
OVERRIDES
next := From_import_next;
update := From_import_update;
END;
PROCEDURE Simple_import_update(iter: Simple_import_iter; nn: AST.NODE)
RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
IF NOT SeqM3AST_AS_Import_item.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Import_item.Update(iter.n.as_import_item_s, iter.
iter0, nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Simple_import_update;
PROCEDURE Simple_import_next(iter: Simple_import_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Import_item;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
IF SeqM3AST_AS_Import_item.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
END Simple_import_next;
TYPE
Simple_import_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Simple_import;
iter0: SeqM3AST_AS_Import_item.Iter;
OVERRIDES
next := Simple_import_next;
update := Simple_import_update;
END;
PROCEDURE Import_item_update(iter: Import_item_iter; nn: AST.NODE) RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_intf_id := nn;
| 1 =>
iter.n.as_id := nn;
END;
END Import_item_update;
PROCEDURE Import_item_next(iter: Import_item_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_intf_id;
| 1 =>
r := iter.n.as_id;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Import_item_next;
TYPE
Import_item_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Import_item;
OVERRIDES
next := Import_item_next;
update := Import_item_update;
END;
PROCEDURE Module_update(iter: Module_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_unsafe := nn;
RETURN ;
| 1 =>
iter.n.as_id := nn;
RETURN ;
| 2 =>
IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Used_interface_id.Update(iter.n.as_export_s, iter.
iter0, nn);
RETURN ;
END;
| 3 =>
IF NOT SeqM3AST_AS_IMPORTED.Exhausted(iter.iter1) THEN
SeqM3AST_AS_IMPORTED.Update(iter.n.as_import_s, iter.iter1, nn);
RETURN ;
END;
| 4 =>
iter.n.as_block := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Module_update;
PROCEDURE Module_next(iter: Module_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Used_interface_id;
node1: M3AST_AS.IMPORTED;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_unsafe;
EXIT;
| 1 =>
r := iter.n.as_id;
EXIT;
| 2 =>
IF SeqM3AST_AS_Used_interface_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 3 =>
IF SeqM3AST_AS_IMPORTED.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
| 4 =>
r := iter.n.as_block;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Module_next;
TYPE
Module_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Module;
iter0: SeqM3AST_AS_Used_interface_id.Iter;
iter1: SeqM3AST_AS_IMPORTED.Iter;
OVERRIDES
next := Module_next;
update := Module_update;
END;
PROCEDURE Interface_update(iter: Interface_iter; nn: AST.NODE) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_unsafe := nn;
RETURN ;
| 1 =>
iter.n.as_id := nn;
RETURN ;
| 2 =>
IF NOT SeqM3AST_AS_IMPORTED.Exhausted(iter.iter0) THEN
SeqM3AST_AS_IMPORTED.Update(iter.n.as_import_s, iter.iter0, nn);
RETURN ;
END;
| 3 =>
iter.n.as_block := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Interface_update;
PROCEDURE Interface_next(iter: Interface_iter; VAR r: AST.NODE): BOOLEAN
RAISES {}=
VAR
node0: M3AST_AS.IMPORTED;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_unsafe;
EXIT;
| 1 =>
r := iter.n.as_id;
EXIT;
| 2 =>
IF SeqM3AST_AS_IMPORTED.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 3 =>
r := iter.n.as_block;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Interface_next;
TYPE
Interface_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Interface;
iter0: SeqM3AST_AS_IMPORTED.Iter;
OVERRIDES
next := Interface_next;
update := Interface_update;
END;
PROCEDURE Module_gen_ins_update(iter: Module_gen_ins_iter; nn: AST.NODE)
RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_unsafe := nn;
RETURN ;
| 1 =>
iter.n.as_id := nn;
RETURN ;
| 2 =>
IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Used_interface_id.Update(iter.n.as_export_s, iter.
iter0, nn);
RETURN ;
END;
| 3 =>
iter.n.as_gen_id := nn;
RETURN ;
| 4 =>
IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(iter.iter1) THEN
SeqM3AST_AS_Used_interface_id.Update(iter.n.as_id_s, iter.iter1,
nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Module_gen_ins_update;
PROCEDURE Module_gen_ins_next(iter: Module_gen_ins_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Used_interface_id;
node1: M3AST_AS.Used_interface_id;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_unsafe;
EXIT;
| 1 =>
r := iter.n.as_id;
EXIT;
| 2 =>
IF SeqM3AST_AS_Used_interface_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 3 =>
r := iter.n.as_gen_id;
EXIT;
| 4 =>
IF SeqM3AST_AS_Used_interface_id.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Module_gen_ins_next;
TYPE
Module_gen_ins_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Module_gen_ins;
iter0: SeqM3AST_AS_Used_interface_id.Iter;
iter1: SeqM3AST_AS_Used_interface_id.Iter;
OVERRIDES
next := Module_gen_ins_next;
update := Module_gen_ins_update;
END;
PROCEDURE Interface_gen_ins_update(iter: Interface_gen_ins_iter; nn: AST.NODE
) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_unsafe := nn;
RETURN ;
| 1 =>
iter.n.as_id := nn;
RETURN ;
| 2 =>
iter.n.as_gen_id := nn;
RETURN ;
| 3 =>
IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_Used_interface_id.Update(iter.n.as_id_s, iter.iter0,
nn);
RETURN ;
END;
END;
INC(iter.slot);
END;
END Interface_gen_ins_update;
PROCEDURE Interface_gen_ins_next(iter: Interface_gen_ins_iter;
VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.Used_interface_id;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_unsafe;
EXIT;
| 1 =>
r := iter.n.as_id;
EXIT;
| 2 =>
r := iter.n.as_gen_id;
EXIT;
| 3 =>
IF SeqM3AST_AS_Used_interface_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Interface_gen_ins_next;
TYPE
Interface_gen_ins_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Interface_gen_ins;
iter0: SeqM3AST_AS_Used_interface_id.Iter;
OVERRIDES
next := Interface_gen_ins_next;
update := Interface_gen_ins_update;
END;
PROCEDURE Module_gen_def_update(iter: Module_gen_def_iter; nn: AST.NODE)
RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_F_Interface_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_F_Interface_id.Update(iter.n.as_id_s, iter.iter0, nn);
RETURN ;
END;
| 2 =>
IF NOT SeqM3AST_AS_IMPORTED.Exhausted(iter.iter1) THEN
SeqM3AST_AS_IMPORTED.Update(iter.n.as_import_s, iter.iter1, nn);
RETURN ;
END;
| 3 =>
iter.n.as_block := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Module_gen_def_update;
PROCEDURE Module_gen_def_next(iter: Module_gen_def_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.F_Interface_id;
node1: M3AST_AS.IMPORTED;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
EXIT;
| 1 =>
IF SeqM3AST_AS_F_Interface_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 2 =>
IF SeqM3AST_AS_IMPORTED.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
| 3 =>
r := iter.n.as_block;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Module_gen_def_next;
TYPE
Module_gen_def_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Module_gen_def;
iter0: SeqM3AST_AS_F_Interface_id.Iter;
iter1: SeqM3AST_AS_IMPORTED.Iter;
OVERRIDES
next := Module_gen_def_next;
update := Module_gen_def_update;
END;
PROCEDURE Interface_gen_def_update(iter: Interface_gen_def_iter; nn: AST.NODE
) RAISES {}=
BEGIN
LOOP
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_id := nn;
RETURN ;
| 1 =>
IF NOT SeqM3AST_AS_F_Interface_id.Exhausted(iter.iter0) THEN
SeqM3AST_AS_F_Interface_id.Update(iter.n.as_id_s, iter.iter0, nn);
RETURN ;
END;
| 2 =>
IF NOT SeqM3AST_AS_IMPORTED.Exhausted(iter.iter1) THEN
SeqM3AST_AS_IMPORTED.Update(iter.n.as_import_s, iter.iter1, nn);
RETURN ;
END;
| 3 =>
iter.n.as_block := nn;
RETURN ;
END;
INC(iter.slot);
END;
END Interface_gen_def_update;
PROCEDURE Interface_gen_def_next(iter: Interface_gen_def_iter;
VAR r: AST.NODE): BOOLEAN RAISES {}=
VAR
node0: M3AST_AS.F_Interface_id;
node1: M3AST_AS.IMPORTED;
BEGIN
LOOP
CASE iter.slot OF
| 0 =>
r := iter.n.as_id;
EXIT;
| 1 =>
IF SeqM3AST_AS_F_Interface_id.Next(iter.iter0, node0) THEN
r := node0;
RETURN TRUE;
END;
| 2 =>
IF SeqM3AST_AS_IMPORTED.Next(iter.iter1, node1) THEN
r := node1;
RETURN TRUE;
END;
| 3 =>
r := iter.n.as_block;
EXIT;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
END;
INC(iter.slot);
RETURN TRUE;
END Interface_gen_def_next;
TYPE
Interface_gen_def_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Interface_gen_def;
iter0: SeqM3AST_AS_F_Interface_id.Iter;
iter1: SeqM3AST_AS_IMPORTED.Iter;
OVERRIDES
next := Interface_gen_def_next;
update := Interface_gen_def_update;
END;
PROCEDURE Compilation_Unit_update(iter: Compilation_Unit_iter; nn: AST.NODE)
RAISES {}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_root := nn;
END;
END Compilation_Unit_update;
PROCEDURE Compilation_Unit_next(iter: Compilation_Unit_iter; VAR r: AST.NODE)
: BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_root;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Compilation_Unit_next;
TYPE
Compilation_Unit_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Compilation_Unit;
OVERRIDES
next := Compilation_Unit_next;
update := Compilation_Unit_update;
END;
PROCEDURE Qual_used_id_update(iter: Qual_used_id_iter; nn: AST.NODE) RAISES {
}=
BEGIN
CASE iter.slot OF <*NOWARN*>
| 0 =>
iter.n.as_intf_id := nn;
| 1 =>
iter.n.as_id := nn;
END;
END Qual_used_id_update;
PROCEDURE Qual_used_id_next(iter: Qual_used_id_iter; VAR r: AST.NODE):
BOOLEAN RAISES {}=
BEGIN
CASE iter.slot OF
| 0 =>
r := iter.n.as_intf_id;
| 1 =>
r := iter.n.as_id;
ELSE
RETURN FALSE;
END;
INC(iter.slot);
RETURN TRUE;
END Qual_used_id_next;
TYPE
Qual_used_id_iter = AST_Iter.T OBJECT
n: M3AST_AS_F.Qual_used_id;
OVERRIDES
next := Qual_used_id_next;
update := Qual_used_id_update;
END;
PROCEDURE Qual_used_id_newIter(n: M3AST_AS_F.Qual_used_id): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Qual_used_id_iter, n := n);
END Qual_used_id_newIter;
PROCEDURE Compilation_Unit_newIter(n: M3AST_AS_F.Compilation_Unit): AST_Iter.
T RAISES {}=
BEGIN
RETURN NEW(Compilation_Unit_iter, n := n);
END Compilation_Unit_newIter;
PROCEDURE Interface_gen_def_newIter(n: M3AST_AS_F.Interface_gen_def):
AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Interface_gen_def_iter, n := n, iter0 :=
SeqM3AST_AS_F_Interface_id.NewIter(n.as_id_s), iter1 :=
SeqM3AST_AS_IMPORTED.NewIter(n.as_import_s));
END Interface_gen_def_newIter;
PROCEDURE Module_gen_def_newIter(n: M3AST_AS_F.Module_gen_def): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Module_gen_def_iter, n := n, iter0 :=
SeqM3AST_AS_F_Interface_id.NewIter(n.as_id_s), iter1 :=
SeqM3AST_AS_IMPORTED.NewIter(n.as_import_s));
END Module_gen_def_newIter;
PROCEDURE Interface_gen_ins_newIter(n: M3AST_AS_F.Interface_gen_ins):
AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Interface_gen_ins_iter, n := n, iter0 :=
SeqM3AST_AS_Used_interface_id.NewIter(n.as_id_s));
END Interface_gen_ins_newIter;
PROCEDURE Module_gen_ins_newIter(n: M3AST_AS_F.Module_gen_ins): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Module_gen_ins_iter, n := n, iter0 :=
SeqM3AST_AS_Used_interface_id.NewIter(n.as_export_s), iter1 :=
SeqM3AST_AS_Used_interface_id.NewIter(n.as_id_s));
END Module_gen_ins_newIter;
PROCEDURE Interface_newIter(n: M3AST_AS_F.Interface): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Interface_iter, n := n, iter0 := SeqM3AST_AS_IMPORTED.NewIter(
n.as_import_s));
END Interface_newIter;
PROCEDURE Module_newIter(n: M3AST_AS_F.Module): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Module_iter, n := n, iter0 := SeqM3AST_AS_Used_interface_id.
NewIter(n.as_export_s), iter1 := SeqM3AST_AS_IMPORTED.NewIter(n.
as_import_s));
END Module_newIter;
PROCEDURE Import_item_newIter(n: M3AST_AS_F.Import_item): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Import_item_iter, n := n);
END Import_item_newIter;
PROCEDURE Simple_import_newIter(n: M3AST_AS_F.Simple_import): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Simple_import_iter, n := n, iter0 := SeqM3AST_AS_Import_item.
NewIter(n.as_import_item_s));
END Simple_import_newIter;
PROCEDURE From_import_newIter(n: M3AST_AS_F.From_import): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(From_import_iter, n := n, iter0 := SeqM3AST_AS_Used_def_id.
NewIter(n.as_id_s));
END From_import_newIter;
PROCEDURE Revelation_s_newIter(n: M3AST_AS_F.Revelation_s): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Revelation_s_iter, n := n, iter0 := SeqM3AST_AS_REVELATION.
NewIter(n.as_reveal_s));
END Revelation_s_newIter;
PROCEDURE Const_decl_s_newIter(n: M3AST_AS_F.Const_decl_s): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Const_decl_s_iter, n := n, iter0 := SeqM3AST_AS_Const_decl.
NewIter(n.as_const_decl_s));
END Const_decl_s_newIter;
PROCEDURE Type_decl_s_newIter(n: M3AST_AS_F.Type_decl_s): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Type_decl_s_iter, n := n, iter0 := SeqM3AST_AS_TYPE_DECL.
NewIter(n.as_type_decl_s));
END Type_decl_s_newIter;
PROCEDURE Var_decl_s_newIter(n: M3AST_AS_F.Var_decl_s): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Var_decl_s_iter, n := n, iter0 := SeqM3AST_AS_Var_decl.NewIter
(n.as_var_decl_s));
END Var_decl_s_newIter;
PROCEDURE Exc_decl_s_newIter(n: M3AST_AS_F.Exc_decl_s): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Exc_decl_s_iter, n := n, iter0 := SeqM3AST_AS_Exc_decl.NewIter
(n.as_exc_decl_s));
END Exc_decl_s_newIter;
PROCEDURE Proc_decl_newIter(n: M3AST_AS_F.Proc_decl): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Proc_decl_iter, n := n);
END Proc_decl_newIter;
PROCEDURE Const_decl_newIter(n: M3AST_AS_F.Const_decl): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Const_decl_iter, n := n);
END Const_decl_newIter;
PROCEDURE Var_decl_newIter(n: M3AST_AS_F.Var_decl): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Var_decl_iter, n := n, iter0 := SeqM3AST_AS_Var_id.NewIter(n.
as_id_s));
END Var_decl_newIter;
PROCEDURE Exc_decl_newIter(n: M3AST_AS_F.Exc_decl): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Exc_decl_iter, n := n);
END Exc_decl_newIter;
PROCEDURE Subtype_decl_newIter(n: M3AST_AS_F.Subtype_decl): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Subtype_decl_iter, n := n);
END Subtype_decl_newIter;
PROCEDURE Concrete_decl_newIter(n: M3AST_AS_F.Concrete_decl): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Concrete_decl_iter, n := n);
END Concrete_decl_newIter;
PROCEDURE Subtype_reveal_newIter(n: M3AST_AS_F.Subtype_reveal): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Subtype_reveal_iter, n := n);
END Subtype_reveal_newIter;
PROCEDURE Concrete_reveal_newIter(n: M3AST_AS_F.Concrete_reveal): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Concrete_reveal_iter, n := n);
END Concrete_reveal_newIter;
PROCEDURE Named_type_newIter(n: M3AST_AS_F.Named_type): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Named_type_iter, n := n);
END Named_type_newIter;
PROCEDURE Root_type_newIter(n: M3AST_AS_F.Root_type): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Root_type_iter, n := n);
END Root_type_newIter;
PROCEDURE Enumeration_type_newIter(n: M3AST_AS_F.Enumeration_type): AST_Iter.
T RAISES {}=
BEGIN
RETURN NEW(Enumeration_type_iter, n := n, iter0 := SeqM3AST_AS_Enum_id.
NewIter(n.as_id_s));
END Enumeration_type_newIter;
PROCEDURE Subrange_type_newIter(n: M3AST_AS_F.Subrange_type): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Subrange_type_iter, n := n);
END Subrange_type_newIter;
PROCEDURE Array_type_newIter(n: M3AST_AS_F.Array_type): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Array_type_iter, n := n, iter0 := SeqM3AST_AS_M3TYPE.NewIter(n
.as_indextype_s));
END Array_type_newIter;
PROCEDURE Record_type_newIter(n: M3AST_AS_F.Record_type): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Record_type_iter, n := n, iter0 := SeqM3AST_AS_Fields.NewIter(
n.as_fields_s));
END Record_type_newIter;
PROCEDURE Object_type_newIter(n: M3AST_AS_F.Object_type): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Object_type_iter, n := n, iter0 := SeqM3AST_AS_Fields.NewIter(
n.as_fields_s), iter1 := SeqM3AST_AS_Method.NewIter(n.as_method_s));
END Object_type_newIter;
PROCEDURE Set_type_newIter(n: M3AST_AS_F.Set_type): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Set_type_iter, n := n);
END Set_type_newIter;
PROCEDURE Procedure_type_newIter(n: M3AST_AS_F.Procedure_type): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Procedure_type_iter, n := n, iter0 := SeqM3AST_AS_Formal_param
.NewIter(n.as_formal_param_s));
END Procedure_type_newIter;
PROCEDURE Ref_type_newIter(n: M3AST_AS_F.Ref_type): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Ref_type_iter, n := n);
END Ref_type_newIter;
PROCEDURE Packed_type_newIter(n: M3AST_AS_F.Packed_type): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Packed_type_iter, n := n);
END Packed_type_newIter;
PROCEDURE Opaque_type_newIter(n: M3AST_AS_F.Opaque_type): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Opaque_type_iter, n := n);
END Opaque_type_newIter;
PROCEDURE Brand_newIter(n: M3AST_AS_F.Brand): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Brand_iter, n := n);
END Brand_newIter;
PROCEDURE Fields_newIter(n: M3AST_AS_F.Fields): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Fields_iter, n := n, iter0 := SeqM3AST_AS_Field_id.NewIter(n.
as_id_s));
END Fields_newIter;
PROCEDURE Method_newIter(n: M3AST_AS_F.Method): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Method_iter, n := n);
END Method_newIter;
PROCEDURE Override_newIter(n: M3AST_AS_F.Override): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Override_iter, n := n);
END Override_newIter;
PROCEDURE Formal_param_newIter(n: M3AST_AS_F.Formal_param): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Formal_param_iter, n := n, iter0 := SeqM3AST_AS_FORMAL_ID.
NewIter(n.as_id_s));
END Formal_param_newIter;
PROCEDURE Raisees_some_newIter(n: M3AST_AS_F.Raisees_some): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(Raisees_some_iter, n := n, iter0 := SeqM3AST_AS_Qual_used_id.
NewIter(n.as_raisees_s));
END Raisees_some_newIter;
PROCEDURE Range_EXP_newIter(n: M3AST_AS_F.Range_EXP): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Range_EXP_iter, n := n);
END Range_EXP_newIter;
PROCEDURE Range_newIter(n: M3AST_AS_F.Range): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Range_iter, n := n);
END Range_newIter;
PROCEDURE Constructor_newIter(n: M3AST_AS_F.Constructor): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Constructor_iter, n := n, iter0 := SeqM3AST_AS_CONS_ELEM.
NewIter(n.as_element_s));
END Constructor_newIter;
PROCEDURE RANGE_EXP_elem_newIter(n: M3AST_AS_F.RANGE_EXP_elem): AST_Iter.T
RAISES {}=
BEGIN
RETURN NEW(RANGE_EXP_elem_iter, n := n);
END RANGE_EXP_elem_newIter;
PROCEDURE Actual_elem_newIter(n: M3AST_AS_F.Actual_elem): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Actual_elem_iter, n := n);
END Actual_elem_newIter;
PROCEDURE Propagate_newIter(n: M3AST_AS_F.Propagate): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Propagate_iter, n := n);
END Propagate_newIter;
PROCEDURE BINARY_newIter(n: M3AST_AS_F.BINARY): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(BINARY_iter, n := n);
END BINARY_newIter;
PROCEDURE UNARY_newIter(n: M3AST_AS_F.UNARY): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(UNARY_iter, n := n);
END UNARY_newIter;
PROCEDURE Select_newIter(n: M3AST_AS_F.Select): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Select_iter, n := n);
END Select_newIter;
PROCEDURE Call_newIter(n: M3AST_AS_F.Call): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Call_iter, n := n, iter0 := SeqM3AST_AS_Actual.NewIter(n.
as_param_s));
END Call_newIter;
PROCEDURE Index_newIter(n: M3AST_AS_F.Index): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Index_iter, n := n, iter0 := SeqM3AST_AS_EXP.NewIter(n.
as_exp_s));
END Index_newIter;
PROCEDURE Actual_newIter(n: M3AST_AS_F.Actual): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Actual_iter, n := n);
END Actual_newIter;
PROCEDURE Assign_st_newIter(n: M3AST_AS_F.Assign_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Assign_st_iter, n := n);
END Assign_st_newIter;
PROCEDURE Call_st_newIter(n: M3AST_AS_F.Call_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Call_st_iter, n := n);
END Call_st_newIter;
PROCEDURE Case_st_newIter(n: M3AST_AS_F.Case_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Case_st_iter, n := n, iter0 := SeqM3AST_AS_Case.NewIter(n.
as_case_s));
END Case_st_newIter;
PROCEDURE Eval_st_newIter(n: M3AST_AS_F.Eval_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Eval_st_iter, n := n);
END Eval_st_newIter;
PROCEDURE Exit_st_newIter(n: M3AST_AS_F.Exit_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Exit_st_iter, n := n);
END Exit_st_newIter;
PROCEDURE For_st_newIter(n: M3AST_AS_F.For_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(For_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END For_st_newIter;
PROCEDURE If_st_newIter(n: M3AST_AS_F.If_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(If_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s), iter1 := SeqM3AST_AS_Elsif.NewIter(n.as_elsif_s));
END If_st_newIter;
PROCEDURE Lock_st_newIter(n: M3AST_AS_F.Lock_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Lock_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END Lock_st_newIter;
PROCEDURE Loop_st_newIter(n: M3AST_AS_F.Loop_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Loop_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END Loop_st_newIter;
PROCEDURE Raise_st_newIter(n: M3AST_AS_F.Raise_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Raise_st_iter, n := n);
END Raise_st_newIter;
PROCEDURE Repeat_st_newIter(n: M3AST_AS_F.Repeat_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Repeat_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END Repeat_st_newIter;
PROCEDURE Return_st_newIter(n: M3AST_AS_F.Return_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Return_st_iter, n := n);
END Return_st_newIter;
PROCEDURE Try_st_newIter(n: M3AST_AS_F.Try_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Try_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END Try_st_newIter;
PROCEDURE Typecase_st_newIter(n: M3AST_AS_F.Typecase_st): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Typecase_st_iter, n := n, iter0 := SeqM3AST_AS_Tcase.NewIter(n
.as_tcase_s));
END Typecase_st_newIter;
PROCEDURE While_st_newIter(n: M3AST_AS_F.While_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(While_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END While_st_newIter;
PROCEDURE With_st_newIter(n: M3AST_AS_F.With_st): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(With_st_iter, n := n, iter0 := SeqM3AST_AS_Binding.NewIter(n.
as_binding_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
END With_st_newIter;
PROCEDURE Block_newIter(n: M3AST_AS_F.Block): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Block_iter, n := n, iter0 := SeqM3AST_AS_DECL_REVL.NewIter(n.
as_decl_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
END Block_newIter;
PROCEDURE Case_newIter(n: M3AST_AS_F.Case): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Case_iter, n := n, iter0 := SeqM3AST_AS_RANGE_EXP.NewIter(n.
as_case_label_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
END Case_newIter;
PROCEDURE Else_stm_newIter(n: M3AST_AS_F.Else_stm): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Else_stm_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END Else_stm_newIter;
PROCEDURE Elsif_newIter(n: M3AST_AS_F.Elsif): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Elsif_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END Elsif_newIter;
PROCEDURE Try_except_newIter(n: M3AST_AS_F.Try_except): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Try_except_iter, n := n, iter0 := SeqM3AST_AS_Handler.NewIter(
n.as_handler_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
END Try_except_newIter;
PROCEDURE Try_finally_newIter(n: M3AST_AS_F.Try_finally): AST_Iter.T RAISES {
}=
BEGIN
RETURN NEW(Try_finally_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
as_stm_s));
END Try_finally_newIter;
PROCEDURE Tcase_newIter(n: M3AST_AS_F.Tcase): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Tcase_iter, n := n, iter0 := SeqM3AST_AS_M3TYPE.NewIter(n.
as_type_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
END Tcase_newIter;
PROCEDURE Handler_newIter(n: M3AST_AS_F.Handler): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Handler_iter, n := n, iter0 := SeqM3AST_AS_Qual_used_id.
NewIter(n.as_qual_id_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s)
);
END Handler_newIter;
PROCEDURE Binding_newIter(n: M3AST_AS_F.Binding): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(Binding_iter, n := n);
END Binding_newIter;
PROCEDURE By_newIter(n: M3AST_AS_F.By): AST_Iter.T RAISES {}=
BEGIN
RETURN NEW(By_iter, n := n);
END By_newIter;
BEGIN
END M3AST_AS_Iter.