Lombok.ast - v0.2

lombok.ast.grammar
Class StatementsActions

java.lang.Object
  extended by org.parboiled.BaseActions<Node>
      extended by lombok.ast.grammar.StatementsActions
All Implemented Interfaces:
org.parboiled.ContextAware<Node>

public class StatementsActions
extends org.parboiled.BaseActions<Node>


Field Summary
protected  Source source
           
 
Constructor Summary
StatementsActions(Source source)
           
 
Method Summary
 Node addLocalVariableModifiers(Node variableDefinition, Node modifiers)
           
 Node createAlternateConstructorInvocation(Node typeArguments, Node arguments)
           
 Node createAssertStatement(Node assertion, Node message)
           
 Node createBasicFor(Node init, Node condition, Node update, Node statement)
           
 Node createBlock(List<Node> statements)
           
 Node createBreak(Node label)
           
 Node createCaseStatement(Node condition)
           
 Node createCatch(Node modifiers, Node type, Node varName, Node body)
           
 Node createContinue(Node label)
           
 Node createDefaultStatement(org.parboiled.Node<Node> defaultStatement)
           
 Node createDoStatement(Node condition, Node statement)
           
 Node createEmptyStatement()
           
 Node createEnhancedFor(org.parboiled.Node<Node> modifiers, Node type, org.parboiled.Node<Node> varDefEntry, Node iterable, Node statement)
           
 Node createExpressionStatement(Node expression)
           
 Node createIfStatement(Node condition, Node statement, Node elseStatement)
           
 Node createLabelledStatement(List<Node> labelNames, Node statement)
           
 Node createReturn(Node value)
           
 Node createStatementExpressionList(Node head, List<Node> tail)
           
 Node createSuperConstructorInvocation(org.parboiled.Node<Node> dot, Node qualifier, Node typeArguments, Node arguments)
           
 Node createSwitchStatement(Node condition, Node body)
           
 Node createSynchronizedStatement(Node lock, Node body)
           
 Node createThrow(Node throwable)
           
 Node createTryStatement(Node body, List<Node> catches, Node finallyBody)
           
 Node createVariableDeclaration(Node definition)
           
 Node createWhileStatement(Node condition, Node statement)
           
 
Methods inherited from class org.parboiled.BaseActions
character, character, chars, chars, currentChar, getContext, hasError, inPredicate, lastChar, lastNode, lastText, lastValue, node, nodeByLabel, nodes, nodesByLabel, nodeSuppressed, prevChar, prevEnd, prevStart, prevText, prevValue, set, set, setContext, text, text, texts, texts, value, value, value, values, values
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

source

protected final Source source
Constructor Detail

StatementsActions

public StatementsActions(Source source)
Method Detail

createBlock

public Node createBlock(List<Node> statements)

createEmptyStatement

public Node createEmptyStatement()

createLabelledStatement

public Node createLabelledStatement(List<Node> labelNames,
                                    Node statement)

createIfStatement

public Node createIfStatement(Node condition,
                              Node statement,
                              Node elseStatement)

createAssertStatement

public Node createAssertStatement(Node assertion,
                                  Node message)

createSwitchStatement

public Node createSwitchStatement(Node condition,
                                  Node body)

createCaseStatement

public Node createCaseStatement(Node condition)

createDefaultStatement

public Node createDefaultStatement(org.parboiled.Node<Node> defaultStatement)

createWhileStatement

public Node createWhileStatement(Node condition,
                                 Node statement)

createDoStatement

public Node createDoStatement(Node condition,
                              Node statement)

createStatementExpressionList

public Node createStatementExpressionList(Node head,
                                          List<Node> tail)

createBasicFor

public Node createBasicFor(Node init,
                           Node condition,
                           Node update,
                           Node statement)

createEnhancedFor

public Node createEnhancedFor(org.parboiled.Node<Node> modifiers,
                              Node type,
                              org.parboiled.Node<Node> varDefEntry,
                              Node iterable,
                              Node statement)

createBreak

public Node createBreak(Node label)

createContinue

public Node createContinue(Node label)

createReturn

public Node createReturn(Node value)

createThrow

public Node createThrow(Node throwable)

createSynchronizedStatement

public Node createSynchronizedStatement(Node lock,
                                        Node body)

createCatch

public Node createCatch(Node modifiers,
                        Node type,
                        Node varName,
                        Node body)

createTryStatement

public Node createTryStatement(Node body,
                               List<Node> catches,
                               Node finallyBody)

addLocalVariableModifiers

public Node addLocalVariableModifiers(Node variableDefinition,
                                      Node modifiers)

createAlternateConstructorInvocation

public Node createAlternateConstructorInvocation(Node typeArguments,
                                                 Node arguments)

createSuperConstructorInvocation

public Node createSuperConstructorInvocation(org.parboiled.Node<Node> dot,
                                             Node qualifier,
                                             Node typeArguments,
                                             Node arguments)

createExpressionStatement

public Node createExpressionStatement(Node expression)

createVariableDeclaration

public Node createVariableDeclaration(Node definition)

Lombok.ast - v0.2

Copyright © 2010-2011 The Project Lombok Authors, licensed under the MIT licence.