Move one token ahead.

@return void
490988
private function advanceToken()
    {
        if (!($this->tokenIs(T_WHITESPACE) || $this->tokenIs(T_DOC_COMMENT))) {
            $this->prevToken = $this->token;
        }
        $this->token = next($this->tokens);
    }
1101961
protected function updateTokenExpiry()
    {
        \DB::table($this->tokenTable)->where('token', $this->getToken())->update([
            $this->getTokenColumn('expire') => Carbon::parse('now '. $this->getTokenLifetime()),
        ]);
    }
144196
public int moveTokens() {
        int count;
        if(token == -1) {
            return 0;
        }

        int skip = limit - token;
        if(skip < 0) {
            return 0;
        }

        if((count = token - buffer.start) != 0) {
            System.arraycopy(buffer.buffer, token, buffer.buffer, buffer.start, skip);
            token = buffer.start;
            marker -= count;
            cursor -= count;
            toktmp -= count;
            limit -= count;
            lineptr -= count;
            linectptr -= count;
        }
        return skip;
    }
306761
public function next()
        {
            if (false !== $this->skipNextIteration) {
                $this->skipNextIteration = false;
                return;
            }

            next($this->data);
        }
606319
protected function processToken(): void
    {
        $prevStatement = null;

        foreach ($this->useStatements as $useStatement) {
            if ($prevStatement && ($this->compareUseStatements($prevStatement, $useStatement) > 0)) {
                $exception = new CodeError(
                    static::CODE_INCORRECT_ORDER,
                    'Use statements should be sorted alphabetically. The first wrong one is %s.',
                    $useStatement->getPointer()
                );

                $exception
                    ->setPayload([$useStatement->getFullyQualifiedTypeName()])
                    ->isFixable(true);

                throw $exception;
            }

            $prevStatement = $useStatement;
        }
    }
1163831
public function shift()
    {
        $first = $this->first();

        if (null === $first) {
            return;
        }

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

        return $first;
    }
1315489
public function advance()
    {
        if (!$this->started) {
            throw new LogicException('Progress indicator has not yet been started.');
        }

        if (!$this->output->isDecorated()) {
            return;
        }

        $currentTime = $this->getCurrentTimeInMilliseconds();

        if ($currentTime < $this->indicatorUpdateTime) {
            return;
        }

        $this->indicatorUpdateTime = $currentTime + $this->indicatorChangeInterval;
        ++$this->indicatorCurrent;

        $this->display();
    }
72979
protected function processToken(): void
    {
        try {
            $this->checkAndRegisterSortingError();

            $this->checkAndRegisterLineBreakErrors();
        } catch (CodeWarning  $exception) {
            $fixable = $this->getExceptionHandler()->handleException($exception);

            if ($fixable) {
                $this->fixSorting();
            }
        }
    }
734364
public function next()
    {
        $this->index++;

        if ($this->valid()) {
            $model = $this->offsetGet($this->index);

            if (in_array($model->UniqueIdentifier, $this->filteredIds)){
                $this->next();
            }
        }
    }
500852
function MoveNext()
	{
		$ret = @oci_fetch_array($this->_queryID,$this->fetchMode);
		if($ret !== false) {
		global $ADODB_ANSI_PADDING_OFF;
			$this->fields = $ret;
			$this->_currentRow++;
			$this->_updatefields();

			if (!empty($ADODB_ANSI_PADDING_OFF)) {
				foreach($this->fields as $k => $v) {
					if (is_string($v)) $this->fields[$k] = rtrim($v);
				}
			}
			return true;
		}
		if (!$this->EOF) {
			$this->EOF = true;
			$this->_currentRow++;
		}
		return false;
	}
508643
protected function pushOrder()
    {
        if( $this->order ) {
            $this->parts[] = 'ORDER BY';
            $this->parts[] = $this->quoteIdentifierIfNotExpression($this->order);
            $this->parts[] = $this->direction == self::DESC ? self::DESC : self::ASC;
        }
    }
436225
protected function processToken(): void
    {
        $tokenTypes = [T_CONST, T_FUNCTION, T_VARIABLE];

        foreach ($tokenTypes as $tokenType) {
            $this->checkAndRegisterSortingProblemsOfTypes($tokenType);
        }
    }
200386
private function moveToNextLine(): bool
    {
        if ($this->currentLineNb >= \count($this->lines) - 1) {
            return false;
        }

        $this->currentLine = $this->lines[++$this->currentLineNb];

        return true;
    }
67481
public function getNextToken() {
		if ($this->index < (count($this->tokens) - 1)) {

			// Increment the index
			$this->index ++;

			// Return the new token
			return $this->tokens[$this->index];
		} else {
			return false;
		}
	}
928168
private function moveReaderToCurrent()
    {
        if (
            ($this->reader->nodeType === XMLReader::NONE)
            or ($this->reader->nodeType !== XMLReader::ELEMENT)
            or ($this->localName && $this->localName !== $this->reader->localName)
        ) {
            self::next();
        }
    }
70523
protected function setUp(): void
    {
        parent::setUp();

        $nextToken = $this->tokens[$this->stackPos + 1];
        $prevToken = $this->tokens[$this->stackPos - 1];

        $this->nextIsWhitespace = $nextToken['code'] === T_WHITESPACE;
        $this->prevIsWhitespace = $prevToken['code'] === T_WHITESPACE;
    }
859146
public function forward(array $forward)
    {
        if (isset($forward['namespace'])) {
            $this->setNamespaceName($forward['namespace']);
        }

        if (isset($forward['handler'])) {
            $this->setHandlerName($forward['handler']);
        }

        if (isset($forward['action'])) {
            $this->setActionName($forward['action']);
        }

        if (isset($forward['params'])) {
            $this->setParams($forward['params']);
        }

        $this->finished = false;
    }