expr : variable INC
            | variable DEC
10293
def p_expr_post_incdec(p):
    ''''''
    p[0] = ast.PostIncDecOp(p[2], p[1], lineno=p.lineno(2))
1165253
private SemanticType checkVariable(Expr.VariableAccess expr, Environment environment) {
		Decl.Variable var = expr.getVariableDeclaration();
		return environment.getType(var);
	}
1204766
def p_assignment_expr_noin(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = self.asttypes.Assign(left=p[1], op=p[2], right=p[3])
            p[0].setpos(p, 2)
506778
def incr(**vars):
    
    for k, v in vars:
        current_context.vars.setdefault(k, 0)
        current_context[k] += v
491777
def _pre_var(self, value):
        

        def sub_(m):
            return self._pre_variables.get(m.group()[2:-1].strip(), '')

        return r_pre_var.sub(sub_, value)
259796
def convert(self, expr):
        
        if expr is True or expr == None or expr is False:
            return expr
        elif is_number(expr):
            return expr
        elif expr == ".":
            return "."
        elif is_variable_name(expr):
            return coalesce(self.dimensions[expr], expr)
        elif is_text(expr):
            Log.error("{{name|quote}} is not a valid variable name", name=expr)
        elif isinstance(expr, Date):
            return expr
        elif is_op(expr, QueryOp):
            return self._convert_query(expr)
        elif is_data(expr):
            if expr["from"]:
                return self._convert_query(expr)
            elif len(expr) >= 2:
                #ASSUME WE HAVE A NAMED STRUCTURE, NOT AN EXPRESSION
                return wrap({name: self.convert(value) for name, value in expr.leaves()})
            else:
                # ASSUME SINGLE-CLAUSE EXPRESSION
                k, v = expr.items()[0]
                return converter_map.get(k, self._convert_bop)(self, k, v)
        elif is_many(expr):
            return wrap([self.convert(value) for value in expr])
        else:
            return expr
829097
def p_expr_usr(p):
    
    if p[2].type_ == TYPE.string:
        p[0] = make_builtin(p.lineno(1), 'USR_STR', p[2], type_=TYPE.uinteger)
    else:
        p[0] = make_builtin(p.lineno(1), 'USR',
                            make_typecast(TYPE.uinteger, p[2], p.lineno(1)),
                            type_=TYPE.uinteger)
948367
def p_expr_plus(self, tree):
        ''' '''
        tree.value = convertstr(tree[0].value) + convertstr(tree[2].value)
1002257
def expr2dimacssat(ex):
    """"""
    if not ex.simple:
        raise ValueError("expected ex to be simplified")

    litmap, nvars = ex.encode_inputs()

    formula = _expr2sat(ex, litmap)
    if 'xor' in formula:
        if '=' in formula:
            fmt = 'satex'
        else:
            fmt = 'satx'
    elif '=' in formula:
        fmt = 'sate'
    else:
        fmt = 'sat'

    return "p {} {}\n{}".format(fmt, nvars, formula)
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
665646
def p_expr_noin(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = ast.Comma(left=p[1], right=p[3])
535581
function findRems(rule) {

        for (var i = 0; i < rule.declarations.length; i++) {
          var declaration = rule.declarations[i];

          // grab values that contain 'rem'
          if (declaration.type === 'declaration' && isSupported(declaration) && regexRem.test(declaration.value)) {

            var pxValues = remToPx(declaration.value.split(/\s(?![^\(\)]*\))/));

            if (options.replace) {
              declaration.value = pxValues;
            } else {
              var fallback = clone(declaration);
              fallback.value = pxValues;
              rule.declarations.splice(i, 0, fallback);
            }

          }
        }
      }
573628
def p_exprlt(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'
1181970
def _expr2bddnode(expr):
    """"""
    if expr.is_zero():
        return BDDNODEZERO
    elif expr.is_one():
        return BDDNODEONE
    else:
        top = expr.top

        # Register this variable
        _ = bddvar(top.names, top.indices)

        root = top.uniqid
        lo = _expr2bddnode(expr.restrict({top: 0}))
        hi = _expr2bddnode(expr.restrict({top: 1}))
        return _bddnode(root, lo, hi)
323792
function(dec) {

      let g;
      let N = this["n"];
      let D = this["d"];

      dec = dec || 15; // 15 = decimal places when no repitation

      let cycLen = cycleLen(N, D); // Cycle length
      let cycOff = cycleStart(N, D, cycLen); // Cycle start

      let str = this['s'] < C_ZERO ? "-" : "";

      // Append integer part
      str += N / D | C_ZERO;

      N %= D;
      N *= C_TEN;

      if (N)
        str += ".";

      if (cycLen) {

        for (let i = cycOff; i--; ) {
          str += N / D | C_ZERO;
          N %= D;
          N *= C_TEN;
        }
        str += "(";
        for (let i = cycLen; i--; ) {
          str += N / D | C_ZERO;
          N %= D;
          N *= C_TEN;
        }
        str += ")";
      } else {
        for (let i = dec; N && i--; ) {
          str += N / D | C_ZERO;
          N %= D;
          N *= C_TEN;
        }
      }
      return str;
    }
1110285
function decInt(str, base = 10) {
  if (!isNumStr(str, base)) throw new Error('in decInt, str is not an integer in the given base');
  let minus = String.fromCharCode(consts.minus);

  let rec = rectify(str);

  // If the rectified value is negative, call increment on the absolute value.
  if (rec[0] == minus) {
    let inc = incInt(rec.slice(1), base);
    return (minus + inc);
  }

  // Find the first character from the right that is not zero.
  // This is the character to decrement.
  let decIndex = -1;
  for (let i = rec.length - 1; i >= 0; i--) {
    if (rec[i] != consts.alphabet[0]) {
      decIndex = i;
      break;
    }
  }

  // If all characters are found to be zero, the decremented value is -1.
  if (decIndex < 0) return minus + consts.alphabet[1];

  // Decrement the appropriate character.
  let decrementedChar = decChar(rec[decIndex], base);
  let dec = rec.slice(0, decIndex) + decrementedChar;

  // Reset all lesser character places to the maximal character for the given base.
  let maximalChar = consts.alphabet[base - 1];
  dec = dec.padEnd(rec.length, maximalChar);

  // Rectify in case the decremented character left a leading zero.
  dec = rectify(dec);

  return dec;
}
577632
def p_expr(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = ast.Comma(left=p[1], right=p[3])