// demdraw.cd  -- CD for Apstudio
// Authors - Kedar & Binoy
// modified: Binoy : 1998/03/12
//*****************************************************************************
//
package EDU.neu.ccs.demeter.tools.apstudio.graphedit;

import java.awt.*;
import java.io.*;                       
import java.util.*;
import EDU.neu.ccs.demeter.*;
import EDU.neu.ccs.demeter.common.tg.*;
 

// Topmost class in class structure is Graph

UGraph 		= 	"#Class" "#Dictionary" "#Graph" *l
			[ <pkg> Package *l]		
			[ <imports> SList(Import) *l ]
			[ <preamble> JavaCode *l]	//deprecated
			[< vertices >UVertex_List] 
			<idToVertexTable> Hashtable	//vert list <-> hash
			[< edges > UEdge_List] 
			<idToEdgeTable> Hashtable	//edge list <-> hash
			<nameToIdVertexTable> Hashtable
			[<firstuid>UID] *EOF*. 
/**
TODO:
1. Rethink Package handling. Since new demjava 0.5.6 can have more than one package statement!
2. Same for global & local imports.
3. Remove support for preamble
*/
// Following is description of class Vertex_List and its parts

UVertex_List 	~	"#Vertex" "#List" *l + UVertex  {*l UVertex } *l- .

UVertex 	:  	UConstOrAltVertex | UTerm | UInterface
        		*common*
				< vid > UID
				< vertexname > UVertexName
				< position > Coordinates
				[< incoming > IEdge_List]	//incoming uids
				[< outgoing > OEdge_List]	//outgoing uids
				<inArcIdList>Vector 
				<outArcIdList>Vector 
				[<vdeco>Decorator]		//subgraph tag
				<tgv>TGVertex
				< persp > Perspective
				*extends* NetPrimitive .

UConstOrAltVertex : UConstVertex | UAltVertex
				*common*
				<parse> ParseOrNot
				<outEdgeNameList> Vector
				[<keywords> ScopeIdentifier_List].
				

ParseOrNot : YaParse | NopParse.
YaParse = "#parse".
NopParse = "#noparse".

UTerm		: UTermConstVertex | UTermInterface.

IEdge_List 	~ 	"#Incoming" UID { "," UID }.	//commalist uid {","uid}
OEdge_List 	~ 	"#Outgoing" UID { "," UID }.	//commalist uid {","uid}

UConstVertex 	=	"#ConstVertex" [< beFore > UBefore][< afTer > UAfter].
UBefore      	=	"#Before" <syntax>String.
UAfter       	=	"#After" <syntax>String.
UAltVertex 		=  	"#AltVertex" .

UInterface		= "#Interface" [<keywords> InterfaceModifier_List] JavaCode.
InterfaceModifier_List ~ InterfaceModifier { InterfaceModifier }.
InterfaceModifier : PublicModifier.
PublicModifier = "#public".

UTermConstVertex	= "#TermConstVertex" .
UTermInterface = "#TermInterface" .


ScopeIdentifier_List	~ ScopeIdentifier { ScopeIdentifier }.
ScopeIdentifier : PublicIdentifier | FinalIdentifier .
PublicIdentifier = "#public".
FinalIdentifier	 = "#final".

// Following is description of class Edge_List and its parts

UEdge_List 	~ 	"#Edge" "#List" *l + UEdge  {*l UEdge } *l -.

UEdge 		: 	 USuperEdge | UConstEdge
	        	*common*
	  			< eid >UID
  				< fromVertex > UID 
  				< toVertex > UID
				[<edeco>Decorator]		//subgraph tag
				[<bendpoint> BendPoint]//_List ]
   				<persp> ArcPerspective
				*extends* NetPrimitive. 
//BendPoint_List ~ BendPoint{BendPoint}.
USuperEdge : UAltEdge | UExtendEdge | UImplEdge .

BendPoint	=	<position> Coordinates.

UAltEdge 	= 	"#AltEdge" <tge>TGAEdge.
UExtendEdge	=	"#ExtendEdge" <tge>TGAEdge.
UImplEdge	=	"#ImplEdge" <tge>TGIEdge.

UConstEdge 	= 	"#ConstEdge" [< edgename > UEdgeName] 
				<card> Cardinality
				[<beFore>UBefore][<afTer>UAfter]
				[<keywords> PartModifier_List]
				<tge>TGCEdge.
PartModifier_List ~ PartModifier { PartModifier }.

PartModifier	: FinalMod | StaticMod | ReadOnlyMod | PrivateMod .
FinalMod		= "#final".
StaticMod		= "#static".
ReadOnlyMod		= "#read-only".
PrivateMod		= "#private".

Cardinality 	= 	"#Cardinality" < lower > Lower [ < upper > Upper].
Lower		=	<l>Integer.
Upper		=	"." "." <u>String.


// Classes common to Vertex and Edge

UID 		= 	< id > Integer.
UEdgeName 	=  	<name> Ident *implements* PartNameI.
UVertexName	=  	<name> Ident *implements* ClassNameI.

// Classes common to Vertex , VertexName ,  Edge and EdgeName

Coordinates =	"{" <x> X <y> Y "}".
X		=		<x>Integer .
Y		=		<y>Integer .

//Decorator to store the attribute(color?) of vertices and edges
Decorator	=	"travstat"<travtag>Integer  <travtaglist>Vector.//PList(Attributes)
//Attributes	= 	Integer.

//IndependantTraversal= 	"from"<sourceid> List(SUID)  <sourceids>Vector
//				TOCLASS  
//				<destid>List(DUID)  <destids>Vector
//				["bypassing"<bypassings> List(UID) ]
//				<bypassingList> Vector.
//SUID	=	UID.
//DUID	=	UID.
//TOCLASS :	ToV | ToStopV.
///ToV	=	"to".
//ToStopV	=	"tostop".

UniqueIDGenerator=  	.

// demjava.cd -- class dictionary for Demeter/Java
// $Id: demjava.cd,v 1.54 1998/03/01 12:05:35 dougo Exp $


Program			= GlobalImports <cg> ClassGraph *EOF* .
GlobalImports		= [ <imports> SList(Import) *l ] .

Import			= "import" PackageName [ ImportAllClasses ] ";".
ImportAllClasses	= ".*".

ClassGraph		= <defdict> Hashtable
			  <classes> DList(ClassGraphEntry)
			  [ "tg:" <tg> TraversalGraph ] .

ClassGraphEntry		: Directive | Definition.

Directive		: ParseDirective | VisitorDirective | PackageDirective.
ParseDirective		= ParseKeyword.
VisitorDirective	= VisitorKeyword.
PackageDirective	= <pkg> Package *l LocalImports.
Package			= "package" PackageName ";".
LocalImports		= [ <imports> SList(Import) *l ] .

Definition		: ClassDef.

ClassDef		= <keywords> List(ClassKeyword)
			  ParamClassName [ *s ParseDirective ]
			  *s ClassParts [ ClassMethods ]
			  [ *s EOFtoken ] "." .

ParamClassName		= ClassName ["(" <parameters> Commalist(ClassName) ")"].

ClassParts		: ConstOrAltClass | RepetitionClass.

ConstOrAltClass		: ConstructionClass | AlternationClass
			*common* + + +
				<parts> List(PartOrSyntax)
				<parents> ClassParents
				 - - -.

PartOrSyntax		: Part | OptionalPart | Syntax.

Part			= [ "<" PartName ">" *s ]
			  <keywords> List(PartKeyword)
			  ClassSpec [ PartInit ].
PartInit		= PartInitKeyword *s JavaCode.

OptionalPart		= "[" [LocalLookahead] <part> Sandwich(Part) "]".

ClassParents		= [ Superclasses ] [ Interfaces ].
Superclasses		= ExtendsKeyword <superclasses> Commalist(Superclass).
Superclass		= ClassSpec.
Interfaces		= ImplementsKeyword <interfaces> Commalist(Interface).
Interface		= ClassSpec.

ConstructionClass	= "=".

AlternationClass	= ":" + + + [ *lookahead* (@ _Subclass() @)
				      <subclasses> Barlist(Subclass) ] - - -
			[ CommonKeyword ].

Subclass		= [LocalLookahead] ClassSpec.

LocalLookahead		= LookaheadKeyword JavaCode.

RepetitionClass		= "~" <sandwiched> Sandwich(RepeatedPart).

RepeatedPart		= [ <nonempty> ClassSpec ]
			"{" [LocalLookahead] <repeated> Sandwich(ClassSpec)
			*s "}".

Sandwich(S)		= <first> List(Syntax) *s <inner> S <second> List(Syntax) .

ClassSpec		= ClassName
			["(" <actual_parameters> Commalist(ClassSpec) ")" ]
			.

Syntax			: PlainSyntax | PrintCommand.

PlainSyntax		= <string> String.

PrintCommand		: PrintIndent | PrintUnindent | PrintSkip | PrintSpace.
PrintIndent		= "+" .
PrintUnindent		= "-" .
PrintSkip		= "*l" .
PrintSpace		= "*s" .

EOFtoken		= "*EOF*".

//////////////////////
// Behavior (methods).
//////////////////////
ProgramBehavior		= [ <behavior> DList(Behavior) ] *EOF* .

Behavior		: StrategyDefinition | ClassBehavior.

StrategyDefinition	= "strategy" StrategyName "="
			  <exp> StrategyExpression ".".

StrategyExpression	: StrategyGraph | PathDirective | StrategyVariable
			| CompoundStrategy.

StrategyGraph		= "{" *l + [ "vec:" *s <edgeVec> Vector ]
				   <edges> SList(SGEdge) - *l "}" *s
			  [ "source:" <sources> ClassGlobSpec ]
			  [ "source-edge:" <sourceEdges> NList(Integer) ]
			  [ "target:" <targets> ClassGlobSpec ]
			*implements* StrategyGraphI
			.
SGEdge			= <source> ClassGlobSpec *s "->" *s
			  <dest> ClassGlobSpec
			  [ <constraint> NegativeConstraint ].

PathDirective		= [ <constraint> NegativeConstraint ]
			  <segments> List(PathSegment)
			  TargetDirective.

PathSegment		= <node> PositiveConstraint
			  [ <constraint> NegativeConstraint ].

Constraint		: PositiveConstraint | NegativeConstraint
			*common* <glob> GlobSpec.
PositiveConstraint	: Through | Via.	// synonyms
Through			= "through".
Via			= "via".
NegativeConstraint	: Bypassing | OnlyThrough.
Bypassing		= "bypassing".
OnlyThrough		= "only-through".

TargetDirective		: To | ToStop *common* <targets> ClassGlobSpec.
To			= "to".
ToStop			= "to-stop".

StrategyVariable	= "do" StrategyName.

CompoundStrategy	: Join | Merge | Intersect
			  *common* "(" <args> Commalist(StrategyExpression) ")".
Join			= "join".
Merge			= "merge".
Intersect		= "intersect".

GlobSpec		: OneGlob | GlobSet.
OneGlob			= Glob.
GlobSet			= "{" *s [ <globs> Commalist(Glob) *s ] "}".

Glob			: ClassGlob | EdgeGlob.
EdgeGlob		: PartGlob | SubclassGlob | SuperclassGlob.

ClassGlob		= <name> ClassNameGlob.
PartGlob		= "->" *s <source> SourceGlob "," *s
				  <name> PartNameGlob "," *s
			          <dest> DestGlob.
SubclassGlob		= "=>" *s <source> SourceGlob "," *s <dest> DestGlob.
SuperclassGlob		= ":>" *s <source> SourceGlob "," *s <dest> DestGlob.

SourceGlob		= <name> ClassNameGlob.
DestGlob		= <name> ClassNameGlob.

ClassNameGlob		: ClassNameExact | AnyClass.
ClassNameExact		= ClassName.
AnyClass		= "*".

PartNameGlob		: PartNameExact | AnyPart.
PartNameExact		= PartName.
AnyPart			= "*".

ClassGlobSpec		: OneClassGlob | ClassGlobSet.
OneClassGlob		= ClassGlob.
ClassGlobSet		= "{" *s <globs> Commalist(ClassGlob) *s "}".

ClassBehavior		= <classes> ClassGlobSpec <methods> ClassMethods.

ClassMethods		= "{" *l + [ <methods> SList(Method) ] - *l "}"
			  [ "wrappers:" <wrapperdict> Hashtable
			    // maps Wrapper-kind -> HostSet
			  ] .

HostSet			=
	[ "exact:" <exactHosts> Hashtable ] // globs with no stars
	[ "partnames:" <partnames> Hashtable ] // -> *,name,* globs
	[ "globs:" <globs> GlobSet] . // other globs

Method			: TraversalDef | MethodDef | Wrapper | Accessor
			| Constructor | Start | Finish | ReturnValue
			| Verbatim.

// Class graph traversal definitions.
TraversalDef		= "traversal" <name> TraversalName
			  <parms> TraversalParms
			  *s "{" *l
			  + <strat> StrategyExpression ";"
			  - *l "}".

TraversalParms		= "(" [ <visitors> Commalist(Visitor) ] ")" .

Visitor			= ClassName [ VisitorName ].

// Adaptive methods.
MethodDef		= MethodSignature MethodBody.

MethodSignature		= <keywords> List(MethodKeyword)
			  <returnType> JavaType <name> MethodName
			  "(" [ <parms> Commalist(MethodParm) ] ")"
			  <throwsclause> Throws.
MethodKeyword		: PublicMethod | ProtectedMethod | PrivateMethod
			| StaticMethod | FinalMethod | AbstractMethod.
PublicMethod		= "public".
ProtectedMethod		= "protected".
PrivateMethod		= "private".
StaticMethod		= "static".
FinalMethod		= "final".
AbstractMethod		= "abstract".
MethodParm		= <type> JavaType <array1> List(ArraySpec)
			  <name> ParmName <array2> List(ArraySpec).
ArraySpec		= "[" "]".
Throws			= [ *s "throws" <exceptions> Commalist(ClassName) ].

MethodBody		: VerbatimMethodBody | AdaptiveMethodBody
			| NoMethodBody.
VerbatimMethodBody	= JavaCode.
AdaptiveMethodBody	= <trv> TraversalExpression <vis> VisitorExpression.
NoMethodBody		= ";".

TraversalExpression	: TraversalRef | TraversalSpec.
TraversalRef		= [Equals] <name> TraversalName.
Equals			= "=".	    // optional syntax
TraversalSpec		= <strat> StrategyExpression.

VisitorExpression	: VisitorRef | VisitorSpec.
VisitorRef		: WithVisitorRef | ParenVisitorRef.
WithVisitorRef		= "with" <visitorClasses> Commalist(ClassName) ";".
ParenVisitorRef		= "(" <visitorClasses> Commalist(ClassName) ")" ";".
VisitorSpec		= <methods> ClassMethods.

// Visit methods.
Wrapper			= <kind> WrapperKind <hosts> HostSpec JavaCode.
WrapperKind		: Before | Around | After.
Before			= "before".
Around			= "around".
After			= "after".

HostSpec		: GlobSpec.

// Derived part accessors.
Accessor		: Getter | Setter *common* PartName JavaCode .

Getter			= "get" .
Setter			= "set" .

// Constructor method.
// Only no-arg constructors supported for now.
Constructor		= "init" JavaCode.

// Methods called at the beginning and ending of a traversal.
Start			= "start" JavaCode.
Finish			= "finish" JavaCode.

// Code for computing the return value of a visitor when used in an
// adaptive method.
ReturnValue		= "return" [ <type> JavaType ] <exp> JavaCode.

// Verbatim java code.
Verbatim		= JavaCode.

// Terminal buffer classes.
PackageName		~ IdentOrKeyword { *lookahead* (@ 2 @) "." IdentOrKeyword }.
ClassName		= Name *implements* ClassNameI.
PartName		= <name> IdentOrKeyword *implements* PartNameI.
TraversalName		= Name.
VisitorName		= Name.
MethodName		= <name> Ident.
ParmName		= <name> Ident.
StrategyName		= <name> Ident.
JavaType		= <type> Name.
JavaCode		= <code> Text.

Name			~ Ident {   // kludge!!
    *lookahead* (@ "." _Ident(),{ "=:~(".indexOf(getToken(3).image) == -1 } @)
				  "." Ident }.

// All the keywords that look like identifiers in the class dictionary
// grammar that aren't keywords in Java.
IdentOrKeyword		: ParseIdent | NoParseIdent
			| VisitorsIdent | EndVisitorsIdent
			| VisitorIdent | NotParsedIdent
			| DerivedIdent | InitIdent
			| CommonIdent | LookaheadIdent
			| OtherIdent.
ParseIdent		= "parse".
NoParseIdent		= "noparse".
VisitorsIdent		= "visitors".
EndVisitorsIdent	= "endvisitors".
VisitorIdent		= "visitor".
NotParsedIdent		= "notparsed".
DerivedIdent		= "derived".
InitIdent		= "init".
CommonIdent		= "common".
LookaheadIdent		= "lookahead".
OtherIdent		= <id> Ident.

// Keywords with optional star forms.
ParseKeyword			: DoParse | DontParse.
DoParse				: DoParseWithoutStars | DoParseWithStars.
DoParseWithoutStars		= "parse".
DoParseWithStars		= "*parse*".
DontParse			: DontParseWithoutStars | DontParseWithStars.
DontParseWithoutStars		= "noparse".
DontParseWithStars		= "*noparse*".
VisitorKeyword			: BeginVisitors | EndVisitors.
BeginVisitors			: BeginVisitorsWithoutStars | BeginVisitorsWithStars.
BeginVisitorsWithoutStars	= "visitors".
BeginVisitorsWithStars		= "*visitors*".
EndVisitors			: EndVisitorsWithoutStars | EndVisitorsWithStars.
EndVisitorsWithoutStars		= "endvisitors".
EndVisitorsWithStars		= "*endvisitors*".
ClassKeyword			: PublicClass | FinalClass | InterfaceClass
				| VisitorClass | NotParsedClass.
PublicClass			: PublicClassWithoutStars | PublicClassWithStars.
PublicClassWithoutStars		= "public".
PublicClassWithStars		= "*public*".
FinalClass			: FinalClassWithoutStars | FinalClassWithStars.
FinalClassWithoutStars		= "final".
FinalClassWithStars		= "*final*".
InterfaceClass			: InterfaceClassWithoutStars | InterfaceClassWithStars.
InterfaceClassWithoutStars	= "interface".
InterfaceClassWithStars		= "*interface*".
VisitorClass			: VisitorClassWithoutStars | VisitorClassWithStars.
VisitorClassWithoutStars	= "visitor".
VisitorClassWithStars		= "*visitor*".
NotParsedClass			: NotParsedClassWithoutStars | NotParsedClassWithStars.
NotParsedClassWithoutStars	= "notparsed".
NotParsedClassWithStars		= "*notparsed*".
PartKeyword			: FinalPart | StaticPart | ReadOnlyPart
				| PrivatePart | DerivedPart.
FinalPart			: FinalPartWithoutStars | FinalPartWithStars.
FinalPartWithoutStars		= "final".
FinalPartWithStars		= "*final*".
StaticPart			: StaticPartWithoutStars | StaticPartWithStars.
StaticPartWithoutStars		= "static".
StaticPartWithStars		= "*static*".
ReadOnlyPart			: ReadOnlyPartWithoutStars | ReadOnlyPartWithStars.
ReadOnlyPartWithoutStars	= "read-only".
ReadOnlyPartWithStars		= "*read-only*".
PrivatePart			: PrivatePartWithoutStars | PrivatePartWithStars.
PrivatePartWithoutStars		= "private".
PrivatePartWithStars		= "*private*".
DerivedPart			: DerivedPartWithoutStars | DerivedPartWithStars.
DerivedPartWithoutStars		= "derived".
DerivedPartWithStars		= "*derived*".
PartInitKeyword			: PartInitKeywordWithoutStars | PartInitKeywordWithStars.
PartInitKeywordWithoutStars	= "init".
PartInitKeywordWithStars	= "*init*".
ExtendsKeyword			: ExtendsKeywordWithoutStars | ExtendsKeywordWithStars.
ExtendsKeywordWithoutStars 	= "extends".
ExtendsKeywordWithStars		= *s "*extends*" *s.
ImplementsKeyword		: ImplementsKeywordWithoutStars | ImplementsKeywordWithStars.
ImplementsKeywordWithoutStars	= "implements".
ImplementsKeywordWithStars	= *s "*implements*" *s.
CommonKeyword			: CommonWithoutStars | CommonWithStars.
CommonWithoutStars		= *l + + + "common" - - -.
CommonWithStars			= *l + + + "*common*" - - -.
LookaheadKeyword		: LookaheadKeywordWithoutStars | LookaheadKeywordWithStars.
LookaheadKeywordWithoutStars	= "lookahead".
LookaheadKeywordWithStars  	= "*lookahead*".

// Parameterized class definitions.
List(S) ~ {*s S}.
NList(S) ~ S {*s S}.
SList(S) ~ S { *l S } .
DList(S) ~ S { *l *l S } *l .
Commalist(S) ~ S {"," *s S}.
Barlist(S) ~ S { *l "|" *s S}.

*noparse*

// Utility classes.
TraversalMethodName	= MethodName.
ClassType		= <is_con> boolean <is_alt> boolean <is_rep> boolean
			  <is_public> boolean <is_final> boolean
			  <is_interface> boolean
			  <is_not_parsed> boolean <is_visitor> boolean.
PartType		= <is_final> boolean <is_static> boolean
			  <is_derived> boolean
			  <has_getter> boolean <has_setter> boolean .
Parts			~ { Part }.

///**********
//visitors (text-uml ones)

//turn off parsing for the visitors
*noparse*
*visitors*

PlacementVisitor = <ugraph>UGraph .
EdgeDistinctionVisitor = <edgetype> String.
ClassNameRetVisitor = <cn> ClassName.
ClassNameTranspVisitor = <pcn> ParamClassName.
EdgeVisitor =  <edv> EdgeDistinctionVisitor <cntv> ClassNameTranspVisitor 
		<ugraph>UGraph.
//************

// Visitors for UML - to - TEXT traversals

VertexReadingVisitor     =  <thegraph> UGraph <graphstring> String 
			 <lookupvid> Integer <uppervalue> Integer .
EdgeReadingVisitor       =  <thegraph> UGraph <graphstring> String 
			 <commonstring> String 
			 <lookupvid> Integer <fromtype> String
			 <pipeswitch> Integer <listswitch> Integer .

// Visitors and Main class (the GUI ones)

ReadVertexVisitor= <elements> VertexContainer .
VertexContainer  = < construction > Vector < alternation > Vector < termination > Vector.
ReadEdgeVisitor  = < elements > EdgeContainer .
EdgeContainer    = < construction > Vector < alternation > Vector .
Main			= .

CountingVisitor		= <total> Integer .
//TraversalVisitor	= <ug>UGraph <it>IndependantTraversal . 

superInitVisitor	: InitVisitor | HashCreateVisitor | TGUpdateVisitor.
InitVisitor		= .
HashCreateVisitor	=.

ListVectorVisitor	= <sv>Vector<dv>Vector<bv>Vector.

DecoCollectVisitor	=<duid>UID <v>Vector.
tostopVisitor		= .

RepClassSpecVisitor	= <first>Name  <inner>Name.
PlaceVertexVisitor	=  <pos>Coordinates <vtable>Hashtable <etable>Hashtable.

SomeClassSpecVisitor	= <uce>UConstEdge.


//Visitors for cd2gcd : for Modifiers
IntModVisitor	= <il>InterfaceModifier_List .
ClassModVisitor	= <sl>ScopeIdentifier_List .
PartModVisitor	= <pl>PartModifier_List .

//visitors for cdstring.beh

cdStringVisitor	: ConstVisitor | AltVisitor | IntVisitor 
		  *common* <return_val>String.
ConstVisitor	= <vtable> Hashtable <etable> Hashtable .
AltVisitor	= <vtable> Hashtable <etable> Hashtable .
IntVisitor	= <vtable> Hashtable <etable> Hashtable .

//visitors for CTGstrategy.beh
ClassGlobVisitor	: SourceEdgeCollector .
SourceEdgeCollector	= <sg> StrategyGraph <edges> NList(Integer).

ClassNameAccessor	: .

GlobVisitor		: GlobMatcher | GlobCollector
			| ClassGlobCollector | EdgeGlobCollector
			| OutgoingEdgeSpecConvertor | SGEdgeMatcher
			.
GlobMatcher		= Glob <found_one> boolean.
GlobCollector		= <spec> GlobSet.
ClassGlobCollector	= <spec> ClassGlobSet.
EdgeGlobCollector	= <spec> GlobSet.
OutgoingEdgeSpecConvertor = <spec> GlobSet.
SGEdgeMatcher		= <c> ClassNameI <index> int <return_val> Vector.

TGVertexCollector	= <tg> TraversalGraph.
TGEdgeGlobMaker		= <s> ClassName <d> ClassName <cl> ClassName
			  <name> PartName <return_val> Glob
			*extends* TGEdgeVisitor.


//visitors for CTGsubgraph.beh
TGCreateVisitor		= <g>TraversalGraph <vtable>Hashtable.
TGUpdateVisitor		= .

//visitor for gcdsave.beh & extracting propagation graph
SaveGraphVisitor = < graphString > String .
SelectMarkedVisitor	= <bflag>boolean <cflag> boolean <anyEdgeflag> boolean 
			<graphString> String <ioeString> String.

// Visitors for strategy graph extraction
SGraphCollector = <names>Vector <graphs>Vector.
VecVisitor = <names>Vector.
StringVisitor = <name> String.
DummyVisitor=.