Indicate an invalid marker on a processed file

@param string $file File where invalid marker resides
@param int $line Line number
@param string $marker Marker found
@param int $count Count
@return void
196292
protected function _markerError($file, $line, $marker, $count)
    {
        if (strpos($this->_file, CAKE_CORE_INCLUDE_PATH) === false) {
            $this->_countMarkerError++;
        }

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

        $this->err(sprintf("Invalid marker content in %s:%s\n* %s(", $file, $line, $marker));
        $count += 2;
        $tokenCount = count($this->_tokens);
        $parenthesis = 1;

        while ((($tokenCount - $count) > 0) && $parenthesis) {
            if (is_array($this->_tokens[$count])) {
                $this->err($this->_tokens[$count][1], false);
            } else {
                $this->err($this->_tokens[$count], false);
                if ($this->_tokens[$count] === '(') {
                    $parenthesis++;
                }

                if ($this->_tokens[$count] === ')') {
                    $parenthesis--;
                }
            }
            $count++;
        }
        $this->err("\n", true);
    }
818810
public function handler($number, $message, $file, $line, $context) {

		if(0 === error_reporting()) { 
			return;
		}

		$this -> error = new Error();
		$this -> error -> setFile($file); 
		$this -> error -> setMessage($message); 
		$this -> error -> setNumber($number); 
		$this -> error -> setLine($line); 
		$this -> error -> setDate(new DateTime()); 
		$this -> error -> setContext($context); 
		$this -> error -> setBacktrace(debug_backtrace(null, 5));
		$this -> error -> setIp(Request :: getIp());

		switch($this -> error -> getNumber()) {

			case E_ERROR :
			case E_CORE_ERROR :
			case E_COMPILE_ERROR :
			case E_PARSE :
				$this -> error -> setType('FATAL');
			break;
			
			case E_USER_ERROR :
			case E_RECOVERABLE_ERROR :
				$this -> error -> setType('ERROR');
			break;
		
			case E_WARNING :
			case E_CORE_WARNING :
			case E_COMPILE_WARNING :
			case E_USER_WARNING :
				$this -> error -> setType('WARNING');
			break;
		
			case E_NOTICE :
			case E_USER_NOTICE :
				$this -> error -> setType('INFO');
			break;
			
			case E_STRICT :
				$this -> error -> setType('STRICT');
			break;
		}

		$this -> action();
	}
1203691
private function checkDifferentAnnotations(Annotation $annotation, $linesCount)
    {
        if ($linesCount === 1) {
            return;
        }

        $this->phpcsFile->addError(
            \sprintf('Expected 1 lines between different annotations types, found %d.', $linesCount),
            $annotation->getStartPointer(),
            'LineBetweenDifferentTags'
        );
    }
454007
public void error(Marker marker, String format, Object arg) {
        if (!logger.isErrorEnabled(marker))
            return;
        if (instanceofLAL) {
            String formattedMessage = MessageFormatter.format(format, arg).getMessage();
            ((LocationAwareLogger) logger).log(marker, fqcn, LocationAwareLogger.ERROR_INT, formattedMessage, new Object[] { arg }, null);
        } else {
            logger.error(marker, format, arg);
        }
    }
40017
public function setLocation(FileDescriptor $file, $line = 0)
    {
        $this->setFile($file);
        $this->line = $line;
    }
269250
public static void checkValidFile(final File file) {
        checkNotNull("file", file);
        if (!file.exists()) {
            throw new IllegalArgumentException("The file '" + file + "' does not exist!");
        }
        if (!file.isFile()) {
            throw new IllegalArgumentException("The name '" + file + "' is not a file!");
        }
    }
1279260
protected function eachLineHasColumnCountOf(array $lines, $count, $separator, $delimiter)
    {
        foreach ($lines as $line) {
            $row = str_getcsv($line, $separator, $delimiter);

            if (static::isSkippableRow($row)) {
                continue;
            }

            if ($count != count($row)) {
                return false;
            }
        }

        return true;
    }
984119
public function handleError(int $num, string $str, string $file, int $line): void
    {
        $this->handleException(new \ErrorException($str, 0, $num, $file, $line));
        $this->stop(-1);
    }
557244
protected function ol(array $items, string $marker = '<yellow>%s</yellow>.', int $writer = Output::STANDARD): void
	{
		(new OrderedList($this->output))->draw($items, $marker, $writer);
	}
654477
private function renderPHP($file, $line)
    {
        try {
            $count = count(file($file));
            $code  = highlight_file($file, true);
            return $this->wrapLineNumbers($count, $code, $line);
        }
        catch(Throwable $e) { // Error or Exception (executed only in PHP 7, will not match in PHP 5)
            return null;
        }
        catch(Exception $e) { // Once PHP 5 support is no longer needed, this block can be removed.
            return null;
        }
    }
194863
public function writeError($line, $check, $message, $level = WARNING) {

		// Update the counters
		$this->nbErrors ++;
		$this->fileErrors ++;
		if ($this->fileInError === false) {
			$this->nbfilesError ++;
			$this->fileInError = true;
		}

		// Add the check to the details
		$detail = $this->_readTemplate("detail_body");
		$values = array();
		$values['%%message%%'] = htmlspecialchars($message);
		$values['%%check%%'] = $check;
		$values['%%line%%'] = $line;
		$values['%%level%%'] = $level;
		$detail = $this->_fillTemplate($detail, $values);
		$this->fileDetail .= $detail;
	}
1242242
public void trace(Marker marker, String format, Object arg1, Object arg2) {
        if (!logger.isTraceEnabled(marker))
            return;
        if (instanceofLAL) {
            String formattedMessage = MessageFormatter.format(format, arg1, arg2).getMessage();
            ((LocationAwareLogger) logger).log(marker, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, new Object[] { arg1, arg2 }, null);
        } else {
            logger.trace(marker, format, arg1, arg2);
        }
    }
228745
public void error( Marker marker, String format, Object arg )
    {
        if( m_delegate.isErrorEnabled() )
        {
            FormattingTuple tuple = MessageFormatter.format( format, arg );
            setMDCMarker( marker );
            m_delegate.error( tuple.getMessage(), tuple.getThrowable() );
            resetMDCMarker();
        }
    }
97215
public void warn(final Marker marker, final String message) {
        log.warn(marker, sanitize(message));
    }
611459
protected function outdent(File $phpcsFile, int $index, int $count = 1): void
    {
        $tokens = $phpcsFile->getTokens();
        $char = $this->getIndentationCharacter($tokens[$index]['content'], true);

        $phpcsFile->fixer->replaceToken($index, $this->strReplaceOnce($char, '', $tokens[$index]['content']));
    }
883535
public function errorHandler(int $type, string $message, string $file, int $line) :void
    {
        $this->whichError($message, $type, $file, $line);
    }
763554
public static function errorToException($code, $message, $file, $line)
    {
        if (error_reporting() & $code) {
            throw new \ErrorException($message, 0, $code, $file, $line);
        }
    }