Parser (Velocity 1.7 API)
Keywords: org.apache.velocity.runtime.parser.Parser class

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.velocity.runtime.parser
Class Parser

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

All Implemented Interfaces:
  ParserConstants, ParserTreeConstants

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.java 928463 2010-03-28 18:11:34Z nbubna $
Author:
  Jason van Zyl, Geir Magnusson Jr., Henning P. Schmiedehausen

Field Summary
`String` | `currentTemplateName` Name of 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.ParserTreeConstants
`JJTADDNODE, JJTANDNODE, JJTASSIGNMENT, JJTBLOCK, JJTCOMMENT, JJTDIRECTIVE, JJTDIVNODE, JJTELSEIFSTATEMENT, JJTELSESTATEMENT, JJTEQNODE, JJTESCAPE, JJTESCAPEDDIRECTIVE, JJTEXPRESSION, JJTFALSE, JJTFLOATINGPOINTLITERAL, JJTGENODE, JJTGTNODE, JJTIDENTIFIER, JJTIFSTATEMENT, JJTINDEX, JJTINTEGERLITERAL, JJTINTEGERRANGE, JJTLENODE, JJTLTNODE, JJTMAP, JJTMETHOD, JJTMODNODE, JJTMULNODE, 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, ALPHANUM_CHAR, BRACKETED_WORD, COLON, COMMA, DEFAULT, DIGIT, DIRECTIVE, DIRECTIVE_CHAR, DIRECTIVE_TERMINATOR, DIVIDE, DOLLAR, DOLLARBANG, DOT, DOUBLE_ESCAPE, DOUBLEDOT, ELSE_DIRECTIVE, ELSEIF_DIRECTIVE, 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_SINGLE_LINE_COMMENT, IN_TEXTBLOCK, INDEX_LBRACKET, INDEX_RBRACKET, 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, LPAREN, MINUS, MODULUS, MULTI_LINE_COMMENT, MULTIPLY, NEWLINE, PLUS, PRE_DIRECTIVE, RBRACKET, RCURLY, REFERENCE, REFERENCE_TERMINATOR, REFINDEX, REFMOD, REFMOD2, REFMOD2_RPAREN, REFMODIFIER, RIGHT_CURLEY, RPAREN, SET_DIRECTIVE, SINGLE_LINE_COMMENT, SINGLE_LINE_COMMENT_START, STRING_LITERAL, TEXT, TEXTBLOCK, tokenImage, TRUE, WHITESPACE, WORD`

Constructor Summary
`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
`void` | `AdditiveExpression()`
`void` | `Assignment()`
`void` | `Comment()`
`void` | `ConditionalAndExpression()`
`void` | `ConditionalOrExpression()`
`SimpleNode` | `Directive()` Supports the Pluggable Directives #foo( arg+ )
`int` | `DirectiveArg()` Supports the arguments for the Pluggable Directives
`void` | `disable_tracing()` Disable tracing.
`void` | `ElseIfStatement()`
`void` | `ElseStatement()`
`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.
`Token` | `getToken(int index)` Get the specific Token.
`void` | `Identifier()` This method corresponds to variable references in Velocity templates.
`void` | `IfStatement()`
`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, String templateName)` 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()`
`void` | `SetDirective()` Currently support both types of set : #set( expr ) #set expr
`void` | `Statement()` These are the types of statements that are acceptable in Velocity templates.
`void` | `StringLiteral()`
`void` | `Text()` This method is responsible for allowing all non-grammar text to pass through unscathed.
`void` | `Textblock()`
`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

### currentTemplateName

    public String currentTemplateName

  Name of 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

### parse

    public SimpleNode parse(Reader reader,
                            String templateName)
                     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 void Statement()
                         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 void 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`

### Directive

    public final SimpleNode Directive()
                               throws ParseException

  Supports the Pluggable Directives #foo( arg+ )

  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 void Text()
                    throws ParseException

  This method is responsible for allowing all non-grammar text to pass through unscathed.

  Throws:
    `ParseException`

### IfStatement

    public final void IfStatement()
                           throws ParseException

  Throws:
    `ParseException`

### ElseStatement

    public final void ElseStatement()
                             throws ParseException

  Throws:
    `ParseException`

### ElseIfStatement

    public final void ElseIfStatement()
                               throws ParseException

  Throws:
    `ParseException`

### SetDirective

    public final void SetDirective()
                            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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2000-2010 Apache Software Foundation. All Rights Reserved.