celluloid.java.stg

group jcelluloid;

program(
 events, constraints,
 devices, predicates, 
 functions, code)  ::=
<<
  package org.celluloidlang.program;

  import java.io.File;
  import java.net.MalformedURLException;
  import javax.media.Manager;
  import org.celluloidlang.core.*;
  import org.celluloidlang.devices.*;
  import org.celluloidlang.reactive.*;
  import org.celluloidlang.announcment.*;
  import org.celluloidlang.constraints.buildtin.*;
  import org.celluloidlang.constraints.defined.*;


  <constraints:{ constraint | <constraint>}; separator="\r\n">
  <devices:{ device | <device> }; separator="\r\n">

  public class CelluloidProgram {
  	<events:{ event | <event> }; separator="\r\n">
  	<functions:{ function | <function> }; separator="\r\n">
  	<predicates:{ predicate | <predicates> }; separator="\r\n">

  	public static void main(String[] args) {
      /*
       * This is the one and only global timeline.
       * REQUIRED: global timeline is required, see the bottom
       * for the details
       */
      Timeline globalTimeline = new Timeline();

      // REQUIRED: Need this set to display video
      Manager.setHint(Manager.LIGHTWEIGHT_RENDERER, true);

      try {
  	    <code:{ code | <code>}; separator="\r\n">
  	  
        /*
         * EXECUTION BEGINS HERE
         */
        globalTimeline.play();
     } catch (MalformedURLException e) { System.err.println(e); return; }
  	}
  }

>>

announcementDefinition()              ::= ""
eventDefinition(name)                 ::= "private String <name>_event = \"<name>\";"

constraintDefinition(
 name, require,
 requires, block)                     ::=
<<
interface <name> <requires> {
  <block>
}
>>

deviceDefinition(name, accept, accepts, block) ::=
<<
class <name> extends JMF <accept> <accepts> {
 <block>
}
>>

functionHeader(name, args)             ::= "<name>(<args>);"
functionDefinition(name, args, block)  ::=
<<
public void <name> (<args>) {
  <block>
}
>>

predicateHeader(name, args)           ::= "public bool <name> (<args>);"
predicateDefinition(name, args, block) ::=
<<
public boolean <name> (<args>) {
  <block>
}
>>
predicateBlock(statements, returns) ::=
<<
  <statements:{ statement | <statement>}; separator="\r\n">
  return <returns>;
>>

ifStatement(exp, block)               ::=
<<
if (<exp>)
<block>

>>
ifBlock(block, elifStmt, elseStmt)    ::=
<<
{
  <block>
}
<elifStmt>
<elseStmt>
>>
elseIfStatement(exp, block)           ::=
<<
else if (<exp>)
{
  <block>
}
>>
elseStatement(block)           ::=
<<
else
{
  <block>
}
>>

whenStatement(with, name, event, lblock)  ::= 
<<
<with>.addEventFunction(<name>, "<event>",
    <lblock>
);
>>

everyStatement(with, name, event, time, lblock) ::=
<<
<with>.addEveryFunction(
    new EveryFunction(new ReactiveNumber(<time>), <lblock>

)

>>

functionPredicateCall(name, args)     ::= "<name>(<args>)"

constraintFunctionCall(
 with, target,
 type, function,
 time, args)                          ::=
<<
<with>.addConstraintFunction(new ConstraintFunction(<target>, new ReactiveNumber(<time>)) {
  public void execute() {
    ((<type>) input).<function>(<args.st>);
  }
);
>>

eventFunctionCall(with, function, name, type)  ::=
<<
new EventFunction(<name>) {
	public void execute() {
	    ((<type>) input).<function>();
	}
}
>>

everyFunctionCall(function, name, type, target)  ::=
<< <target>, <name>) {
				public void execute() {
					if(evals[0].isPlaying())
						((<type>) input).<function>();
				}
>>

outputConstraintFunctionCall(
 with, target,
 type, function,
 time, args)                          ::=
<<
globalTimeline.addConstraintFunction(
    new OutputConstraintFunction(
        <target>,
        <with>,
        new ReactiveNumber(<time>)) {
                                        public void execute() {
                                            ((<type>) input).attachOutput(output);
                                        }
                                     }
);

globalTimeline.addConstraintFunction(new ConstraintFunction(<target>, new ReactiveNumber(<time>)) {
    public void execute() {
        ((<type>) input).<function>(<args>);
    }
});
>>

passThrough(text)  ::= "<text>"
idList(ids)                           ::= "<ids:{ id | <id.text> }; separator=\", \">"
variableList(vars)                    ::= "<vars:{ var | <var> }; separator=\", \">"
expressionList(exps)                  ::= "<exps:{ exp | <exp> }; separator=\", \">"
statementList(statements)             ::=
<<
<statements:{ statement | <statement>}; separator="\r\n">
>>

variableArgument(type, name)          ::= "<type> <name>"
timelineArgument(name)                ::= "Timeline <name>"
outputDeclaration(type, name, args)   ::= "<type> <name> = new <type>(\"Celluloid Output\", 1024, 768);"
jmfDeviceDeclaration(type, name, args) ::= "<type> <name> = new <type>(new File(<args>).toURI().toURL());"
deviceDeclaration(type, name, args)   ::= "<type> <name> = new <type>(<args>);"
variableDeclaration(type, name, init) ::= "<type> <name> <init>;"
timelineDeclaration(name)             ::= "Timeline <name> = new Timeline();"
initializer(exp)                      ::= " = <exp>"
expressionLine(lhand,op,rhand)        ::= "<lhand> <op> <rhand>;"
expression(lhand,op,rhand)            ::= "<lhand> <op> <rhand>"
simpleExpression(lhand)               ::= "<lhand>"
primaryExpression                     ::= ""