expression: expression (LTE | LT | GTE | GT) expression
341099
@Override
    public Object visitComparisonExpression(ExcellentParser.ComparisonExpressionContext ctx) {
        Pair<Object, Object> args = Conversions.toSame(visit(ctx.expression(0)), visit(ctx.expression(1)), m_evalContext);
        int compared;

        if (args.getLeft() instanceof String) {
            // string comparison is case-insensitive
            compared = ((String) args.getLeft()).compareToIgnoreCase((String) args.getRight());
        }
        else {
            compared = ((Comparable) args.getLeft()).compareTo(args.getRight());
        }

        if (ctx.LTE() != null) {
            return compared <= 0;
        } else if (ctx.LT() != null) {
            return compared < 0;
        } else if (ctx.GTE() != null) {
            return compared >= 0;
        } else { // GT
            return compared > 0;
        }
    }
1038562
public static <E> AbstractGroupExpression<E, Set<E>> set(Expression<E> expression) {
        return GSet.createLinked(expression);
    }
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;
    }
895884
public Expression<String> gte(String value) {
		String valueString = "'" + value + "'";
		return new Expression<String>(this, Operation.gte, valueString);
	}
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;
	}
1262830
def p_expression_uxnor(self, p):
        ''
        p[0] = Uxnor(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
287744
public static Expression atan(String expression1, String expression2) {
        return atan(x(expression1), x(expression2));
    }
882271
def p_expression(tok):
        """"""
        if len(tok) == 4:
            tok[0] = LogicalBinOpRule(tok[2], tok[1], tok[3])
        else:
            tok[0] = tok[1]
757223
function performTermOperationOnExpression(expression, op, term) {
  const node = (Node.Type.isOperator(expression) ?
    Node.Creator.parenthesis(expression) : expression);

  term.changeGroup = 1;
  const newNode = Node.Creator.operator(op, [node, term]);

  return newNode;
}
1370004
def p_expr_GT_expr(p):
    
    p[0] = make_binary(p.lineno(2), 'GT', p[1], p[3], lambda x, y: x > y)
1039556
def p_l_expression(self, p):
        '''     
        '''
        _LOGGER.debug("l -> expresion")

        l = TypedList( [ p[1] ] )
        p[0] = l
624974
private Expression toExpression(Part part, ExpressionList<?> root) {
        return new ExpressionBuilder(part, root).build();
    }
427827
def p_expression_logical(self, p):
        
        p[0] = Expression(left=p[1], operator=p[2], right=p[3])
268420
def p_expression_Or(self, p):
        ''
        p[0] = Or(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
619668
public Expression<Long> lte(long value) {
		String valueString = "'" + value + "'";
		return new Expression<Long>(this, Operation.lte, valueString);
	}
1142891
public Expression<String> gt(String value) {
		String valueString = "'" + value + "'";
		return new Expression<String>(this, Operation.gt, valueString);
	}
535002
public Expression<Byte> lte(byte value) {
		String valueString = "'" + value + "'";
		return new Expression<Byte>(this, Operation.lte, valueString);
	}