Track any args for anonymous templates like
then }>
The lexer in action.g returns a single token ANONYMOUS_TEMPLATE
and so I need to have it parse args in the lexer and make them
available for when I build the anonymous template.
If this template is an embedded template such as when you apply
a template to an attribute, then the arguments passed to this
template represent the argument context--a set of values
computed by walking the argument assignment list.
If this template is embedded in another template, the arguments
must be evaluated just before each application when applying
template to a list of values.
array -
Variable in class org.antlr.stringtemplate.language.ArrayIterator
A reference to an attribute with no value, must be compared against
the formal parameter to see if it exists; if it exists all is well,
but if not, throw an exception.
A simple loader that looks only in the directory(ies) you
specify in the ctor, but it uses the classpath rather than
absolute dirs so it can be used when the ST application is jar'd up.
Represents the name of a formal argument
defined in a template:
group test;
test(a,b) : "$a$ $b$"
t() : "blort"
Each template has a set of these formal arguments or uses
a placeholder object: UNKNOWN (indicating that no arguments
were specified such as when a template is loaded from a file.st).
When templates are defined in a group file format, the attribute
list is provided including information about attribute cardinality
such as present, optional, ...
If an instance of x is enclosed in a y which is in a z, return
a String of these instance names in order from topmost to lowest;
here that would be "[z y x]".
Specify a complete map of what object classes should map to which
renderer objects for every template in this group (that doesn't
override it per template).
A group interface is like a group without the template implementations;
there are just template names/argument-lists like this:
interface foo;
class(name,fields);
method(name,args,body);
Normally StringTemplate tests presence or absence of attributes
for adherence to my principles of separation, but some people
disagree and want to change.
When template arguments are not available such as when the user
uses "new StringTemplate(...)", then the list of formal arguments
must be distinguished from the case where a template can specify
args and there just aren't any such as the t() template above.
Because we might need to wrap at a non-atomic string boundary
(such as when we wrap in between template applications
]}; wrap>) we need to expose the wrap string
writing just like for the separator.