(*
 * PBNF, the people's BNF, for beings capable of working at the apobetic level
 *
 * CHANGELOG:
 * ==========
 * 2002.02.21-15:30
 * - allowed for "application/*/use" element
 * - changed "call/@version" to @minIncludeVersion and @maxIncludeVersion
 * - fixed problem with mixed content in "application/*"
 * - changed "declare/@type" to "declare/@container"
 * - added "declare/@type" to declare the linkage of the parameter.
 *
 * 2002.02.21-09:30
 * - (re-) creation date
 *
 *) 

definitions = 
    <definitions version=string		(* required *)
     [ vdlns=string ]			(* VDL namespace we define in *)
     (* TODO: Dublin Core subset on creator/creation information? *)
    >
	{ transformation | derivation }
    </definitions> ;

transformation =
    <transformation name=token
     [ version=string ]			(* must allow "order" facet *)
     [ vdlns=string ]			(* override parent VDL namespace *)
     (* TODO: Ewa/Gaurang meta data on transformation *)
    >
	formal-parameter, transformation-body
    </transformation> ;

derivation =
    <derivation uses=token		(* matches "name" of transformation *)
     [ maxIncludeVersion=string ]	(* default: "unbounded" *)
     [ minIncludeVersion=string ]	(* default: "unbounded" *)
     [ name=token ]			(* allows optional nameing *)
     [ vdlns=string ]			(* override parent VDL namespace *)
    >
	actual-parameter
    </derivation> ;

formal-parameter =
    <formal-parameter>
	{ declare }			(* declare formal parameter
    </formal-parameter> ;

declare =				(* declare a formal-parameter *)
    <declare name=token			(* name of variable *)
       link=LinkageType			(* input, output, inout, none *)
     [ container=ContainerType ]	(* fixed "scalar" for temp. *)
     [ vdlns=string ]			(* override VDL namespace *)
    >
	(* TODO: only scalar defaults allowed? *)
    </default> ;

transformation-body =
    <transformation-body>
	[ temporary ],			(* local variables section *)
	{ parameter-file },		(* any number of parameter files *)
	( application, [ argument ] |	(* simple transformation *)
	  call, { call } ),		(* compound transformation *)
	{ environment },
	{ condor }
    </transformation-body> ;

temporary =
    <temporary
     [ vdlns=string ]
    >
	declare, { declare }		(* see above for definition *)
    </temporary> ;

parameter-file =
    <parameter-file name=token
     [ render=string ]			(* default renderer *)
    >
	{ chunk }
    </parameter-file> ;

application =
    <application>
	[ pre-script ],
	executable,
	[ postscript ]
    </application> ;

pre-script, post-script =
    <(pre|post)-script 
     [ universe=UniverseType ]		(* default: "scheduler" *)
    >
	( #PCDATA | 			(* either a physical filename *)
	  lfn |				(* or a logical filename *)
	  use )				(* referral to parameter content *)
    </(pre|post)-script> ;

executable =
    <executable
     [ universe=UniverseType ]		(* default: "vanilla" *)
    >
	( #PCDATA | 			(* either a physical filename *)
	  lfn |				(* or a logical filename *)
	  use )				(* referral to parameter content *)
    </executable> ;

argument = 
    <argument>
	{ chunk }
    </argument> ;

chunk =
    <chunk 
     [ name=token ]
     [ render=string ]			(* rendering hint, not XSLT *)
    >
	{ #PCDATA |			(* consider <![CDATA[...]]> *)
	  lfn |				(* referral to logical filename *)
	  use |				(* referral to parameter content *)
	  br }				(* visual markup option *)
    </chunk> ;

call =
    <call uses=token			(* matches "name" of invocation *)
     [ name=token ]			(* name it, if you want to *)
     [ maxIncludeVersion=string ]	(* default: "unbounded" *)
     [ minIncludeVersion=string ]	(* default: "unbounded" *)
     [ vdlns=string ]
    >
	actual-parameter
    </call> ;

environment, condor =
    <(environment|condor) key=token>	(* name of variable *)
	{ #PCDATA |			(* verbatim text *)
	  lfn |				(* referral to LFN *)
	  use }				(* referral to parameter content *)
    </(environment|condor)> ;

actual-parameter =
    <actual-parameter>
	{ pass }
    </actual-parameter> ;

pass =
    <pass bind=token			(* name of parameter to bind to *)
     [ name=token ]
    >
	( scalar |			(* encapsulate as-is and lfn *)
	  list |			(* vector, or list *)
	  hash )			(* dictionary *)
    </pass>

scalar =
    <scalar [name=token]>
	{ #PCDATA |			(* verbatim value to pass *)
	  lfn |				(* LFN to pass *)
	  use }				(* NOT available in derivations *)
    </scalar> ;

list =
    <list [name=token]>
	{ i }
    </list> ;

hash =
    <hash [name=token]>
	{ kv } 
    </hash> ;

i = <i [index=integer]>
	{ #PCDATA |			(* verbatim value to pass *)
	  lfn |				(* LFN to pass *)
	  use }				(* NOT available in derivations *)
    </i> ;

kv = 
    <kv key=string>
	{ #PCDATA |			(* verbatim value to pass *)
	  lfn |				(* LFN to pass *)
	  use }				(* NOT available in derivations *)
    </kv> ;

lfn = 
    <lfn
     file=string			(* logical filename *)
     type=LinkageType			(* restricted: input, output, inout *)
    /> ;				(* empty element *)

use =
    <use name=token			(* name of parameter referred to *)
     [ render=string ]			(* rendering hint *)
     [ type=LinkageType ]		(* restricted hint: input, output *)
    /> ;				(* empty element *)

ContainerType =
    ( scalar | list | hash ) ;

LinkageType =
    ( input | output | inout | none ) ;

UniverseType =
    ( standard | vanilla | scheduler | globus | mpi | pvm | java ) ;