expr : expr GE expr
327921
def p_exprge(p):
    
    a = int(p[1]) if p[1].isdigit() else 0
    b = int(p[3]) if p[3].isdigit() else 0

    p[0] = '1' if a >= b else '0'
302555
def p_member_expr(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        elif p[1] == 'new':
            p[0] = ast.NewExpr(p[2], p[3])
        elif p[2] == '.':
            p[0] = ast.DotAccessor(p[1], p[3])
        else:
            p[0] = ast.BracketAccessor(p[1], p[3])
1167528
def p_exprgt(p):
    
    a = int(p[1]) if p[1].isdigit() else 0
    b = int(p[3]) if p[3].isdigit() else 0

    p[0] = '1' if a > b else '0'
959379
function(expr) {
      var obj = this._apply("anything"),
          state = this.bt.current_state();

      this.bt.inject(obj);
      expr.call(this);
      this._apply("end");

      this.bt.restore(state);
      return obj;
    }
897795
def find_ge(a, x):
    """"""
    i = bs.bisect_left(a, x)
    if i != len(a): return i
    raise ValueError
786698
private ExprKraken parseAndExpr()
  {
    // AndExpr oldAndExpr = _andExpr;
    AndExpr andExpr = new AndExpr();
    // _andExpr = andExpr;

    andExpr.add(parseNotExpr());

    while (true) {
      Token token = scanToken();

      switch (token) {
      case AND:
        andExpr.add(parseNotExpr());
        break;

      default:
        _token = token;

        // _andExpr = oldAndExpr;

        return andExpr.getSingleExpr();
      }
    }
  }
536295
function parseRegExp (str) {
  if (str instanceof RegExp) return str
  let arg = String(str).match(/^\/(.*)\/(g|i|)$|.*/)
  return new RegExp(arg[1] || arg[0], arg[2])
}
847176
def p_expr_NE_expr(p):
    
    p[0] = make_binary(p.lineno(2), 'NE', p[1], p[3], lambda x, y: x != y)
15906
def p_expr1(p):
    
    p[0] = node.expr(op=p[1], args=node.expr_list([p[2]]))
54584
def p_new_expr_nobf(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = self.asttypes.NewExpr(p[2])
            p[0].setpos(p)
997056
def p_expr_BXOR_expr(p):
    
    p[0] = make_binary(p.lineno(2), 'BXOR', p[1], p[3], lambda x, y: x ^ y)
305652
def p_id_expr(p):
    
    entry = SYMBOL_TABLE.access_id(p[1], p.lineno(1), default_class=CLASS.var)
    if entry is None:
        p[0] = None
        return

    entry.accessed = True
    if entry.type_ == TYPE.auto:
        entry.type_ = _TYPE(gl.DEFAULT_TYPE)
        api.errmsg.warning_implicit_type(p.lineno(1), p[1], entry.type_)

    p[0] = entry

    """
    if entry.class_ == CLASS.var:
        if entry.type_ == TYPE.auto:
            entry.type_ = SYMBOL_TABLE.basic_types[gl.DEFAULT_TYPE]
            #api.errmsg.warning_implicit_type(p.lineno(1), p[1], entry.type_)
    """
    if entry.class_ == CLASS.array:
        if not LET_ASSIGNMENT:
            syntax_error(p.lineno(1), "Variable '%s' is an array and cannot be used in this context" % p[1])
            p[0] = None
    elif entry.kind == KIND.function:  # Function call with 0 args
        p[0] = make_call(p[1], p.lineno(1), make_arg_list(None))
    elif entry.kind == KIND.sub:  # Forbidden for subs
        api.errmsg.syntax_error_is_a_sub_not_a_func(p.lineno(1), p[1])
        p[0] = None
1097936
function ge(Me){var Ze=[],Ue,Fe,He,Ke,qe,Ve,Ge,Ye,We,Xe,Je,/** `inputLength` will hold the number of code points in `input`. */Qe,/** Cached calculation results */$e,et,tt;// Convert the input in UCS-2 to Unicode
// Handle the basic code points
for(Me=le(Me),Qe=Me.length,Ue=Be,Fe=0,qe=Pe,Ve=0;Ve<Qe;++Ve)Je=Me[Ve],128>Je&&Ze.push(ze(Je));// Main encoding loop:
for(He=Ke=Ze.length,Ke&&Ze.push(Re);He<Qe;){// All non-basic code points < n have been handled already. Find the next
// larger one:
for(Ge=Ie,Ve=0;Ve<Qe;++Ve)Je=Me[Ve],Je>=Ue&&Je<Ge&&(Ge=Je);// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
// but guard against overflow
for($e=He+1,Ge-Ue>Le((Ie-Fe)/$e)&&de("overflow"),Fe+=(Ge-Ue)*$e,Ue=Ge,Ve=0;Ve<Qe;++Ve)if(Je=Me[Ve],Je<Ue&&++Fe>Ie&&de("overflow"),Je==Ue){// Represent delta as a generalized variable-length integer
for(Ye=Fe,We=Ae;;/* no condition */We+=Ae){if(Xe=We<=qe?we:We>=qe+Ee?Ee:We-qe,Ye<Xe)break;tt=Ye-Xe,et=Ae-Xe,Ze.push(ze(be(Xe+tt%et,0))),Ye=Le(tt/et)}Ze.push(ze(be(Ye,0))),qe=he(Fe,$e,He==Ke),Fe=0,++He}++Fe,++Ue}return Ze.join("")}
192088
def p_expr_minus_expr(p):
    
    p[0] = make_binary(p.lineno(2), 'MINUS', p[1], p[3], lambda x, y: x - y)
578146
def p_conditional_expr(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = self.asttypes.Conditional(
                predicate=p[1], consequent=p[3], alternative=p[5])
            p[0].setpos(p, 2)
1041361
def p_expr_AND_expr(p):
    
    p[0] = make_binary(p.lineno(2), 'AND', p[1], p[3], lambda x, y: x and y)
277511
function parsePrimaryExpression() {
        var type, token, expr, node;

        if (match('(')) {
            return parseGroupExpression();
        }

        if (match('[')) {
            return parseArrayInitialiser();
        }

        if (match('{')) {
            return parseObjectInitialiser();
        }

        type = lookahead.type;
        node = new Node();

        if (type === Token.Identifier) {
            expr = node.finishIdentifier(lex().value);
        } else if (type === Token.StringLiteral || type === Token.NumericLiteral) {
            if (strict && lookahead.octal) {
                tolerateUnexpectedToken(lookahead, Messages.StrictOctalLiteral);
            }
            expr = node.finishLiteral(lex());
        } else if (type === Token.Keyword) {
            if (matchKeyword('function')) {
                return parseFunctionExpression();
            }
            if (matchKeyword('this')) {
                lex();
                return node.finishThisExpression();
            }
            if (matchKeyword('class')) {
                return parseClassExpression();
            }
            throwUnexpectedToken(lex());
        } else if (type === Token.BooleanLiteral) {
            token = lex();
            token.value = (token.value === 'true');
            expr = node.finishLiteral(token);
        } else if (type === Token.NullLiteral) {
            token = lex();
            token.value = null;
            expr = node.finishLiteral(token);
        } else if (match('/') || match('/=')) {
            index = startIndex;

            if (typeof extra.tokens !== 'undefined') {
                token = collectRegex();
            } else {
                token = scanRegExp();
            }
            lex();
            expr = node.finishLiteral(token);
        } else {
            throwUnexpectedToken(lex());
        }

        return expr;
    }