//
// The class dictionaries which define the inputs to our tools are
// available with the following copyright notice:
//  Copyright (C) 1990-1993 Northeastern University.
//   Permission is granted to any individual or 
//   institution to use, copy, modify,
//   and distribute this class dictionary, 
//   provided that this complete copyright
//   and permission notice is maintained, 
//   intact, in all copies and supporting
//   documentation.

////////////////////////////////////////////////////////////////////////////////
// possible inputs
////////////////////////////////////////////////////////////////////////////////

Demeter_in    = <input> Input. 
Input         :    Cd_graph               // schema
                |  Propagation_patterns   // implementations of propagation patterns
                |  Propagation_schema .

Propagation_schema = [ "*source*" <source_port> Vertex_selector *l ]
                     [ "*target*" <target_port> Vertex_selector *l ]
                      + "*paths*" *l +  <paths> Cd_graph  - - *l.

Schema_name        =  <name> DemIdent.
File_name          =  <name> DemString.

Dir_name           = "*directive*" <name> DemIdent .
Class_set_name     = "*class-set*" <name> DemIdent .

CRFV_name          = <name> Term. // Class Relation Var Function

////////////////////////////////////////////////////////////////////////////////
// schema  definition
////////////////////////////////////////////////////////////////////////////////

Cd_graph     =    <adjacencies> Nlist(Adjacency)
                [ + "*dfs_n*" <dfs_n> DemNumber - *l ]
                [ + "*current_component*" <current_component> DemNumber - *l ]
                [ + "*stack*" <stack> List(Adjacency) - *l ]
                [ + "*matrix*" <matrix> List(SCC_component) - *l ]              
                [ + "*terminal_sets*" <terminal_sets> Commalist(Vertex) "." - *l ] .

Adjacency    = < source > Vertex                                                        
               ["(" < parameters> Commalist(Vertex) ")"]                               
               < ns > Neighbors *l
               [ + "*intransportedargs*"  <inarguments> Commalist(Param_decl) - *l ]
               [ + "*outtransportedargs*" <outarguments> Commalist(Param_decl) - *l ]
               [ + "*assignments*"     <param_assignments> List(Param_assignment) - *l ]
               [ + "*propagate*" <propagate> DemString - *l ]
               [ + "*generated*" <generated> DemString - *l ]
               [ + "*tempmark*"  <tempmark>  DemString - *l ]     
               [ + "(*signatures*" <signatures> Commalist(Signature) ")" - *l ]
               [ + "(*inherits*"   <superclasses> List(Vertex) ")" - *l ]
               [   <emptyMethod> $int ]
               [ + "*dfs*"   <dfs>   DemNumber - *l ]
               [ + "*high*"  <high>  DemNumber - *l ]
               [ + "*scc*"   <scc>   DemNumber - *l ]
               "." .                                                                    
Neighbors    : Neighbors_wc |  Repetit_n  *common*. 
Neighbors_wc : Construct_ns |  Alternat_ns                          
                  *common* *l + + + < construct_ns > List(Any_vertex) - - - .    
Construct_ns = "=".                                                        
Alternat_ns  = ":" [ *l + + + <alternat_ns> Barlist(Term) - - - ] <common> Common .    
Common       = + + + "*common*" - - - .

Repetit_n    = "~" [ <sandwiched> Sandwich(Kernel) ].                             
Kernel       = [ <nonempty> Term ]  "{" <repeated> Sandwich(Term) "}".

Any_vertex   : Opt_labeled_term  | Optional_term  | Syntax_vertex  | Inherit_term 
     *common*
   [ + + + "*AnyVertexcallValues*" <callVals> Commalist(Param_decl) "." - - - *l ]
   [ + + + "*bypass_at_anyvertex*" <bypassing> DemString - - - *l ]
   [ + + + "*propagate_edges_at_anyvertex*" <call> DemString - - - *l ] *l.


Vertex       =  < vertex_name > DemIdent
           [ *l + + + "*callValues*" <callVals> Commalist(Param_decl) "." - - - ]
           [ *l + + + "*bypass_at_vertex*" <bypassing> DemString - - - ]
           [ *l + + + "*propagate_EAr_at_vertex*" <call> DemString - - - ].

Syntax_vertex :  Regular_syntax | Print_command *common*. 
Print_command :  Print_indent | Print_unindent | Print_skip | Print_space *common*.
Print_indent   = "+" .
Print_unindent = "-" .
Print_skip     = "*l" .
Print_space    = "*s" .

Regular_syntax  = < string > DemString .                                      
Opt_labeled_term :  Labeled | Regular
      *common*  [StaticSpec] [AccessorSpec] <vertex> Term. 

StaticSpec = "*static*" .
AccessorSpec : ReadOnlyAcc | PrivateAcc *common* .
ReadOnlyAcc = "*read-only*" .
PrivateAcc = "*private*" .

Regular          = .                                                                
Labeled          = "<" < label_name > DemIdent ">" .                                   
Inherit_term     = "*inherit*" <inherited> Commalist(Term). 
Term : Normal | CppTerm 
	*common* <vertex> Vertex 
		 <moduleRef> TermRef
           [ *l + + + "(" <actual_parameters> Commalist(Term) ")" - - - ]
           [ *l + + + "*TermcallValues*" <callVals> Commalist(Param_decl) "." - - - ] 
           [ *l + + + "*bypass_at_term*" <bypassing> DemString - - - ]
           [ *l + + + "*propagate_edges_at_term*" <call> DemString - - - ].
CppTerm = "$" .
Normal = .
TermRef : LocalRef | ModuleRef.
ModuleRef : CompRef | LibRef *common* <moduleName> DemIdent.
LocalRef = .
CompRef = "@".
LibRef  = "@@".
Optional_term = "[" <opt> Sandwich(Opt_labeled_term) "]".                  

/////////////////////////////////////////////////////////////////////////////////////
// for SCC computation
/////////////////////////////////////////////////////////////////////////////////////

SCC_component =  + + + "*scc*" <scc> DemNumber <mark> DemString  *l
                       <edges> List(SCC_component_Edges) - - - .
SCC_component_Edges = "*sccedge*" <scc> DemNumber <mark> DemString *l .


/////////////////////////////////////////////////////////////////////////////////////
// propagation patterns
/////////////////////////////////////////////////////////////////////////////////////

Propagation_patterns  =  [ <text> CppCode ]
                         <pps> List (Propagation_pattern) 
		         [ "*C*" <oldtext> CppCode ]
                         ["*cd*" <cdgraph> Cd_graph ]            //for implementation
                         .

Propagation_pattern   =    <header> Header
                           [ <meta_def> Meta_def ]
                           <impl_or_loc>  Impl_or_loc.

Meta_def           =  + "*constraints*" *l <meta_def> Meta_macro_def "*end*" - *l .

Meta_macro_def     = [ + "*classes*"     <classes>    Commalist(Term) - *l ]
                     [ + "*edge*" "*patterns*"  <relations>  Commalist(Meta_edge) - *l ]
                     [ + "*class-set*" *l +  <class_sets> Amplist(Class_set_def) -  - *l ]
                     [ + "*directives*"       *l +  <dirs>       Amplist(Dir_meta_def) -  - *l ].

Class_set_def     = <class_set_name> Class_set_def_name
                    "=" <class_set>  Vertex_selector ";" .
Class_set_def_name    = <name> DemIdent.

Dir_meta_def      = <dir_name> Dir_def_name
                    "=" <pde> Propagation_directive_exp ";" .
Dir_def_name          = <name> DemIdent.

Impl_or_loc                : Implementation | Pp_location.
Pp_location                = + <pp_file>  File_name - *l.

Header                =  <signature> Signature
                         [ + "*access*" <access>  Vertex_selector  - *l ] .

Signature              =  *l "*operation*"
                          <type_spec> Type_spec
                          <name>  Op_name
                          "(" [ <parameter_decls> Commalist(Param_decl) ] ")"
                          [ <const_qualifier> Const ]
                          [ "*init*" <init> CppCode ] *l .

CppCode                = <code> DemText.

Op_name                =  <op_name> DemIdent.
Type_spec              :  Void | Nonvoid_type_spec.
Void                   =  "void".
Nonvoid_type_spec      :  Type_with_attribute | Type_without_attribute.
Type_without_attribute =  <param_type>      Type.
Type_with_attribute    =  <param_attribute> Param_attribute
                          <param_type>      Type.
Param_attribute        :  In | Out | Inout.
In                     =  "*in*".
Out                    =  "*out*".
Inout                  =  "*inout*".

Param_decl             =  <param_type_spec> Nonvoid_type_spec
                          <param_name> Param_name
			  [ "=" <default_val> CppCode ].
Param_name             =  <name> DemIdent.

Type                   =  [ <type_qualifier> Type_qualifier ]
                            <type_name> Term
                            <refs> List(Ref_Ptr).
Ref_Ptr                :  Ref | Ptr.
Ref                    =  "&".
Ptr                    =  "*".
Type_qualifier         :  Const | Struct .
Const                  =  "const".
Struct                 =  "struct".

Implementation         =  [ + "*traverse*" *l + <pde>    Propagation_directive_exp  - - *l ]
                           <carry_or_wrapper>    List(Carry_or_wrapper).

Carry_or_wrapper       : Sig_ext_prim | Code_fragment.

Sig_ext_prim           = + "*carry*" <arguments>   Commalist(Param_decl) *l
                         +   "*along*" <pde>       Propagation_directive_exp - *l
                         +    <assignments> List(Param_assignment_block) - - *l.

Param_assignment_block   = "*at*" [ <pa> PrefixAssign ] <vertices> Vertex_selector *l 
                           <param_assignments> List(Param_assignment).

PrefixAssign = "*prefix*".

Param_assignment         =  + <param> Param_name "=" <proc_fragment> CppCode - *l .


Impl_param_assignment    =  + <param> Param_name [ <proc_fragment> CppCode ] - *l .

Code_fragment            =   + "*wrapper*" <vertices_edges> Vertices_edges *l
			     [ + "*prefix*" <prefix> Prefix - *l ]
                             [ + +  <prefix_fragment>     CppCode - - *l ]
                             [ + "*suffix*" *l + <suffix_fragment>      CppCode - - *l ]
			     -.

Prefix = .
////////////////////////////////////////////////////////////////////////
// propagation directive expressions
////////////////////////////////////////////////////////////////////////

Propagation_directive_exp : Pde  | Merge_pde | Join_pde | Dir_name_with_exp.

Dir_name_with_exp = <inst> DemIdent.

Merge_pde   = "*merge*" "(" <pde1> Propagation_directive_exp ","
                            <pde2> Propagation_directive_exp
                        ")".

Join_pde   = "*join*" "(" <pde1> Propagation_directive_exp ","
                            <pde2> Propagation_directive_exp
                      ")".



Pde                       =  "*from*" <source_port> Vertex_selector
                             [ <constraint> Path_constraint_exp ]
                             <via> List(Segment).

Segment                    =  <targets> Targets
                              [  <constraint> Path_constraint_exp ].

Targets                    =  <to_or_via> To_or_via
                              <targets> Vertex_selector .

To_or_via                 : To | Via | Tostop.

Via                       = "*via*".
To                        =  "*to*".
Tostop                    =  "*to-stop*".

Path_constraint_exp        : Require_through | Require_bypassing.
Require_through            =    <through>   Through_path_constraint 
                              [ <bypassing> Bypassing_path_constraint ].
Require_bypassing          =   <bypassing>  Bypassing_path_constraint 
                             [ <through>   Through_path_constraint ].
Through_path_constraint    = "*through*"   <through>   Commalist(Meta_edge).
Bypassing_path_constraint  = "*bypassing*" <bypassing> Commalist(Meta_edge).

Vertices_edges             :  Require_vertex_selector | Require_meta_edges.

Require_vertex_selector    = <vertices> Vertex_selector
                             [ <edges>  Meta_edges ].

Require_meta_edges         = <edges>  Meta_edges
                             [ <vertices> Vertex_selector ].

Meta_edges                 =  <edges> Commalist(Meta_edge).

Meta_edge                  : Meta_construction_edge | Meta_alternation_edge |
                             Meta_repetition_edge | Meta_inheritance_edge. 


Meta_construction_edge       = "->" <from>  Vertex_selector ","
                                    <edge_label> Label_selector ","
                                    <to> Vertex_selector .
Meta_alternation_edge        = "=>" <from> Vertex_selector ","
                                    <to> Vertex_selector  .
Meta_inheritance_edge        = ":>" <from> Vertex_selector ","
                                    <to> Vertex_selector .
Meta_repetition_edge         = "~>" <from> Vertex_selector ","
                                    <to> Vertex_selector .

Macro_exp                    = "*expand*" .


Vertex_selector            : Any_term | Fixed_term | Vertex_set.

Any_term                   =   "*".
Fixed_term                 = <vertex> Term.

Vertex_set                 : Vertex_set_sim | Vertex_set_comp | Class_set_inst | Late_selected_terms.

Vertex_set_sim             =  "{" <terms> Commalist(Fixed_term) "}" .

Vertex_set_comp            = <op> Vertex_set_op <arg1> Vertex_set <arg2> Vertex_set ")".

Vertex_set_op              : Union | Intersect.

Union                      = "*union*" "(".
Intersect                  = "*intersect*" "(".

Class_set_inst             = <name> Class_set_name.

Late_selected_terms        = "(*class-set*" <pde> Propagation_directive_exp ")".

Label_selector             : Any_edge_label | Relation_meta_var | Label_set.
Label_set                  = "{" <labels> Commalist(Relation_meta_var) "}".
Any_edge_label             =   "*".
Relation_meta_var          = <name> DemIdent.

/////////////////////////////////////////////////////////////////////////////////
// parameterized classes
/////////////////////////////////////////////////////////////////////////////////
List(S) ~ {S}.                                                             
Nlist(S) ~ S { *l S} *l .                                                          
Barlist(S) ~ S {"|" *l  S}.                                                   
Commalist(S) ~ S {"," S}.
Amplist(S) ~ S { *l  S } .                                                 
Sandwich(S) =                                                              
  <first> List(Syntax_vertex) <inner> S                                    
  <second> List(Syntax_vertex)                                             
  .