ignore chars in stream while it is white space
@throws \InvalidArgumentException
@throws \LogicException
772265
public function ignoreWhitespace()
    {
        ignoreWhitespace:
        if (! $this->isEnd() && $this->currentAscii()->isWhiteSpace()) {
            $this->next();
            goto ignoreWhitespace;
        }
    }
957506
public int skipWhitespace() {
        for (int i = index; i < originalInput.length(); i++) {
            if (Character.isWhitespace(originalInput.charAt(i))) {
                index++;
            } else {
                break;
            }
        }
        return index;
    }
1140902
def _skip_whitespace(self):
        """"""
        i = 0
        while self._cur_token['type'] is TT.ws and not self._finished:
            self._increment()
            i += 1

        return i
932694
private function popWhitespace()
    {
        while ($this->isToken(reset($this->tokens), Tokenizer::TOKEN_WHITESPACE)) {
            array_shift($this->tokens);
        }
    }
186761
private function handleNoWhitespaceFound(File $phpcsFile, int $semicolonPtr): void
    {
        $fixNoWhitespace = $phpcsFile->addFixableError(
            self::MESSAGE_NO_WHITESPACE_FOUND,
            $semicolonPtr,
            static::CODE_NO_WHITESPACE_FOUND
        );

        if ($fixNoWhitespace) {
            $phpcsFile->fixer->beginChangeset();
            $phpcsFile->fixer->addNewline($semicolonPtr);
            $phpcsFile->fixer->endChangeset();
        }
    }
1091234
public int skipWhitespace() {
        try {
            int readChar = 20;
            char c = SPACE;
            while (Character.isWhitespace(c)) {
                reader.mark(1);
                readChar = reader.read();
                c = (char) readChar;
            }
            reader.reset();
            return readChar;
        } catch (IOException ioe) {
            throw new JsonException("An IO exception occurred while reading the JSON payload", ioe);
        }
    }
518697
public function readStringNull()
    {
        $pos = \strpos($this->buffer, "\0", $this->bufferPos);
        if ($pos === false) {
            throw new \LogicException('Missing NULL character');
        }

        $ret = $this->read($pos - $this->bufferPos);
        ++$this->bufferPos;

        return $ret;
    }
177032
private function removeWhitespace(): void
    {
        $string = preg_replace('/ {2,}/', Tokens::SPACE, $this->normalisedString);
        $lines = [];

        foreach (explode(Tokens::LINE_FEED, $string) as $line) {
            if ('' !== $line = trim($line)) {
                $lines[] = $line;
            }
        }
        $this->normalisedString = implode(Tokens::LINE_FEED, $lines);
    }
1163944
protected function skipWhitespace()
	{
		while (++$this->i < $this->cnt && $this->tokens[$this->i][0] === T_WHITESPACE);
	}
1201036
public function tell(): int
    {
        if (null === $this->handle) {
            throw new \LogicException('Can not read from closed input stream.');
        }

        $position = @ftell($this->handle);
        if (false === $position) {
            throw new StreamException(
                    'Can not read current position in file: '
                    . lastErrorMessage('unknown error')
            );
        }

        return $position;
    }
1056864
private function SkipWhitespace()
	{
		do
		{
			// if ( XmlCharType.Instance.IsWhiteSpace( $this->Peek( 0 ) ) )
			if ( preg_match( "/\s/", $this->Peek( 0 ) ) )
			{
				$c;
				while ( ( $c = $this->Peek( 0 ) ) && ord( $c ) != 0 && preg_match( "/\s/", $c ) )
				{
					$this->Read();
				}
				continue;
			}
			if ( $this->Peek( 0 ) == '(' && $this->Peek( 1 ) == ':' )
			{
				$this->Read();
				$this->Read();
				$n = 1;
				while ( true )
				{
					$c = $this->Peek( 0 );
					if ( ord( $c ) == 0 )
					{
						break;
					}
					else if ( $c == '(' && $this->Peek( 1 ) == ':' )
					{
						$this->Read();
						$this->Read();
						$n++;
					}
					else if ( $c == ':' && $this->Peek( 1 ) == ')' )
					{
						$this->Read();
						$this->Read();
						if ( --$n == 0 )
						{
							break;
						}
					}
					else
					{
						$this->Read();
					}
				}
				if ( $n )
				{
					throw XPath2Exception::withErrorCodeAndParam( "XPST0003", Resources::XPST0003, "Comment not closed" );
				}
				continue;
			}
			break;
		}
		while ( true );
	}
610583
private int absorbWhitespace(final StreamTokenizer tokeniser, Reader in, boolean ignoreEOF) throws IOException, ParserException {
        // HACK: absorb extraneous whitespace between components (KOrganizer)..
        int ntok;
        while ((ntok = nextToken(tokeniser, in, ignoreEOF)) == StreamTokenizer.TT_EOL) {
            if (log.isTraceEnabled()) {
                log.trace("Absorbing extra whitespace..");
            }
        }
        if (log.isTraceEnabled()) {
            log.trace("Aborting: absorbing extra whitespace complete");
        }
        return ntok;
    }
970143
public function escapeStream()
    {
        if ($this->literal()) {
            throw new Horde_Imap_Client_Data_Format_Exception('String requires literal to output.');
        }

        rewind($this->_data->stream);

        $stream = new Horde_Stream_Temp();
        $stream->add($this->_data, true);

        stream_filter_register('horde_imap_client_string_quote', 'Horde_Imap_Client_Data_Format_Filter_Quote');
        stream_filter_append($stream->stream, 'horde_imap_client_string_quote', STREAM_FILTER_READ);

        return $stream->stream;
    }
973821
public void skipWhitespace() {
        while (position < string.length()) {
            final char c = string.charAt(position);
            if (c == ' ' || c == '\n' || c == '\r' || c == '\t') {
                position++;
            } else {
                break;
            }
        }
    }
287971
protected function skipWhitespace(): void
    {
        while ($this->position < $this->bodyLength) {
            $code = $this->readCharCode($this->position);

            if (9 === $code || 32 === $code || 44 === $code || 0xfeff === $code) {
                // tab | space | comma | BOM
                ++$this->position;
            } elseif (10 === $code) {
                // new line (\n)
                ++$this->position;
                ++$this->line;
                $this->lineStart = $this->position;
            } elseif (13 === $code) {
                // carriage return (\r)
                if (10 === $this->readCharCode($this->position + 1)) {
                    // carriage return and new line (\r\n)
                    $this->position += 2;
                } else {
                    ++$this->position;
                }
                ++$this->line;
                $this->lineStart = $this->position;
            } else {
                break;
            }
        }
    }
805008
private final boolean skip_whitespace(CommentStrategy commentStrategy) throws IOException
    {
        boolean any_whitespace = false;
        int c;

        loop: for (;;) {
            c = read_char();
            switch (c) {
            case -1:
                break loop;
            case ' ':
            case '\t':
            // new line normalization and counting is handled in read_char
            case CharacterSequence.CHAR_SEQ_NEWLINE_SEQUENCE_1:
            case CharacterSequence.CHAR_SEQ_NEWLINE_SEQUENCE_2:
            case CharacterSequence.CHAR_SEQ_NEWLINE_SEQUENCE_3:
            case CharacterSequence.CHAR_SEQ_ESCAPED_NEWLINE_SEQUENCE_1:
            case CharacterSequence.CHAR_SEQ_ESCAPED_NEWLINE_SEQUENCE_2:
            case CharacterSequence.CHAR_SEQ_ESCAPED_NEWLINE_SEQUENCE_3:
                any_whitespace = true;
                break;
            case '/':
                if (!commentStrategy.onComment(this))
                {
                    break loop;
                }
                any_whitespace = true;
                break;
            default:
                break loop;
            }
        }
        unread_char(c);
        return any_whitespace;
    }
207493
private function _skipWhiteSpaces()
    {
        while ($this->_pos < strlen($this->_value)
              && ctype_space($this->_value[$this->_pos])
        ) {
            ++$this->_pos;
        }
    }