Hi Mira:

time has come to propose a grammar for APPCs.
Below is a pretty complete proposal which reuses
much of Demeter/Java.

As an interim solution I plan to have  *.appc files in
Demeter/Java that produce Java packages working together
with the rest of Demeter/Java.

I will polish it further. Any suggestions?

-- Karl

  import java.util.*;
  import java.io.*;

// need to add: 
// to strategies: 
//   introduce variable names for object transportation
// to class graphs:
//   parameters on edges (methods with arguments)
// implement Persephone semantics
// to behavior:
//   allow keyword: main-entry
//   should we allow strategy {visitor methods} anywhere?

APPC_with_Mapping = APPC Mapping.

APPC = // independent of class graph
  "APPC" <name> APPC_Name
  "ICG" <icg> ClassGraph
  [<strategies> NList(StrategyDefinition) ]
  Behavior
  .
Behavior = "behavior"
  ClassBehavior. // taken from Demeter/Java and modified
// modifications needed to Demeter/Java syntax
// add at method
// allow return values from wrappers

Mapping = // dependent on class graph
  "mapping" MappingKind.
MappingKind : DefaultMapping.
DefaultMapping = "default".


StrategyDefinition	= "strategy" StrategyName "="
			  <exp> StrategyExpression ".".
StrategyExpression	: SGEdge| StrategyGraph | StrategyName
  *common* [ <constraint> NegativeConstraint ].
StrategyGraph		= "{" *l + 
				   <edges> SList(StrategyExpression) - *l "}".
SGEdge		  = "->" <source> ClassGlobSpec *s
			    <dest> ClassGlobSpec.
Constraint		: NegativeConstraint *common* <glob> GlobSpec.
NegativeConstraint	: Bypassing.
Bypassing		= "bypassing".
GlobSpec		: OneGlob | GlobSet.
OneGlob			= Glob.
GlobSet			= "{" *s [ <globs> Commalist(Glob) *s ] "}".
Glob			: ClassGlob | EdgeGlob.
EdgeGlob		: PartGlob .
ClassGlob		= <name> ClassNameGlob.
PartGlob		= "->" *s <source> SourceGlob "," *s
				  <name> PartNameGlob "," *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 "}".
Main = .
// Terminal buffer classes.
ClassName		= Name.
APPC_Name		= Name.
PartName		= Name.
StrategyName		= Name.
Name			~ Ident {   // kludge!!
    *lookahead* (@ "." _Ident(), { "=:~(".indexOf(getToken(3).image) == -1 } @)
				  "." Ident }.
// Parameterized class definitions.
List(S) ~ {*s S}.
NList(S) ~ S {*s S}.
SList(S) ~ S { *l S } .
Commalist(S) ~ S {"," *s S}.


// demjava.cd -- class dictionary for Demeter/Java
// /proj/adaptive/www/sources/DemeterJava/examples/j-check-TBR3

Program			= [ <pkg> Package ] [ <preamble> JavaCode ] ClassGraph.

Package			~ "package" DirName { "." DirName } ";".

ClassGraph		= <classes> DList(ClassDef).

ClassDef		= ParamClassName ClassParts "."
 			  .

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

ClassParts		: ConstOrAltClass | RepetitionClass.

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

PartOrSyntax		: Part | OptionalPart | Syntax.

Part			= [ "<" PartName ">" ] ClassSpec.

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

ClassParents		= [ "*extends*" <parents> ClassSpec ]
			  [ "*implements*" <interfaces> Commalist(ClassSpec) ] .

ConstructionClass	= "=".

AlternationClass	= ":" + + + <subclasses> Barlist(Subclass) - - -
			[ Common ].

Subclass		= ClassSpec.

Common			= *l + + + "*" "common" "*" - - -.

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

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

Sandwich(S)		= <first> List(Syntax) <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" .


// Terminal buffer classes.
DirName			= <name> Ident.
// ClassName               = <name> Ident.
// PartName                = <name> Ident.
JavaCode                =  <code> Text.
// JavaCode                = "(@" <code> String "@)".

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

// Extra utility parameterized classes.
Parameterized           = Commalist(Part).
SyntaxTable             = List(PlainSyntax).

// Visitors

IsDemeterClassVisitor = 
  // vector of cd defined class names 
  <cd_defined_classes_out> ClassNames. 
CheckingVisitor = 
  // vector of cd defined class names 
  <cd_defined_classes_in> ClassNames
  <className> ClassName // current class
  <p> Integer // number of parts per class
  <pt> Integer // number of terminal parts per class
  <passed> Boolean
  .
ClassNames = *extends* Vector. // Vector(String)


// from cd of Demeter/Java
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 <name> ParmName
			  <array> List(ArraySpec).
Throws			= [ *s "throws" <exceptions> Commalist(ClassName) ].

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

// TraversalExpression	: TraversalRef | TraversalSpec.
TraversalExpression	: 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			= 
  <returnType> JavaType // changed from Demeter/Java: added
  <kind> WrapperKind <hosts> HostSpec JavaCode.
WrapperKind		: Before | Around | After | At.
Before			= "before".
Around			= "around".
After			= "after".
At			= "at".

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.
TraversalName		= Name.
VisitorName		= Name.
MethodName		= <name> Ident.
ParmName		= <name> Ident.
JavaType		= <type> Name <array> List(ArraySpec).
ArraySpec		= "[" "]".