INTERFACE************************************************************************* Copyright (C) Olivetti 1989 All Rights reserved Use and copy of this software and preparation of derivative works based upon this software are permitted to any person, provided this same copyright notice and the following Olivetti warranty disclaimer are included in any copy of the software or any modification thereof or derivative work therefrom made by any person. This software is made available AS IS and Olivetti disclaims all warranties with respect to this software, whether expressed or implied under any law, including all implied warranties of merchantibility and fitness for any purpose. In no event shall Olivetti be liable for any damages whatsoever resulting from loss of use, data or profits or otherwise arising out of or in connection with the use or performance of this software. *************************************************************************M3ASTNext ;
IMPORT M3AST_LX, M3AST_AS, M3AST_SM; IMPORT SeqM3AST_AS_Var_decl, SeqM3AST_AS_Fields, SeqM3AST_AS_Formal_param, SeqM3AST_AS_Case, SeqM3AST_AS_Handler, SeqM3AST_AS_Tcase, SeqM3AST_AS_IMPORTED;------------------------------- FLATTENING COMPLEX ITERATIONS -------------------------------
A series of iterators for flattening nasty M3 AST iterations e.g. the 'Var' iterator just iterates all the 'Var_id's in a 'seqVar_decl', so the user doesn't have to iterate the 'Var_decl's then the 'Var_id's for each decl. They are all used in a similar manner; here is an example using the 'Var' iterator.
VAR iter := M3ASTNext.IterVar(seqVar_decl); BEGIN WHILE M3ASTNext.Var(iter, varId) DO ..your code.. END;
TYPE IterVar <: REFANY; PROCEDURE NewIterVar(seqVar_decl: SeqM3AST_AS_Var_decl.T): IterVar RAISES {}; PROCEDURE Var( VAR (* INOUT *) iter: IterVar; VAR (* OUT *) var_id: M3AST_AS.Var_id) : BOOLEAN RAISES {}; TYPE IterField <: REFANY; PROCEDURE NewIterField(seqFields: SeqM3AST_AS_Fields.T): IterField RAISES {}; PROCEDURE Field( VAR (* INOUT *) iter: IterField; VAR (* OUT *) field_id: M3AST_AS.Field_id) : BOOLEAN RAISES {}; TYPE IterFormal <: REFANY; PROCEDURE NewIterFormal( seqFormal_param: SeqM3AST_AS_Formal_param.T) : IterFormal RAISES {}; PROCEDURE Formal( VAR (* INOUT *) iter: IterFormal; VAR (* OUT *) formal_param: M3AST_AS.Formal_param; VAR (* OUT *) formal_id: M3AST_AS.FORMAL_ID) : BOOLEAN RAISES {}; TYPE IterCaseLabel <: REFANY; PROCEDURE NewIterCaseLabel( seqCase: SeqM3AST_AS_Case.T) : IterCaseLabel RAISES {}; PROCEDURE CaseLabel( VAR (* INOUT *) iter: IterCaseLabel; VAR (* OUT *) m3_case: M3AST_AS.Case; VAR (* OUT *) label: M3AST_AS.RANGE_EXP) : BOOLEAN RAISES {}; TYPE IterHandlerLabel <: REFANY; PROCEDURE NewIterHandlerLabel( seqHandler: SeqM3AST_AS_Handler.T) : IterHandlerLabel RAISES {}; PROCEDURE HandlerLabel( VAR (* INOUT *) iter: IterHandlerLabel; VAR (* OUT *) handler: M3AST_AS.Handler; VAR (* OUT *) label: M3AST_AS.Qual_used_id) : BOOLEAN RAISES {}; TYPE IterTypeCaseLabel <: REFANY; PROCEDURE NewIterTypeCaseLabel( seqTcase: SeqM3AST_AS_Tcase.T) : IterTypeCaseLabel RAISES {}; PROCEDURE TypeCaseLabel( VAR (* INOUT *) iter: IterTypeCaseLabel; VAR (* OUT *) tcase: M3AST_AS.Tcase; VAR (* OUT *) label: M3AST_AS.M3TYPE) : BOOLEAN RAISES {}; TYPE IterImportedId <: REFANY; PROCEDURE NewIterImportedId(i: SeqM3AST_AS_IMPORTED.T): IterImportedId RAISES {}; PROCEDURE ImportedId( VAR (*inout*) iter: IterImportedId; VAR (*out*) used_intf_id: M3AST_AS.Used_interface_id) : BOOLEAN RAISES {};
Returns the sequence of imported interface ids in the order they appear in the AST.
-------------- OBJECT TYPES --------------
A series of iterators for object types. They provide ways of finding the supertype and iterating fields and methods
PROCEDURE SimpleSuperType( type: M3AST_AS.Object_type; VAR (* OUT *) superType: M3AST_SM.TYPE_SPEC_UNSET) : BOOLEAN RAISES {};
If 'type' has no supertype (other than ones common to all object types) returns FALSE and leaves 'superType' unchanged. Otherwise returns TRUE. If the supertype is unresolved (e.g. an undeclared name) or recursive sets 'superType' to unset otherwise sets 'superType' to the supertype, even if it is unsuitable i.e. not an object or opaque type. This routine assumes that names (in particular the name of the supertype of 'type', if any!) are resolved.
PROCEDURE SuperType( type: M3AST_AS.Object_type; VAR (* OUT *) superType: M3AST_AS.Object_type) : BOOLEAN RAISES {};
This routine is intended for use when iterating fields and methods. If 'type' has a supertype (other than the ones common to all object types e.g. REFANY) this supertype can validly be either an opaque type which is revealed to be an object type or a simple object type. If 'type' has an opaque supertype which is revealed to be an object type and that object type is not the root object type (i.e. OBJANY) TRUE is returned and 'superType' is set to be the revealed object type. If 'type' has a supertype which is a simple object type TRUE is returned and 'superType' is set to be that object type. Otherwise FALSE is returned and 'superType' is not altered. This routine assumes that names (in particular the name of the supertype of 'type', if any!) are resolved. It also uses 'M3CConcTypeSpec.CurrentReveal' to find the current revelation for an opaque supertype
TYPE IterObjectField <: REFANY; PROCEDURE NewIterObjectField( o: M3AST_AS.Object_type) : IterObjectField RAISES {}; PROCEDURE ObjectField( VAR (* INOUT *) iter: IterObjectField; VAR (* OUT *) field_id: M3AST_AS.Field_id) : BOOLEAN RAISES {};
Starts with the root super-type and goes through the current type iterating each type's fields.
TYPE IterObjectMethod <: REFANY; PROCEDURE NewIterObjectMethod( o: M3AST_AS.Object_type) : IterObjectMethod RAISES {}; PROCEDURE ObjectMethod( VAR (* INOUT *) iter: IterObjectMethod; VAR (* OUT *) method: M3AST_AS.METHOD_OVERRIDE; VAR (* OUT *) overrides: BOOLEAN) : BOOLEAN RAISES {};
Starts with the root super-type and goes through the current type iterating
each the type's methods. Overrides is true if the method only overrides a
super-type's method procedure. This is a convenience for backward
compatibility, since overrides = ISTYPE(method, M3AST_AS.Override)
TYPE IterFieldOrMethod <: REFANY; PROCEDURE NewIterFieldOrMethod( o: M3AST_AS.Object_type) : IterFieldOrMethod RAISES {}; PROCEDURE FieldOrMethod( VAR iter: IterFieldOrMethod; VAR field: M3AST_AS.Field_id; VAR method: M3AST_AS.Method; VAR symrep: M3AST_LX.Symbol_rep) : BOOLEAN RAISES {};
Iterator for the fields and methods in an object. The iteration order is fields then methods at the current level then, if the object type has any supertypes, fields then methods of the supertype and so on. If 'FieldOrMethod' succeeds in finding another field or method it returns TRUE and sets 'symrep' to be the name of the field or method. If a field was found 'field' is set appropriately and 'method' is set to NIL otherwise 'method' is set and 'field' is set to NIL. The iteration skips any method overrides. If there are no more fields or methods FALSE is returned. The iteration uses the 'SuperType' procedure; hence names must be resolved and the current revelation of any opaque super type must be available. So a typical iteration might be: IDL.InitSEQIterator(iter); WHILE M3ASTNext.FieldOrMethod(o, iter, field, method, symrep) DO .. whatever .. END; (* while
; *)------------- ARRAY TYPES -------------
An iterator for multi dimensional arrays
PROCEDURE Array( array: M3AST_AS.Array_type; VAR (* OUT *) elementType: M3AST_SM.TYPE_SPEC_UNSET; VAR (* OUT *) openArray: BOOLEAN; VAR (* OUT *) indexType: M3AST_SM.TYPE_SPEC_UNSET) : BOOLEAN (* elementtype is an array i.e. array is multi-dimensional *) RAISES {};
A bit of a mess, but useful. Take an array and return it element and index types. If the array is open, then there is no indexType. Return TRUE if the elements of the array are arrays. This requires sm_norm_type to have been computed.Loop would look like:
array := ... LOOP multiDim := M3ASTNext.Array(array, elementType, openArray, indexType); ... IF NOT multiDim THEN EXIT END; END;
END M3ASTNext.