Parser (Apache Velocity 2.1 API)

java.lang.Object
- org.apache.velocity.runtime.parser.Parser

All Implemented Interfaces:

ParserTreeConstants, ParserConstants
```
public class Parser
extends Object
implements ParserTreeConstants, ParserConstants
```
This class is responsible for parsing a Velocity template. This class was generated by JavaCC using the JJTree extension to produce an Abstract Syntax Tree (AST) of the template. Please look at the Parser.jjt file which is what controls the generation of this class.

Version:

$Id: Parser.jjt 1854737 2019-03-03 17:47:32Z cbrisson $

Author:

Jason van Zyl, Geir Magnusson Jr., Henning P. Schmiedehausen

Field Summary

Fields
Modifier and Type	Field and Description
`Template`	`currentTemplate` Current template we are parsing.
`Token`	`jj_nt` Next token.
`protected JJTParserState`	`jjtree`
`boolean`	`strictEscape` Set to true if the property RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE is set to true
`Token`	`token` Current token.
`ParserTokenManager`	`token_source` Generated Token Manager.

Fields inherited from interface org.apache.velocity.runtime.parser.node.ParserTreeConstants
JJTADDNODE, JJTANDNODE, JJTASSIGNMENT, JJTBLOCK, JJTCOMMENT, JJTDIRECTIVE, JJTDIRECTIVEASSIGN, JJTDIVNODE, JJTELSEIFSTATEMENT, JJTELSESTATEMENT, JJTEQNODE, JJTESCAPE, JJTESCAPEDDIRECTIVE, JJTEXPRESSION, JJTFALSE, JJTFLOATINGPOINTLITERAL, JJTGENODE, JJTGTNODE, JJTIDENTIFIER, JJTIFSTATEMENT, JJTINDEX, JJTINTEGERLITERAL, JJTINTEGERRANGE, JJTLENODE, JJTLTNODE, JJTMAP, JJTMETHOD, JJTMODNODE, JJTMULNODE, JJTNEGATENODE, JJTNENODE, jjtNodeName, JJTNOTNODE, JJTOBJECTARRAY, JJTORNODE, JJTPROCESS, JJTREFERENCE, JJTSETDIRECTIVE, JJTSTRINGLITERAL, JJTSUBTRACTNODE, JJTTEXT, JJTTEXTBLOCK, JJTTRUE, JJTVOID, JJTWORD

Fields inherited from interface org.apache.velocity.runtime.parser.ParserConstants
ALPHA_CHAR, ALT_VAL, BEFORE_EOF, BRACKETED_WORD, COLON, COMMA, DEFAULT, DIGIT, DIRECTIVE, DIRECTIVE_CHAR, DIRECTIVE_TERMINATOR, DIVIDE, DOLLAR, DOLLARBANG, DOT, DOUBLE_ESCAPE, DOUBLEDOT, ELSE, ELSEIF, EMPTY_INDEX, END, EOF, EQUALS, ESCAPE, ESCAPE_DIRECTIVE, EXPONENT, FALSE, FLOATING_POINT_LITERAL, FORMAL_COMMENT, HASH, IDENTIFIER, IDENTIFIER_CHAR, IF_DIRECTIVE, IN_FORMAL_COMMENT, IN_MULTI_LINE_COMMENT, IN_MULTILINE_COMMENT, IN_SINGLE_LINE_COMMENT, IN_TEXTBLOCK, INDEX_LBRACKET, INDEX_RBRACKET, INLINE_TEXT, INTEGER_LITERAL, LBRACKET, LCURLY, LEFT_CURLEY, LETTER, LOGICAL_AND, LOGICAL_EQUALS, LOGICAL_GE, LOGICAL_GT, LOGICAL_LE, LOGICAL_LT, LOGICAL_NOT, LOGICAL_NOT_EQUALS, LOGICAL_OR, LOGICAL_OR_2, LONE_SYMBOL, LPAREN, MINUS, MODULUS, MULTI_LINE_COMMENT, MULTIPLY, NEWLINE, OLD_ALPHA_CHAR, OLD_IDENTIFIER, OLD_IDENTIFIER_CHAR, PIPE, PLUS, PRE_DIRECTIVE, PRE_OLD_REFERENCE, PRE_REFERENCE, RBRACKET, RCURLY, REFERENCE, REFERENCE_TERMINATOR, REFINDEX, REFMOD, REFMOD2, REFMOD2_RPAREN, REFMOD3, REFMODIFIER, RIGHT_CURLEY, RPAREN, SET_DIRECTIVE, SINGLE_LINE_COMMENT, SINGLE_LINE_COMMENT_START, STRING_LITERAL, SUFFIX, TEXT, TEXTBLOCK, tokenImage, TRUE, WHITESPACE, WORD

Constructor Summary

Constructors
Constructor and Description
`Parser(CharStream stream)` Constructor with user supplied CharStream.
`Parser(ParserTokenManager tm)` Constructor with generated Token Manager.
`Parser(RuntimeServices rs)` This constructor was added to allow the re-use of parsers.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`AdditiveExpression()`
`void`	`Assignment()`
`boolean`	`Comment()`
`void`	`ConditionalAndExpression()`
`void`	`ConditionalOrExpression()`
`boolean`	`Directive(boolean afterNewline)` Supports the Pluggable Directives #foo( arg+ )
`int`	`DirectiveArg()` Supports the arguments for the Pluggable Directives
`void`	`DirectiveAssign()`
`void`	`disable_tracing()` Disable tracing.
`ASTBlock`	`ElseIfStatement(ASTBlock previousBlock, boolean afterNewline)`
`ASTBlock`	`ElseStatement(ASTBlock previousBlock, boolean afterNewline)`
`void`	`enable_tracing()` Enable tracing.
`void`	`EqualityExpression()`
`void`	`Escape()` Used to catch and process escape sequences in grammatical constructs as escapes outside of VTL are just characters.
`void`	`EscapedDirective()` used to separate the notion of a valid directive that has been escaped, versus something that looks like a directive and is just schmoo.
`void`	`Expression()`
`void`	`False()`
`void`	`FloatingPointLiteral()`
`ParseException`	`generateParseException()` Generate ParseException.
`Directive`	`getDirective(String directive)` This method gets a Directive from the directives Hashtable
`Token`	`getNextToken()` Get the next Token.
`RuntimeServices`	`getRuntimeServices()`
`Token`	`getToken(int index)` Get the specific Token.
`void`	`Identifier()` This method corresponds to variable references in Velocity templates.
`boolean`	`IfStatement(boolean afterNewline)`
`void`	`Index()`
`void`	`IndexParameter()` A Simplified parameter more suitable for an index position: $foo[$index]
`void`	`IntegerLiteral()`
`void`	`IntegerRange()` supports the [n..m] vector generator for use in the #foreach() to generate measured ranges w/o needing explicit support from the app/servlet
`boolean`	`isDirective(String directive)` This method finds out of the directive exists in the directives Map.
`void`	`Map()` for creating a map in a #set #set($foo = {$foo : $bar, $blargh : $thingy})
`void`	`Method()` This method has yet to be fully implemented but will allow arbitrarily nested method calls
`void`	`MultiplicativeExpression()`
`void`	`ObjectArray()`
`void`	`Parameter()` This method has yet to be fully implemented but will allow arbitrarily nested method calls
`SimpleNode`	`parse(Reader reader, Template template)` This was also added to allow parsers to be re-usable.
`void`	`PrimaryExpression()`
`SimpleNode`	`process()` This method is what starts the whole parsing process.
`void`	`Reference()`
`void`	`ReInit(CharStream stream)` Reinitialise.
`void`	`ReInit(ParserTokenManager tm)` Reinitialise.
`void`	`RelationalExpression()`
`boolean`	`SetDirective(boolean afterNewline)` Currently support both types of set : #set( expr ) #set expr
`boolean`	`Statement(boolean afterNewline)` These are the types of statements that are acceptable in Velocity templates.
`void`	`StringLiteral()`
`boolean`	`Text()` This method is responsible for allowing all non-grammar text to pass through unscathed.
`void`	`Textblock()`
`static void`	`trace(String message)` Our own trace method.
`void`	`True()`
`void`	`UnaryExpression()`
`void`	`Word()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - jjtree
```
protected JJTParserState jjtree
```
  - currentTemplate
```
public Template currentTemplate
```
    Current template we are parsing. Passed to us in parse()
  - strictEscape
```
public boolean strictEscape
```
    Set to true if the property RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE is set to true
  - token_source
```
public ParserTokenManager token_source
```
    Generated Token Manager.
  - token
```
public Token token
```
    Current token.
  - jj_nt
```
public Token jj_nt
```
    Next token.
- Constructor Detail
  - Parser
```
public Parser(RuntimeServices rs)
```
    This constructor was added to allow the re-use of parsers. The normal constructor takes a single argument which an InputStream. This simply creates a re-usable parser object, we satisfy the requirement of an InputStream by using a newline character as an input stream.
  - Parser
```
public Parser(CharStream stream)
```
    Constructor with user supplied CharStream.
  - Parser
```
public Parser(ParserTokenManager tm)
```
    Constructor with generated Token Manager.
- Method Detail
  - trace
```
public static void trace(String message)
```
    Our own trace method. Use sparsingly in production, since each and every call will introduce an execution branch and slow down parsing.
  - getRuntimeServices
```
public RuntimeServices getRuntimeServices()
```
  - parse
```
public SimpleNode parse(Reader reader,
                        Template template)
                 throws ParseException
```
    This was also added to allow parsers to be re-usable. Normal JavaCC use entails passing an input stream to the constructor and the parsing process is carried out once. We want to be able to re-use parsers: we do this by adding this method and re-initializing the lexer with the new stream that we want parsed.
    
    Throws:
    
    ParseException
  - getDirective
```
public Directive getDirective(String directive)
```
    This method gets a Directive from the directives Hashtable
  - isDirective
```
public boolean isDirective(String directive)
```
    This method finds out of the directive exists in the directives Map.
  - process
```
public final SimpleNode process()
                         throws ParseException
```
    This method is what starts the whole parsing process. After the parsing is complete and the template has been turned into an AST, this method returns the root of AST which can subsequently be traversed by a visitor which implements the ParserVisitor interface which is generated automatically by JavaCC
    
    Throws:
    
    ParseException
  - Statement
```
public final boolean Statement(boolean afterNewline)
                        throws ParseException
```
    These are the types of statements that are acceptable in Velocity templates.
    
    Throws:
    
    ParseException
  - EscapedDirective
```
public final void EscapedDirective()
                            throws ParseException
```
    used to separate the notion of a valid directive that has been escaped, versus something that looks like a directive and is just schmoo. This is important to do as a separate production that creates a node, because we want this, in either case, to stop the further parsing of the Directive() tree.
    
    Throws:
    
    ParseException
  - Escape
```
public final void Escape()
                  throws ParseException
```
    Used to catch and process escape sequences in grammatical constructs as escapes outside of VTL are just characters. Right now we have both this and the EscapeDirective() construction because in the EscapeDirective() case, we want to suck in the # and here we don't. We just want the escapes to render correctly
    
    Throws:
    
    ParseException
  - Comment
```
public final boolean Comment()
                      throws ParseException
```
    Throws:
    
    ParseException
  - Textblock
```
public final void Textblock()
                     throws ParseException
```
    Throws:
    
    ParseException
  - FloatingPointLiteral
```
public final void FloatingPointLiteral()
                                throws ParseException
```
    Throws:
    
    ParseException
  - IntegerLiteral
```
public final void IntegerLiteral()
                          throws ParseException
```
    Throws:
    
    ParseException
  - StringLiteral
```
public final void StringLiteral()
                         throws ParseException
```
    Throws:
    
    ParseException
  - Identifier
```
public final void Identifier()
                      throws ParseException
```
    This method corresponds to variable references in Velocity templates. The following are examples of variable references that may be found in a template: $foo $bar
    
    Throws:
    
    ParseException
  - Word
```
public final void Word()
                throws ParseException
```
    Throws:
    
    ParseException
  - DirectiveArg
```
public final int DirectiveArg()
                       throws ParseException
```
    Supports the arguments for the Pluggable Directives
    
    Throws:
    
    ParseException
  - DirectiveAssign
```
public final void DirectiveAssign()
                           throws ParseException
```
    Throws:
    
    ParseException
  - Directive
```
public final boolean Directive(boolean afterNewline)
                        throws ParseException
```
    Supports the Pluggable Directives #foo( arg+ )
    
    Returns:
    
    true if ends with a newline
    
    Throws:
    
    ParseException
  - Map
```
public final void Map()
               throws ParseException
```
    for creating a map in a #set #set($foo = {$foo : $bar, $blargh : $thingy})
    
    Throws:
    
    ParseException
  - ObjectArray
```
public final void ObjectArray()
                       throws ParseException
```
    Throws:
    
    ParseException
  - IntegerRange
```
public final void IntegerRange()
                        throws ParseException
```
    supports the [n..m] vector generator for use in the #foreach() to generate measured ranges w/o needing explicit support from the app/servlet
    
    Throws:
    
    ParseException
  - IndexParameter
```
public final void IndexParameter()
                          throws ParseException
```
    A Simplified parameter more suitable for an index position: $foo[$index]
    
    Throws:
    
    ParseException
  - Parameter
```
public final void Parameter()
                     throws ParseException
```
    This method has yet to be fully implemented but will allow arbitrarily nested method calls
    
    Throws:
    
    ParseException
  - Method
```
public final void Method()
                  throws ParseException
```
    This method has yet to be fully implemented but will allow arbitrarily nested method calls
    
    Throws:
    
    ParseException
  - Index
```
public final void Index()
                 throws ParseException
```
    Throws:
    
    ParseException
  - Reference
```
public final void Reference()
                     throws ParseException
```
    Throws:
    
    ParseException
  - True
```
public final void True()
                throws ParseException
```
    Throws:
    
    ParseException
  - False
```
public final void False()
                 throws ParseException
```
    Throws:
    
    ParseException
  - Text
```
public final boolean Text()
                   throws ParseException
```
    This method is responsible for allowing all non-grammar text to pass through unscathed.
    
    Returns:
    
    true if last read token was a newline
    
    Throws:
    
    ParseException
  - IfStatement
```
public final boolean IfStatement(boolean afterNewline)
                          throws ParseException
```
    Throws:
    
    ParseException
  - ElseStatement
```
public final ASTBlock ElseStatement(ASTBlock previousBlock,
                                    boolean afterNewline)
                             throws ParseException
```
    Throws:
    
    ParseException
  - ElseIfStatement
```
public final ASTBlock ElseIfStatement(ASTBlock previousBlock,
                                      boolean afterNewline)
                               throws ParseException
```
    Throws:
    
    ParseException
  - SetDirective
```
public final boolean SetDirective(boolean afterNewline)
                           throws ParseException
```
    Currently support both types of set : #set( expr ) #set expr
    
    Throws:
    
    ParseException
  - Expression
```
public final void Expression()
                      throws ParseException
```
    Throws:
    
    ParseException
  - Assignment
```
public final void Assignment()
                      throws ParseException
```
    Throws:
    
    ParseException
  - ConditionalOrExpression
```
public final void ConditionalOrExpression()
                                   throws ParseException
```
    Throws:
    
    ParseException
  - ConditionalAndExpression
```
public final void ConditionalAndExpression()
                                    throws ParseException
```
    Throws:
    
    ParseException
  - EqualityExpression
```
public final void EqualityExpression()
                              throws ParseException
```
    Throws:
    
    ParseException
  - RelationalExpression
```
public final void RelationalExpression()
                                throws ParseException
```
    Throws:
    
    ParseException
  - AdditiveExpression
```
public final void AdditiveExpression()
                              throws ParseException
```
    Throws:
    
    ParseException
  - MultiplicativeExpression
```
public final void MultiplicativeExpression()
                                    throws ParseException
```
    Throws:
    
    ParseException
  - UnaryExpression
```
public final void UnaryExpression()
                           throws ParseException
```
    Throws:
    
    ParseException
  - PrimaryExpression
```
public final void PrimaryExpression()
                             throws ParseException
```
    Throws:
    
    ParseException
  - ReInit
```
public void ReInit(CharStream stream)
```
    Reinitialise.
  - ReInit
```
public void ReInit(ParserTokenManager tm)
```
    Reinitialise.
  - getNextToken
```
public final Token getNextToken()
```
    Get the next Token.
  - getToken
```
public final Token getToken(int index)
```
    Get the specific Token.
  - generateParseException
```
public ParseException generateParseException()
```
    Generate ParseException.
  - enable_tracing
```
public final void enable_tracing()
```
    Enable tracing.
  - disable_tracing
```
public final void disable_tracing()
```
    Disable tracing.

Class Parser

Field Summary

Fields inherited from interface org.apache.velocity.runtime.parser.node.ParserTreeConstants

Fields inherited from interface org.apache.velocity.runtime.parser.ParserConstants

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

jjtree

currentTemplate

strictEscape

token_source

token

jj_nt

Constructor Detail

Parser

Parser

Parser

Method Detail

trace

getRuntimeServices

parse

getDirective

isDirective

process

Statement

EscapedDirective

Escape

Comment

Textblock

FloatingPointLiteral

IntegerLiteral

StringLiteral

Identifier

Word

DirectiveArg

DirectiveAssign

Directive

Map

ObjectArray

IntegerRange

IndexParameter

Parameter

Method

Index

Reference

True

False

Text

IfStatement

ElseStatement

ElseIfStatement

SetDirective

Expression

Assignment

ConditionalOrExpression

ConditionalAndExpression

EqualityExpression

RelationalExpression

AdditiveExpression

MultiplicativeExpression

UnaryExpression

PrimaryExpression

ReInit

ReInit

getNextToken

getToken

generateParseException

enable_tracing

disable_tracing