Return a compiled MVEL expression.

@return compiled MVEL expression
169723
protected Serializable getCompiledExpression() {
        if (compiledExpression == null) {
            compiledExpression = MVEL.compileExpression(getExpression(), PARSER_CONTEXT);
        }
        return compiledExpression;
    }
889481
public function NewObjectExpression()
    {
        $this->match(Lexer::T_NEW);
        $this->match(Lexer::T_IDENTIFIER);

        $token      = $this->lexer->token;
        $className  = $token['value'];

        if (strrpos($className, ':') !== false) {
            list($namespaceAlias, $simpleClassName) = explode(':', $className);

            $className = $this->em->getConfiguration()
                ->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
        }

        $this->match(Lexer::T_OPEN_PARENTHESIS);

        $args[] = $this->NewObjectArg();

        while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
            $this->match(Lexer::T_COMMA);

            $args[] = $this->NewObjectArg();
        }

        $this->match(Lexer::T_CLOSE_PARENTHESIS);

        $expression = new AST\NewObjectExpression($className, $args);

        // Defer NewObjectExpression validation
        $this->deferredNewObjectExpressions[] = array(
            'token'        => $token,
            'expression'   => $expression,
            'nestingLevel' => $this->nestingLevel,
        );

        return $expression;
    }
293494
final public ReturnExpressionBuilder<T> returnExp() {
    final int sourceLineNumber = builder.getSourceLineNumber();
    return new ReturnExpressionBuilder<T>(new ExpressionHandler<T>() {
      public T handleExpression(Expression e) {
        return statementHandler().handleStatement(new ReturnStatement(sourceLineNumber, e));
      }
    });
  }
1154335
public String getExpressionString() {
        StringBuffer buf = new StringBuffer();
        buf.append(mPrefix.getExpressionString());

        for (int i = 0; mSuffixes != null && i < mSuffixes.size(); i++) {
            ValueSuffix suffix = (ValueSuffix) mSuffixes.get(i);
            buf.append(suffix.getExpressionString());
        }

        return buf.toString();
    }
673672
protected XExpression _generate(XVariableDeclaration varDeclaration, IAppendable it, IExtraLanguageGeneratorContext context) {
		final String name = it.declareUniqueNameVariable(varDeclaration, varDeclaration.getName());
		it.append(name);
		it.append(" = "); //$NON-NLS-1$
		if (varDeclaration.getRight() != null) {
			generate(varDeclaration.getRight(), it, context);
		} else if (varDeclaration.getType() != null) {
			it.append(toDefaultValue(varDeclaration.getType()));
		} else {
			it.append("None"); //$NON-NLS-1$
		}
		if (context.getExpectedExpressionType() != null) {
			it.newLine();
			it.append("return ").append(name); //$NON-NLS-1$
		}
		return varDeclaration;
	}
645101
public String getExpressionString() {
        StringBuffer buf = new StringBuffer();
        buf.append("(");
        if (mOperator != null) {
            buf.append(mOperator.getOperatorSymbol());
            buf.append(" ");
        } else {
            for (int i = 0; i < mOperators.size(); i++) {
                UnaryOperator operator = (UnaryOperator) mOperators.get(i);
                buf.append(operator.getOperatorSymbol());
                buf.append(" ");
            }
        }
        buf.append(mExpression.getExpressionString());
        buf.append(")");
        return buf.toString();
    }
1368063
public function getExpression()
    {
        if ($this->expression) {
            return $this->expression;
        }

        $class = __NAMESPACE__ . '\\' . ucfirst($this->getName()) . '\\' . ucfirst($this->getName()) . 'Expression';

        if (!class_exists($class)) {
            $class = __NAMESPACE__ . '\\' . 'QueryExpression';
        }

        return $this->expression = new $class($this);
    }
753357
public Expression makeEscapingExpression() {
        return new ExpressionSupport() {
            public String getExpressionText() {
                return expressionText;
            }

            public Object evaluate(JellyContext context) {
                Object[] args = evaluateArguments(context);
                args = Stapler.htmlSafeArguments(args);
                return format(args);
            }
        };
    }
132637
public function getExpression()
    {
        return \sprintf('%s %s %s %s %s', $this->minute, $this->hour, $this->dayOfMonth, $this->month, $this->dayOfWeek);
    }
640927
@Override
	public Expression getValueExpression() {
		return ifThenElse(equalTo(count, literal(0L)), nullOf(getResultType()), div(sum, count));
	}
809166
public ITreeAppendable compile(XBlockExpression expr, ITreeAppendable b, LightweightTypeReference expectedReturnType) {
		final boolean isPrimitiveVoidExpected = expectedReturnType.isPrimitiveVoid(); 
		final boolean isPrimitiveVoid = isPrimitiveVoid(expr);
		final boolean earlyExit = isEarlyExit(expr);
		final boolean isImplicitReturn = !isPrimitiveVoidExpected && !isPrimitiveVoid && !earlyExit;
		final EList<XExpression> expressions = expr.getExpressions();
		for (int i = 0; i < expressions.size(); i++) {
			XExpression ex = expressions.get(i);
			if (i < expressions.size() - 1) {
				internalToJavaStatement(ex, b.trace(ex, true), false);
			} else {
				internalToJavaStatement(ex, b.trace(ex, true), isImplicitReturn);
				if (isImplicitReturn) {
					b.newLine().append("return (");
					internalToConvertedExpression(ex, b, expectedReturnType);
					b.append(");");
				}
			}
		}
		return b;
	}
975680
protected function compileExpressions()
    {
        if (count($this->expressions) === 0) {
            throw new BadMethodCallException('Can\'t compile an empty expression');
        }
        if (count($this->expressions) === 1) {
            return reset($this->expressions);
        }

        $parts = [];

        foreach ($this->expressions as $expr) {
            $expr = '(?:' . $expr . ')';

            $parts[] = $expr;
        }

        return '(?:' . implode('|', $parts) . ')';
    }
1344892
protected synchronized Expression getParsedExpression() {
        if (parsedExpression == null) {
            try {
                parsedExpression = EXPRESSION_PARSER.parseExpression(getExpression());
            }
            catch (ParseException e) {
                throw new IllegalArgumentException("[" + getExpression() + "] is not a valid SpEL expression", e);
            }
        }
        return parsedExpression;
    }
89012
public AbstractExpression getFirstArgument() {
        if (m_left != null) {
            assert(m_args == null);
            return m_left;
        }
        if (m_args != null && m_args.size() > 0) {
            assert(m_left == null && m_right == null);
            return m_args.get(0);
        }
        return null;
    }
471653
public JCExpression variableInitializer() {
        return token.kind == LBRACE ? arrayInitializer(token.pos, null) : parseExpression();
    }
1066351
public Formula getFormula() {
		Reagent[] reagents = new Reagent[] {KEY, VALUE, PARENT, EXPRESSION};
		final Formula rslt = new SimpleFormula(getClass(), reagents);
		return rslt;
	}
1338038
public Expression asCheap() {
    if (isCheap()) {
      return this;
    }
    return new Expression(resultType, features.plus(Feature.CHEAP)) {
      @Override
      protected void doGen(CodeBuilder adapter) {
        Expression.this.gen(adapter);
      }
    };
  }