expression : expression GT expression
325605
def p_expression_greaterthan(self, p):
        ''
        p[0] = GreaterThan(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
258992
public static Expression<?> toExpression(Object o) {
        if (o instanceof Expression) {
            return (Expression<?>) o;
        } else {
            return ConstantImpl.create(o);
        }
    }
1156049
def p_expression_unot(self, p):
        ''
        p[0] = Unot(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
1335467
def p_expression_unor(self, p):
        ''
        p[0] = Unor(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
926282
public Expression<Double> gt(double value) {
		String valueString = "'" + value + "'";
		return new Expression<Double>(this, Operation.gt, valueString);
	}
713057
def p_expression_lessthan(self, p):
        ''
        p[0] = LessThan(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
568505
def gt(self, value):
        
        self.op = '>'
        self.negate_op = '<='
        self.value = self._value(value)
        return self
13295
function (expression, types) {
        var args = types.split(" | "),
            i, len, found = false;

        for (i=0, len=args.length; i < len && !found && expression.hasNext(); i++) {
            found = this.isType(expression, args[i]);
        }

        return found;
    }
73937
public static <E extends Comparable<? super E>> AbstractGroupExpression<E, E> max(Expression<E> expression) {
        return new GMax<E>(expression);
    }
1048059
function M(a, b) {
	var e = Expression(a, b || M.Global);
	return e;
}
514083
def p_expression_sra(self, p):
        ''
        p[0] = Sra(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
29553
public static ExpressionModel computeExpression(String expression) {
		
		// Si l'expression est vide
		if(expression == null || expression.trim().length() == 0) {
			
			// On retourne null
			return null;
		}
		
		// On Instancie un model d'expression
		ExpressionModel expressionModel = new ExpressionModel(expression.trim());
		
		// Index de l'iteration
		int i = 0;
		
		// Si la chaine contient des Fonctions
		if(isExpressionContainPattern(expression.trim(), FUNC_CHAIN_PATTERN)) {
			
			// Obtention de la liste des Fonctions
			String[] functions = extractToken(expression, FUNC_CHAIN_PATTERN);
			
			// Parcours
			for (String function : functions) {

				// Chaine en cours
				String currentExpression = expressionModel.getComputedExpression();
				
				// Nom de la Variable
				String parameterName = "var" + i++;
				
				// On remplace l'occurence courante par le nom de la variable
				currentExpression = currentExpression.replace(function, ":" + parameterName);
				
				// On met a jour l'expression computee
				expressionModel.setComputedExpression(currentExpression);
				
				// On ajoute les parametres
				expressionModel.addParameter(parameterName, function);
			}
			
		}
						
		// Tant que la chaene traitee contient des ENVs
		while(isExpressionContainPattern(expressionModel.getComputedExpression(), ENV_CHAIN_PATTERN)) {
			
			// Obtention de la liste des ENVs
			String[] envs = extractToken(expressionModel.getComputedExpression(), ENV_CHAIN_PATTERN);
			
			// Parcours
			for (String env : envs) {
				
				// Chaine en cours
				String currentExpression = expressionModel.getComputedExpression();
				
				// Nom de la Variable
				String parameterName = "var" + i++;
				
				// On remplace l'occurence courante par le nom de la variable
				currentExpression = currentExpression.replace(env, ":" + parameterName);
				
				// On met a jour l'expression computee
				expressionModel.setComputedExpression(currentExpression);
				
				// On ajoute les parametres
				expressionModel.addParameter(parameterName, env);
			}
		}
		
		// On retourne l'expression
		return expressionModel;
	}
630192
public Expression<Calendar> gt(Calendar value) {
		String valueString = "'" + getCalendarAsString(value) + "'";
		return new Expression<Calendar>(this, Operation.gt, valueString);
	}
555872
@Override
    public GStringExpression visitGstring(GstringContext ctx) {
        final List<ConstantExpression> stringLiteralList = new LinkedList<>();
        final String begin = ctx.GStringBegin().getText();
        final String beginQuotation = beginQuotation(begin);
        stringLiteralList.add(configureAST(new ConstantExpression(parseGStringBegin(ctx, beginQuotation)), ctx.GStringBegin()));

        List<ConstantExpression> partStrings =
                ctx.GStringPart().stream()
                        .map(e -> configureAST(new ConstantExpression(parseGStringPart(e, beginQuotation)), e))
                        .collect(Collectors.toList());
        stringLiteralList.addAll(partStrings);

        stringLiteralList.add(configureAST(new ConstantExpression(parseGStringEnd(ctx, beginQuotation)), ctx.GStringEnd()));

        List<Expression> values = ctx.gstringValue().stream()
                .map(e -> {
                    Expression expression = this.visitGstringValue(e);

                    if (expression instanceof ClosureExpression && !hasArrow(e)) {
                        List<Statement> statementList = ((BlockStatement) ((ClosureExpression) expression).getCode()).getStatements();

                        if (statementList.stream().noneMatch(DefaultGroovyMethods::asBoolean)) {
                            return configureAST(new ConstantExpression(null), e);
                        }

                        return configureAST(this.createCallMethodCallExpression(expression, new ArgumentListExpression(), true), e);
                    }

                    return expression;
                })
                .collect(Collectors.toList());

        StringBuilder verbatimText = new StringBuilder(ctx.getText().length());
        for (int i = 0, n = stringLiteralList.size(), s = values.size(); i < n; i++) {
            verbatimText.append(stringLiteralList.get(i).getValue());

            if (i == s) {
                continue;
            }

            Expression value = values.get(i);
            if (!asBoolean(value)) {
                continue;
            }

            verbatimText.append(DOLLAR_STR);
            verbatimText.append(value.getText());
        }

        return configureAST(new GStringExpression(verbatimText.toString(), stringLiteralList, values), ctx);
    }
956105
public T visitExpression(Expression elm, C context) {
        if (elm instanceof AggregateExpression) return visitAggregateExpression((AggregateExpression)elm, context);
        else if (elm instanceof AliasRef) return visitAliasRef((AliasRef)elm, context);
        else if (elm instanceof BinaryExpression) return visitBinaryExpression((BinaryExpression)elm, context);
        else if (elm instanceof Case) return visitCase((Case)elm, context);
        else if (elm instanceof Combine) return visitCombine((Combine)elm, context);
        else if (elm instanceof Current) return visitCurrent((Current)elm, context);
        else if (elm instanceof DateTime) return visitDateTime((DateTime)elm, context);
        else if (elm instanceof ExpressionRef) return visitExpressionRef((ExpressionRef)elm, context);
        else if (elm instanceof Filter) return visitFilter((Filter)elm, context);
        else if (elm instanceof First) return visitFirst((First)elm, context);
        else if (elm instanceof ForEach) return visitForEach((ForEach)elm, context);
        else if (elm instanceof FunctionRef) return visitFunctionRef((FunctionRef)elm, context);
        else if (elm instanceof IdentifierRef) return visitIdentifierRef((IdentifierRef)elm, context);
        else if (elm instanceof If) return visitIf((If)elm, context);
        else if (elm instanceof IndexOf) return visitIndexOf((IndexOf)elm, context);
        else if (elm instanceof Instance) return visitInstance((Instance)elm, context);
        else if (elm instanceof Interval) return visitInterval((Interval)elm, context);
        else if (elm instanceof Last) return visitLast((Last)elm, context);
        else if (elm instanceof List) return visitList((List)elm, context);
        else if (elm instanceof Literal) return visitLiteral((Literal)elm, context);
        else if (elm instanceof MaxValue) return visitMaxValue((MaxValue)elm, context);
        else if (elm instanceof MinValue) return visitMinValue((MinValue)elm, context);
        else if (elm instanceof NaryExpression) return visitNaryExpression((NaryExpression)elm, context);
        else if (elm instanceof Now) return visitNow((Now)elm, context);
        else if (elm instanceof Null) return visitNull((Null)elm, context);
        else if (elm instanceof OperandRef) return visitOperandRef((OperandRef)elm, context);
        else if (elm instanceof ParameterRef) return visitParameterRef((ParameterRef)elm, context);
        else if (elm instanceof PositionOf) return visitPositionOf((PositionOf)elm, context);
        else if (elm instanceof Property) return visitProperty((Property)elm, context);
        else if (elm instanceof Query) return visitQuery((Query)elm, context);
        else if (elm instanceof QueryLetRef) return visitQueryLetRef((QueryLetRef)elm, context);
        else if (elm instanceof Round) return visitRound((Round)elm, context);
        else if (elm instanceof Sort) return visitSort((Sort)elm, context);
        else if (elm instanceof Split) return visitSplit((Split)elm, context);
        else if (elm instanceof Substring) return visitSubstring((Substring)elm, context);
        else if (elm instanceof TernaryExpression) return visitTernaryExpression((TernaryExpression)elm, context);
        else if (elm instanceof Time) return visitTime((Time)elm, context);
        else if (elm instanceof TimeOfDay) return visitTimeOfDay((TimeOfDay)elm, context);
        else if (elm instanceof Today) return visitToday((Today)elm, context);
        else if (elm instanceof Tuple) return visitTuple((Tuple)elm, context);
        else if (elm instanceof UnaryExpression) return visitUnaryExpression((UnaryExpression)elm, context);
        else return null;
    }
713
def p_expression_ulnot(self, p):
        ''
        p[0] = Ulnot(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
1110954
def p_expression_uminus(self, p):
        ''
        p[0] = Uminus(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))