Uses of Class
com.go.tea.parsetree.Expression

Packages that use Expression
com.go.tea.parsetree   
 

Uses of Expression in com.go.tea.parsetree
 

Subclasses of Expression in com.go.tea.parsetree
 class AndExpression
          AndExpression defines a logical "and" operation with short-circuit semantics.
 class ArithmeticExpression
          ArithmeticExpression defines addition, subtraction, multiplication, division or remainder operations.
 class ArrayLookup
          An ArrayLookup can access indexed properties on objects.
 class BinaryExpression
          A BinaryExpression contains a left expression, a right expression and an operator.
 class BinaryLogicalExpression
           
 class BooleanLiteral
          BooleanLiterals can only have one of two values, true or false.
 class CallExpression
           
 class ConcatenateExpression
          A ConcatenateExpression takes two Expressions, converts their values to strings and returns a new string with the concatenated result.
 class FunctionCallExpression
          A CallExpression to a function.
 class Literal
          A literal is an expression that has a constant value.
 class Lookup
          A Lookup can access properties on objects.
 class NegateExpression
          NegateExpression is a simple unary expression that calculates the negative value of an expression.
 class NewArrayExpression
          An expression that evaluates to a new array or Map of values.
 class NotExpression
          NotExpression is a simple unary expression that calculates the logical "not" value of an expression.
 class NullLiteral
          A Literal representing the null Object.
 class NumberLiteral
          Base class for all Literals that have a numeric type.
 class OrExpression
          OrExpression defines a logical "or" operation with short-circuit semantics.
 class ParenExpression
          A ParenExpression is a thin wrapper around an Expression that was delimited by parenthesis in the source code.
 class RelationalExpression
          RelationalExpression defines seven operations, "==", "!=", "<", ">", "<=" ">=" and "isa".
 class StringLiteral
          A StringLiteral is a constant string of characters, usually delimited by quotes in a source file.
 class TemplateCallExpression
          A CallExpression to a template is specified in a template with the "call" keyword.
 class VariableRef
          VariableRef is used to reference declared Variables.
 

Methods in com.go.tea.parsetree that return Expression
 Expression ParenExpression.getExpression()
           
 Expression ReturnStatement.getExpression()
          Returns the expression to return or null if void is returned.
protected  Expression TreeMutator.visitExpression(Expression expr)
          All expressions pass through this method to ensure the expression's type is preserved.
 Expression BinaryExpression.getLeftExpression()
           
 Expression BinaryExpression.getRightExpression()
           
 Expression Lookup.getExpression()
           
 Expression NegateExpression.getExpression()
           
 Expression RelationalExpression.getRightExpression()
           
 Expression NotExpression.getExpression()
           
 Expression ExpressionStatement.getExpression()
           
 Expression ArrayLookup.getExpression()
           
 Expression ArrayLookup.getLookupIndex()
           
 Expression AssignmentStatement.getRValue()
           
 Expression[] ExpressionList.getExpressions()
           
 Expression IfStatement.getCondition()
           
 Expression ForeachStatement.getRange()
           
 Expression ForeachStatement.getEndRange()
          Returns null if this foreach statement iterates over an array/collection instead of an integer range of values.
 

Methods in com.go.tea.parsetree with parameters of type Expression
 void ParenExpression.setExpression(Expression expr)
           
 void ReturnStatement.setExpression(Expression expr)
           
 java.lang.Object TreeMutator.visit(Expression node)
           
protected  Expression TreeMutator.visitExpression(Expression expr)
          All expressions pass through this method to ensure the expression's type is preserved.
 void BinaryExpression.setLeftExpression(Expression left)
           
 void BinaryExpression.setRightExpression(Expression right)
           
 void Lookup.setExpression(Expression expr)
           
 void NegateExpression.setExpression(Expression expr)
           
 void NotExpression.setExpression(Expression expr)
           
 void ExpressionStatement.setExpression(Expression expr)
           
 void ArrayLookup.setExpression(Expression expr)
           
 void ArrayLookup.setLookupIndex(Expression lookupIndex)
           
 void AssignmentStatement.setRValue(Expression rvalue)
           
 java.lang.Object TreeWalker.visit(Expression node)
           
 java.lang.Object NodeVisitor.visit(Expression node)
           
 void IfStatement.setCondition(Expression condition)
           
 void ForeachStatement.setRange(Expression range)
           
 void ForeachStatement.setEndRange(Expression endRange)
           
 

Constructors in com.go.tea.parsetree with parameters of type Expression
ParenExpression(SourceInfo info, Expression expr)
           
ReturnStatement(SourceInfo info, Expression expr)
           
ReturnStatement(Expression expr)
          Construct a ReturnStatement from just an expression and its SourceInfo.
BinaryExpression(SourceInfo info, Token operator, Expression left, Expression right)
           
ArithmeticExpression(SourceInfo info, Token operator, Expression left, Expression right)
           
Lookup(SourceInfo info, Expression expr, Token dot, Name lookupName)
           
BinaryLogicalExpression(SourceInfo info, Token operator, Expression left, Expression right)
           
NegateExpression(SourceInfo info, Expression expr)
           
RelationalExpression(SourceInfo info, Token operator, Expression left, Expression right)
           
RelationalExpression(SourceInfo info, Token operator, Expression left, TypeName typeName)
          Used to construct an "isa" RelationalExpression.
NotExpression(SourceInfo info, Expression expr)
           
ExpressionStatement(Expression expr)
           
ArrayLookup(SourceInfo info, Expression expr, Token lookupToken, Expression lookupIndex)
           
AssignmentStatement(SourceInfo info, VariableRef lvalue, Expression rvalue)
           
AndExpression(SourceInfo info, Token token, Expression left, Expression right)
           
OrExpression(SourceInfo info, Token token, Expression left, Expression right)
           
ExpressionList(SourceInfo info, Expression[] elements)
           
IfStatement(SourceInfo info, Expression condition, Block thenPart)
           
IfStatement(SourceInfo info, Expression condition, Block thenPart, Block elsePart)
           
ForeachStatement(SourceInfo info, VariableRef loopVar, Expression range, Expression endRange, boolean reverse, Block body)
           
ConcatenateExpression(SourceInfo info, Token operator, Expression left, Expression right)