<form method="POST">
    <h3>Editing: EmailLexer.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Egulias\EmailValidator;

use Doctrine\Common\Lexer\AbstractLexer;

class EmailLexer extends AbstractLexer
{
    //ASCII values
    const C_DEL              = 127;
    const C_NUL              = 0;
    const S_AT               = 64;
    const S_BACKSLASH        = 92;
    const S_DOT              = 46;
    const S_DQUOTE           = 34;
    const S_SQUOTE           = 39;
    const S_BACKTICK         = 96;
    const S_OPENPARENTHESIS  = 49;
    const S_CLOSEPARENTHESIS = 261;
    const S_OPENBRACKET      = 262;
    const S_CLOSEBRACKET     = 263;
    const S_HYPHEN           = 264;
    const S_COLON            = 265;
    const S_DOUBLECOLON      = 266;
    const S_SP               = 267;
    const S_HTAB             = 268;
    const S_CR               = 269;
    const S_LF               = 270;
    const S_IPV6TAG          = 271;
    const S_LOWERTHAN        = 272;
    const S_GREATERTHAN      = 273;
    const S_COMMA            = 274;
    const S_SEMICOLON        = 275;
    const S_OPENQBRACKET     = 276;
    const S_CLOSEQBRACKET    = 277;
    const S_SLASH            = 278;
    const S_EMPTY            = null;
    const GENERIC            = 300;
    const CRLF               = 301;
    const INVALID            = 302;
    const ASCII_INVALID_FROM = 127;
    const ASCII_INVALID_TO   = 199;

    /**
     * US-ASCII visible characters not valid for atext (@link http://tools.ietf.org/html/rfc5322#section-3.2.3)
     *
     * @var array
     */
    protected $charValue = array(
        '('    =&gt; self::S_OPENPARENTHESIS,
        ')'    =&gt; self::S_CLOSEPARENTHESIS,
        '&lt;'    =&gt; self::S_LOWERTHAN,
        '&gt;'    =&gt; self::S_GREATERTHAN,
        '['    =&gt; self::S_OPENBRACKET,
        ']'    =&gt; self::S_CLOSEBRACKET,
        ':'    =&gt; self::S_COLON,
        ';'    =&gt; self::S_SEMICOLON,
        '@'    =&gt; self::S_AT,
        '\\'   =&gt; self::S_BACKSLASH,
        '/'    =&gt; self::S_SLASH,
        ','    =&gt; self::S_COMMA,
        '.'    =&gt; self::S_DOT,
        &quot;'&quot;    =&gt; self::S_SQUOTE,
        &quot;`&quot;    =&gt; self::S_BACKTICK,
        '&quot;'    =&gt; self::S_DQUOTE,
        '-'    =&gt; self::S_HYPHEN,
        '::'   =&gt; self::S_DOUBLECOLON,
        ' '    =&gt; self::S_SP,
        &quot;\t&quot;   =&gt; self::S_HTAB,
        &quot;\r&quot;   =&gt; self::S_CR,
        &quot;\n&quot;   =&gt; self::S_LF,
        &quot;\r\n&quot; =&gt; self::CRLF,
        'IPv6' =&gt; self::S_IPV6TAG,
        '{'    =&gt; self::S_OPENQBRACKET,
        '}'    =&gt; self::S_CLOSEQBRACKET,
        ''     =&gt; self::S_EMPTY,
        '\0'   =&gt; self::C_NUL,
    );

    /**
     * @var bool
     */
    protected $hasInvalidTokens = false;

    /**
     * @var array
     *
     * @psalm-var array{value:string, type:null|int, position:int}|array&lt;empty, empty&gt;
     */
    protected $previous = [];

    /**
     * The last matched/seen token.
     *
     * @var array
     *
     * @psalm-var array{value:string, type:null|int, position:int}
     */
    public $token;

    /**
     * The next token in the input.
     *
     * @var array|null
     */
    public $lookahead;

    /**
     * @psalm-var array{value:'', type:null, position:0}
     */
    private static $nullToken = [
        'value' =&gt; '',
        'type' =&gt; null,
        'position' =&gt; 0,
    ];

    public function __construct()
    {
        $this-&gt;previous = $this-&gt;token = self::$nullToken;
        $this-&gt;lookahead = null;
    }

    /**
     * @return void
     */
    public function reset()
    {
        $this-&gt;hasInvalidTokens = false;
        parent::reset();
        $this-&gt;previous = $this-&gt;token = self::$nullToken;
    }

    /**
     * @return bool
     */
    public function hasInvalidTokens()
    {
        return $this-&gt;hasInvalidTokens;
    }

    /**
     * @param int $type
     * @throws \UnexpectedValueException
     * @return boolean
     *
     * @psalm-suppress InvalidScalarArgument
     */
    public function find($type)
    {
        $search = clone $this;
        $search-&gt;skipUntil($type);

        if (!$search-&gt;lookahead) {
            throw new \UnexpectedValueException($type . ' not found');
        }
        return true;
    }

    /**
     * getPrevious
     *
     * @return array
     */
    public function getPrevious()
    {
        return $this-&gt;previous;
    }

    /**
     * moveNext
     *
     * @return boolean
     */
    public function moveNext()
    {
        $this-&gt;previous = $this-&gt;token;
        $hasNext = parent::moveNext();
        $this-&gt;token = $this-&gt;token ?: self::$nullToken;

        return $hasNext;
    }

    /**
     * Lexical catchable patterns.
     *
     * @return string[]
     */
    protected function getCatchablePatterns()
    {
        return array(
            '[a-zA-Z_]+[46]?', //ASCII and domain literal
            '[^\x00-\x7F]',  //UTF-8
            '[0-9]+',
            '\r\n',
            '::',
            '\s+?',
            '.',
            );
    }

    /**
     * Lexical non-catchable patterns.
     *
     * @return string[]
     */
    protected function getNonCatchablePatterns()
    {
        return array('[\xA0-\xff]+');
    }

    /**
     * Retrieve token type. Also processes the token value if necessary.
     *
     * @param string $value
     * @throws \InvalidArgumentException
     * @return integer
     */
    protected function getType(&amp;$value)
    {
        if ($this-&gt;isNullType($value)) {
            return self::C_NUL;
        }

        if ($this-&gt;isValid($value)) {
            return $this-&gt;charValue[$value];
        }

        if ($this-&gt;isUTF8Invalid($value)) {
            $this-&gt;hasInvalidTokens = true;
            return self::INVALID;
        }

        return  self::GENERIC;
    }

    /**
     * @param string $value
     *
     * @return bool
     */
    protected function isValid($value)
    {
        if (isset($this-&gt;charValue[$value])) {
            return true;
        }

        return false;
    }

    /**
     * @param string $value
     * @return bool
     */
    protected function isNullType($value)
    {
        if ($value === &quot;\0&quot;) {
            return true;
        }

        return false;
    }

    /**
     * @param string $value
     * @return bool
     */
    protected function isUTF8Invalid($value)
    {
        if (preg_match('/\p{Cc}+/u', $value)) {
            return true;
        }

        return false;
    }

    /**
     * @return string
     */
    protected function getModifiers()
    {
        return 'iu';
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>