SetExpr ::= "(" Expression ( "," Expression )* ")"
333627
final public List SetExpr() throws ParseException {
                   List ans = new ArrayList(); Selector elem;
    jj_consume_token(11);
    elem = Expression();
                              ans.add(elem);
    label_1:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 13:
        ;
        break;
      default:
        jj_la1[14] = jj_gen;
        break label_1;
      }
      jj_consume_token(13);
      elem = Expression();
                                ans.add(elem);
    }
    jj_consume_token(12);
    {if (true) return ans;}
    throw new Error("Missing return statement in function");
  }
808382
public function setExpression(Expression $expression)
    {
        $this->map['expressions']->set($expression->hashCode(), $expression->setBuilder($this));
        
        return $this;
    }
849458
def _create_update_expression():
    
    ine = (
        Word("if_not_exists")
        + Suppress("(")
        + var
        + Suppress(",")
        + var_val
        + Suppress(")")
    )
    list_append = (
        Word("list_append")
        + Suppress("(")
        + var_val
        + Suppress(",")
        + var_val
        + Suppress(")")
    )
    fxn = Group(ine | list_append).setResultsName("set_function")
    # value has to come before var to prevent parsing TRUE/FALSE as variables
    path = value | fxn | var
    set_val = (path + oneOf("+ -") + path) | path
    set_cmd = Group(var + Suppress("=") + set_val)
    set_expr = (Suppress(upkey("set")) + delimitedList(set_cmd)).setResultsName(
        "set_expr"
    )
    add_expr = (
        Suppress(upkey("add")) + delimitedList(Group(var + value))
    ).setResultsName("add_expr")
    delete_expr = (
        Suppress(upkey("delete")) + delimitedList(Group(var + value))
    ).setResultsName("delete_expr")
    remove_expr = (Suppress(upkey("remove")) + delimitedList(var)).setResultsName(
        "remove_expr"
    )
    return OneOrMore(set_expr | add_expr | delete_expr | remove_expr).setResultsName(
        "update"
    )
76300
def p_expression_plus(self, p):
        ''
        p[0] = Plus(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
361542
public String getValueAsString(Expression expr) throws PageException {
	expr.writeOut(this, Expression.MODE_REF);
	return Caster.toString(stack.pop());
    }
398256
public final void conditionalExpression() throws RecognitionException {
		int conditionalExpression_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1138:5: ( conditionalOrExpression ( '?' expression ':' expression )? )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1138:9: conditionalOrExpression ( '?' expression ':' expression )?
			{
			pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression5042);
			conditionalOrExpression();
			state._fsp--;
			if (state.failed) return;
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1138:33: ( '?' expression ':' expression )?
			int alt142=2;
			int LA142_0 = input.LA(1);
			if ( (LA142_0==57) ) {
				alt142=1;
			}
			switch (alt142) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1138:35: '?' expression ':' expression
					{
					match(input,57,FOLLOW_57_in_conditionalExpression5046); if (state.failed) return;
					pushFollow(FOLLOW_expression_in_conditionalExpression5048);
					expression();
					state._fsp--;
					if (state.failed) return;
					match(input,51,FOLLOW_51_in_conditionalExpression5050); if (state.failed) return;
					pushFollow(FOLLOW_expression_in_conditionalExpression5052);
					expression();
					state._fsp--;
					if (state.failed) return;
					}
					break;

			}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 110, conditionalExpression_StartIndex); }

		}
	}
233507
def _set_expressions(self, expressions):
        """"""
        self.expressions = {}
        for key, item in expressions.items():
            self.expressions[key] = {'function': item}
849282
@Override
	protected void setBody(JvmExecutable executable, XExpression expression) {
		final GenerationContext context = getContext(
				EcoreUtil2.getContainerOfType(executable, JvmType.class));
		this.typeBuilder.removeExistingBody(executable);
		this.associator.associateLogicalContainer(expression, executable);
		if (expression != null) {
			if (context.getParentContext() == null) {
				context.getPostFinalizationElements().add(() -> {
					initializeLocalTypes(context, executable, expression);
				});
			} else {
				initializeLocalTypes(context, executable, expression);
			}
		} else {
			initializeLocalTypes(context, executable, expression);
		}
	}
94623
private static final ExpressionTree parseToTree(String expression) throws InvalidExpressionException {

        ExpressionParser parser = new ExpressionParser();
        parser.parse(expression);

        return new ExpressionTree(parser.getVar(), parser.getTokens());
    }
1053938
@Nonnull
  public CSSDeclaration setExpression (@Nonnull final CSSExpression aExpression)
  {
    m_aExpression = ValueEnforcer.notNull (aExpression, "Expression");
    return this;
  }
841245
private static void renderExpr(boolean first, CodeBlock.Builder code, Node<PluralType> expr) {
    Iterator<Node<PluralType>> iter = expr.asStruct().nodes().iterator();

    // Parse out the two forms of operand expressions we support:
    //
    //    n = <rangelist>
    //    n % m = <rangelist>
    //
    Atom<PluralType> operand = iter.next().asAtom();
    Atom<PluralType> modop = null;
    Atom<PluralType> relop = iter.next().asAtom();
    if (relop.type() == PluralType.MODOP) {
      modop = relop;
      relop = iter.next().asAtom();
    }

    String var = (String)operand.value();
    List<Node<PluralType>> rangeList = iter.next().asStruct().nodes();

    boolean decimalsZero = false;
    if (var.equals("n") && modop != null) {
      // We're applying mod to the 'n' operand, we must also ensure that
      // decimal value == 0.
      decimalsZero = true;
    }
    
    // If this is the first expression, define the variable; otherwise reuse it.
    String fmt = "zz = o.$L()";
    if (first) {
      fmt = "long " + fmt;
    }

    // Mod operations modify the operand before assignment.
    if (modop != null) {
      fmt += " % $LL";
    }

    // Emit the expression.
    if (modop != null) {
      code.addStatement(fmt, var, (int)modop.value());
    } else {
      code.addStatement(fmt, var);
    }

    renderExpr(code, rangeList, relop.value().equals("="), decimalsZero);
  }
623397
function (expr, cb, joinCond) {
            expr = (isUndefined(expr) || isNull(expr) || (Array.isArray(expr) && !expr.length)) ? null : expr;
            if (expr && cb) {
                return new BooleanExpression(joinCond || "AND", this._filterExpr(expr, null, joinCond), this._filterExpr(cb, null, joinCond));
            } else if (cb) {
                expr = cb;
            }
            if (isInstanceOf(expr, Expression)) {
                if (isInstanceOf(expr, NumericExpression, StringExpression)) {
                    throw new QueryError("Invalid SQL Expression type : " + expr);
                }
                return expr;
            } else if (Array.isArray(expr)) {
                if (expr.length) {
                    var first = expr[0];
                    if (isString(first)) {
                        return new PlaceHolderLiteralString(first, expr.slice(1), true);
                    } else if (Expression.isConditionSpecifier(expr)) {
                        return BooleanExpression.fromValuePairs(expr, joinCond);
                    } else {
                        return BooleanExpression.fromArgs([joinCond || "AND"].concat(expr.map(function (e) {
                            return this._filterExpr(e, null, "AND");
                        }, this)));
                    }
                }
            } else if (isFunction(expr)) {
                return this._filterExpr(expr.call(sql, sql), null, joinCond);
            } else if (isBoolean(expr)) {
                return new BooleanExpression("NOOP", expr);
            } else if (isString(expr)) {
                return this.stringToIdentifier(expr);
            } else if (isInstanceOf(expr, LiteralString)) {
                return new LiteralString("(" + expr + ")");
            } else if (isHash(expr)) {
                return BooleanExpression.fromValuePairs(expr, joinCond);
            } else {
                throw new QueryError("Invalid filter argument");
            }
        }
928938
function Expression(expr, config) {

	// Properties
	this.helper = null;
	this.context = null;
	this.escaped = null;
	this.args = null;
	this.callback = null;

	// Parse & config
	extend(this, Expression.parse(expr));
	extend(this, config);

	// Unless otherwise specified, blocks are not textOnly
	if ((typeof this.textOnly) === 'undefined') {
		this.textOnly = !this.isBlock;
	}
}
1208683
public static Object execExpr(ExprResolver exprResolver, String expression) {

        try {
            // 返回输出的内容
            return exprResolver.executeExpr(expression);

        } catch (Exception e) {

            // 输出日志
            if (logger.isDebugEnabled()) {
                logger.debug("Can't resolving expression: " + expression, e);
            }
        }

        return null;
    }
583058
void setDefaultExpression(int columnIndex, Expression def) {

        ColumnSchema column = getColumn(columnIndex);

        column.setDefaultExpression(def);
        setColumnTypeVars(columnIndex);
    }
487253
private static boolean isTemplate(String expression) {
		return expression.contains(PARSER_CONTEXT.getExpressionPrefix())
				&& expression.contains(PARSER_CONTEXT.getExpressionSuffix());
	}
1008070
def p_expression_uxor(self, p):
        ''
        p[0] = Uxor(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))