CRÉER UN PARSEUR LL

<?php
define('BR', '<br />');

define('NO_ERROR', -1);
define('EMPTY_BUFFER', 0);
define('INVALID_DIGIT', 1);
define('INVALID_VARNAME', 2);
define('VAR_TAG_EXPECTED', 3);
define('CLOSE_TAG_EXPECTED', 4);
/*
 * Specifics chars
 */
define('VAR_TAG', '$');
define('CLOSE_TAG', ';');
define('FLOAT_COMMA', '.');

abstract class LLP
{
    /*
     * Main bufer
     */
    private static $buffer = '';
    private static $bSize = 0;
    /*
     * Read buffer
     */
    private static $readBuffer = '';
    private static $rbSize = 0;
    /*
     * Read cursors
     */
    private static $cursor = 0; # Current
    private static $index = 0; # Global
    /*
     * Prepare will skip following chars
     */
    private static $skip = array
    (
            ' ',
            "\n",
            "\t",
            "\r"
    );
    /*
     * Errors
     */
    private static $errorType = -1;

    public static function getError()
    {
        switch (self::$errorType)
        {
            case 0 : $str = 'EMPTY_BUFFER'; break;
            case 1 : $str = 'INVALID_DIGIT'; break;
            case 2 : $str = 'INVALID_VARNAME'; break;
            case 3 : $str = 'VAR_TAG_EXPECTED'; break;
            case 4 : $str = 'CLOSE_TAG_EXPECTED'; break;
            default : $str = 'NO_ERROR';
        }

        return 'PARSE_ERROR >> '.$str;
    }
    /*
     * Returns global buffer index
     */
    public static function getIndex()
    {
        return self::$index;
    }
    /*
     * Returns char at index self::$index;
     */
    public static function getCharAtCurrentIndex()
    {
        return self::$buffer[self::$index];
    }
    /*
     * return current buffer index
     */
    public static function getCursor()
    {
        return self::$cursor;
    }
    /*
     * Clean main buffer
     */
    public static function clean()
    {
        self::$buffer = '';
        self::$bSize = 0;

        self::$readBuffer = '';
        self::$rbSize = 0;

        self::$index = 0;
        self::$cursor = 0;
    }
    /*
     * Rturn main buffer
     */
    public static function buffer()
    {
        return self::$buffer;
    }
    /*
     * Clean Read buffer
     */
    public static function flush()
    {
        $readBuffer = self::$readBuffer;

        self::$readBuffer = '';

        return $readBuffer;
    }
    /*
     * Print buffers
     */
    public static function cout()
    {
        $out = '';

        $out .= '<pre>';
        $out .= 'MAIN_BUFFER >> ';
        $out .= (strlen(self::$buffer) > 0 ? self::$buffer : 'EMPTY').BR;
        $out .= 'READ_BUFFER >> ';
        $out .= (strlen(self::$readBuffer) > 0 ? self::$readBuffer : 'EMPTY').BR;
        $out .= '</pre>';

        echo $out;
    }
    /*
     * Prepare for read
     */
    protected static function prepare()
    {
        if (self::$bSize === 0)
        {
            self::$errorType = EMPTY_BUFFER;
            return false;
        }

        self::$cursor = 0;

        while (in_array(self::$buffer[0], self::$skip)) self::unbufferize();

        return true;
    }
    /*
     * Add text to main buffer
     */
    public static function bufferize($str = '')
    {
        if (is_string($str))
        {
            self::$buffer = trim($str.self::$buffer);
            self::$bSize += strlen($str);

            return true;
        }

        return false;
    }
    /*
     * Eat $size left chars in main buffer
     */
    protected static function unbufferize($size = 1)
    {
        if ($size > 0)
        {
            if ($size <= self::$bSize)
            {
                self::$buffer = substr(self::$buffer, $size, self::$bSize);
                self::$bSize -= strlen($size);

                self::$cursor += $size;
                self::$index += $size;

                return true;
            }
            return false;
        }
        return false;
    }
    
    /*
     * Private read functions
     */

    /*
     * Read $size chars in main buffer and unbuferize them
     */
    protected static function read($size = 1)
    {
        if ($size > 0)
        {
            if ($size > self::$bSize)
            {
                $size = self::$bSize;
                self::$bSize = 0;
            }

            self::$readBuffer .= substr(self::$buffer, 0, $size);
            self::$rbSize += strlen($size);

            return self::unbufferize($size);
        }
        return false;
    }
    /*
     * Try to read any char in main buffer
     */
    protected static function readChar($char = NULL)
    {
        if (!is_null($char))
        {
            if (self::$buffer[0] !== $char)
                return false;
        }
        return self::read();
    }
    /*
     * Try to read specified digit in main buffer
     */
    protected static function readDigit($digit = NULL)
    {
        if (ctype_digit(self::$buffer[0]))
        {
            if (ctype_digit($digit))
            {
                    if (self::$buffer[0] !== $digit)
                        return false;
            }
            return self::read();
        }
        return false;
    }
    /*
     * Try to read a int in main buffer
     */
    protected static function readInteger($int)
    {
        if (!ctype_digit($int))
                return false;

        $int = strval($int);
        $numSize = strlen($int);
        $i = 0;

        while ($i < $numSize)
        {
            if (self::readDigit($int[$i]))
                $i++;
            else
                return false;
        }

        return true;
    }
    /*
     * Try to read a float in main buffer
     */
    protected static function readFloat($float = '', $separator = FLOAT_COMMA)
    {
        $float = explode($separator, $float);

        return self::readInteger($float[0]) &&
               self::readChar($separator) &&
               self::readInteger($float[1]);
    }
    
    /*
     * Public basic read functions
     */

    /*
     * Try to read specified string
     */
    public static function readString($str = '')
    {
        if (!is_string($str))
            return false;

        $strSize = strlen($str);
        $i = 0;

        while ($i < $strSize)
        {
            if (self::readChar($str[$i]) || self::readDigit($str[$i]))
                $i++;
            else
                return false;
        }

        return true;
    }
    /*
     * Read until next pattern
     */
    public static function readNext($str)
    {
        if (!is_string($str))
            return false;

        while (!self::readString($str)) ;

        if (self::$bSize == 0) return false;
        
        return true;
    }
    /*
     * Read buffer until buffer contain alpha chars
     */
    public static function readAlpha()
    {
        self::prepare();

        $count = 0;
        
        while ((ctype_alpha(self::$buffer[0]) && self::readChar())) $count++;
        
        if ($count > 0) return true;

        return false;
    }
    /*
     * Read buffer until buffer contain alphanum chars
     */
    public static function readAlphaNum()
    {
        self::prepare();

        $count = 0;
        
        while ((ctype_alnum(self::$buffer[0]) && self::readChar())) $count++;

        if ($count > 0) return true;
        
        return false;
    }
    /*
     * Try to read a number (int or float)
     */
    public static function readNumber($number)
    {
        self::prepare();

        if (strstr($number, FLOAT_COMMA)) return self::readFloat($number);

        return self::readInteger($number);
    }
    /*
     * Try to read a word in main buffer
     */
    public static function readWord($str)
    {
        self::prepare();

        return self::readString($str);
    }

    /*
     * Test patterned read functions
     */

    public static function readVar()
    {
        self::prepare();

        if (self::readString(VAR_TAG))
        {
            self::prepare();
            
            if (self::readAlpha() && !self::readAlphaNum())
            {
                if (self::readChar(CLOSE_TAG)) return true;
                else self::$errorType = CLOSE_TAG_EXPECTED;
            }
            else
            {
                self::$errorType = INVALID_VARNAME;
            }
        }
        else self::$errorType = VAR_TAG_EXPECTED;

        return false;
    }
}

 define('XML_OPEN_NODE', '<');
 define('XML_CLOSE_NODE', '>');
 define('XML_TERMINAL_NODE', '</');
 
class NodeParser extends LLP
{
    private static $currentNodeName = '';
    private static $nodeContent = '';

    public static function nodeName()
    {
        return self::$currentNodeName;
    }

    public static function nodeContent()
    {
        return self::$nodeContent;
    }

    public static function openNode()
    {
        if (parent::readString(XML_OPEN_NODE))
            parent::flush();
        if (parent::readAlphaNum())
            self::$currentNodeName = parent::flush();
        if (parent::readString(XML_CLOSE_NODE))
        {
            parent::flush();
            return true;
        }
        return false;
    }

    public static function closeNode()
    {
        if (parent::readString(XML_TERMINAL_NODE))
            parent::flush();
        if (parent::readString(self::$currentNodeName))
           parent::flush();
        if (parent::readString(XML_CLOSE_NODE))
        {
            parent::flush();
            return true;
        }
        return false;
    }
    
    public static function node()
    {
        if (self::openNode())
        {
            parent::readAlphaNum();
            self::$nodeContent = parent::flush();

            if (self::closeNode())
            {
                return true;
            }
            else
            {
                echo 'CLOSE_NODE_ERROR'.BR;
            }
        }
        else
        {
            echo 'OPEN_NODE_ERROR'.BR;
        }

        return false;
    }
}

LLP::bufferize('public private 4242 42.42 toto42 $titi;');
LLP::cout();

if (LLP::readWord('public'))
{
    echo 'Read String : '.LLP::flush().BR;
}else{ echo 'Read String : FAIL at index '.LLP::getIndex().BR; }

if (LLP::readWord('private'))
{
    echo 'Read String : '.LLP::flush().BR;
}else{ echo 'Read String : FAIL at index '.LLP::getIndex().BR; }

if (LLP::readNumber(4242))
{
    echo 'Read Int : '.LLP::flush().BR;
}
else{ echo 'Read Int : FAIL at index '.LLP::getIndex().BR; LLP::cout(); }

if (LLP::readNumber(42.42))
{
    echo 'Read Float : '.LLP::flush().BR;
}
else{ echo 'Read Float : FAIL at index '.LLP::getIndex().BR; LLP::cout(); }

if (LLP::readAlphaNum())
{
    echo 'Read AlphaNum : '.LLP::flush().BR;
}else{ echo 'Read AlphaNum : FAIL at index '.LLP::getIndex().BR; }

if (LLP::readVar())
{
    echo 'Read Var : '.LLP::flush().BR;
}else{ echo 'Read Var : FAIL at index '.LLP::getIndex().' : '.LLP::getError().BR; }

echo 'Done';

NodeParser::clean();
NodeParser::bufferize('<toto>titi</toto>');
NodeParser::cout();

if (NodeParser::node())
{
    echo 'Read Node : '.XMLParser::nodeName().' with content '.XMLParser::nodeContent().BR;
}else{ echo 'Read Node : FAIL at index '.XMLParser::getIndex().' : '.XMLParser::getError().BR; }

?>