Velocity - Velocity Specification

This is tentatively the AST structure for Velocity.

The structure is as would be described using ANTLR
BNF-style notation.  A tree is described by 
#(node node node) where #() represents the tree form.  
The first node is the root of the tree, and following 
nodes are all children.

Visually, #(A B C D E) might look like:

     A
     |
     B-C-D-E

Root nodes must always be a terminal node, denoted by
an all-caps identifier.

Non-root nodes may be either terminal nodes, or sub-rules,
or inlined sub-trees. 

A sub-rule might describe a tree, or simple a node.


block
    :
        #(  BLOCK
                (statement)*
        )

    ;
statement
    :
            text
        |   if_statement
        |   foreach_statement
        |   include_statement
        |   set_statement
        |   parse_statement
        |   param_statement
        |   stop_statement
        |   reference
    ;


text
    :
        TEXT
    ;

//  if/elseif/else chains should be represented solely
//  by <if_statement>.  <elseif> is simply an <if_statement>
//  in the false-branch of the preceeding <if_statement>
//  while <else> is simply an <if_statement> where the
//  <expr> evaluates to TRUE always, and no false-branch
//  is provided.

if_statement
    :
        #(  IF
                // The expression to test
                expr

                // True branch
                block

                // False branch
                ( block )?
        )
    ;

foreach_statement
    :
        #(  FOREACH
                // Value to assign for each iteration
                reference
                // List of objects to iterator
                reference
                // command-block to execute
                ( block )?
        )
    ;

set_statement
    :
        #(  SET
                // Variable to set
                reference
                // Value to assign
                expr
    ;

parse_statement
    :
        #(  PARSE
                STRING_LITERAL
        )
    ;

include_statement
    :
        #(  INCLUDE
                STRING_LITERAL
        )
    ;

stop_statement
    :
        STOP
    ;

reference
    :
        #(  REFERENCE
                postfix
    ;

postfix
    :
        method_call
        |
        member
        |
        identifier
    ;

member
    :
        #(  DOT
                identifier
                (   primary
                |   method_call
                )   
    ;

primary
    :
        IDENTIFIER
    ;

method_call
        #(  CALL
                postfix
                // The argument list
                ( expr ) *
        )
    ;