used in case of overflow, but this is usually an error
771113
@Override
	public void transferTo(Decoder newDecoder) {
		super.transferTo(newDecoder);
		if (remainingBytesLength > 0) {
			if (currentBuffer == null || !currentBuffer.hasRemaining())
				currentBuffer = ByteBuffer.wrap(remainingBytes, 0, remainingBytesLength);
			else {
				byte[] b = new byte[remainingBytesLength + currentBuffer.remaining()];
				System.arraycopy(remainingBytes, 0, b, 0, remainingBytesLength);
				currentBuffer.get(b, remainingBytesLength, currentBuffer.remaining());
				currentBuffer = ByteBuffer.wrap(b);
			}
		}
	}
62925
function intValidatorNoErrors( n, min, max ) {
        return ( n = truncate(n) ) >= min && n <= max;
    }
550271
public void checkLimit(int len) {
        if(cursor == -1) {
            cursor = buffer.start;
            lineptr = buffer.start;
            linectptr = buffer.start;
            marker = buffer.start;
        }
        limit = buffer.start + len;
    }
131158
protected int checkWrite(int offset, int length) {
    checkOffset(offset);
    if (limit == -1) {
      if (offset + length > capacity) {
        if (capacity < maxCapacity) {
          capacity(calculateCapacity(offset + length));
        } else {
          throw new BufferOverflowException();
        }
      }
    } else {
      if (offset + length > limit) {
        throw new BufferOverflowException();
      }
    }
    return offset(offset);
  }
1081681
private void checkTileOverFlow() throws MahjongTileOverFlowException {
        //
        for (int i = 0; i < handsComp.length; i++) {
            int hand = handsComp[i];
            if (hand > 4) {
                canWin = false;
                throw new MahjongTileOverFlowException(i, hand);
            }
        }
    }
1305780
function( value, interval ) {
			var error;

			// Convert the interval bounds to an array:
			interval = interval.split( ',' );

			if ( value < parseFloat( interval[ 0 ] ) ) {
				error = {
					"rule": "interval",
					"message": "ERROR:provided value exceeds the lower bound: " + interval[ 0 ]
				};
				return [ error ];
			}
			if ( value > parseFloat( interval[ 1 ] ) ) {
				error = {
					"rule": "interval",
					"message": "ERROR:provided value exceeds the upper bound: " + interval[ 1 ]
				};
				return [ error ];
			}
			return;
		}
942636
public void addWithOverflow(PagedBitMap that, PagedBitMap overflow) {
        LongArray ta = that.array;
        LongArray of = overflow.array;
        long n = 0;
        while(true) {
            n = ta.seekNext(n);
            if (n < 0) {
                break;
            }
            long o = array.get(n) & ta.get(n);
            long v = array.get(n) | ta.get(n);
            array.set(n, v);
            if (o != 0) {
                o |= of.get(n);
                of.set(n, o);
            }
            ++n;
        }
    }
395362
function AddonFormatError(msg) {
  Error.call(this);

  Error.captureStackTrace(this, AddonFormatError);

  /** @override */
  this.name = AddonFormatError.name;

  /** @override */
  this.message = msg;
}
46994
function ChecksumError(cause, actual, expected) {
    this.code = 'ChecksumError';
    if (expected === undefined) {
        expected = actual;
        actual = cause;
        cause = undefined;
    }
    assert.optionalObject(cause);
    assert.string(actual);
    assert.string(expected);

    var args = [];
    if (cause) args.push(cause);
    args = args.concat('content-md5 expected to be %s, but was %s',
        expected, actual);
    WError.apply(this, args);
}
909114
function (e,err)
		{
			if (typeof err == 'string' || typeof err != 'object' || err.stack == undefined)
				return false;

			e.owner.e.log('ERROR: '+err.message,'exception');

			var _stack = err.stack.split("\n");
			_stack.shift();
			for (s in _stack)
				e.owner.e.log(_stack[s],'stack');
		}
716961
def _limit(lower, upper):
    """"""
    if ((lower < 0) or (upper <= 0) or (upper < lower)):
        raise Exception("Illegal argument to _limit")
    return unicod("{%d,%d}") % (lower, upper)
712750
function attemptFix(problem) {
        const fix = problem.fix;
        const start = fix.range[0];
        const end = fix.range[1];

        // Remain it as a problem if it's overlapped or it's a negative range
        if (lastPos >= start || start > end) {
            remainingMessages.push(problem);
            return false;
        }

        // Remove BOM.
        if ((start < 0 && end >= 0) || (start === 0 && fix.text.startsWith(BOM))) {
            output = "";
        }

        // Make output to this fix.
        output += text.slice(Math.max(0, lastPos), Math.max(0, start));
        output += fix.text;
        lastPos = end;
        return true;
    }
170263
def err(*output, **kwargs):
    
    output = 'Error: ' + ' '.join([str(o) for o in output])
    if kwargs.get('wrap') is not False:
        output = '\n'.join(wrap(output, kwargs.get('indent', '')))
    elif kwargs.get('indent'):
        indent = kwargs['indent']
        output = indent + ('\n' + indent).join(output.splitlines())
    sys.stderr.write(output + '\n')
240832
protected function _overflowHandler() {
        return $this->_getAdapter()->overflow(
            $this->_cacheKey,
            $this->getUsage() - $this->getSize() + 1,
            $this->getUsage()
        );
    }
1278212
function hasOverflow(element) {
  const overflowRegex = /(auto|scroll)/;
  const computedStyles = getComputedStyle(element, null);

  const overflow =
    computedStyles.getPropertyValue('overflow') +
    computedStyles.getPropertyValue('overflow-y') +
    computedStyles.getPropertyValue('overflow-x');

  return overflowRegex.test(overflow);
}
1244674
def error(self, line_number, offset, text, check):
        """"""
        code = super(_Report, self).error(line_number, offset, text, check)
        if code:
            self.errors.append((line_number, offset + 1, code, text, check))
304179
function queryError(text, d, op, value) {
        var miss, err;
        miss = '(?)';
        err = this._getConstrName() + '._analyzeQuery: ' + text +
            '. Malformed query: ' + d || miss + ' ' + op || miss +
            ' ' + value || miss + '.';
        throw new Error(err);
    }