Parser.h

Aller à la documentation de ce fichier.

/*! \file Parser.h
    \brief Parser.

    Parser à pseudo langage programmable.

    \author     aerith (http://aerith.fr)
    \version    1.0
    \date       20/05/2008
*/

#ifndef INCLUDE_RSRC_PARSER
#define INCLUDE_RSRC_PARSER

#include    "../Surcouche/SurcoucheModule.h"
#include    "../Tools/Tools.h"
#include    "../Error/Error.h"
#include    "ParserRule.h"
#include    <vector>
#include    <string>

using namespace std;


#define     PARSER_BUFFER       10240
#define     PARSER_LABEL        32
#define     PARSER_TOK          '$'

//! Information sur une règle.
/*! Information sur une règle.
*/
class ParserRule
{
public  :
    ROUTINE                 function;           /*!< Nom de la routine à éxécutée.                      */
    string                  syntax;             /*!< Syntax de la requette.                             */

    /*! Initialise avec des paramétres par defaut.
        \param pFunction routine à appeler
        \param pSyntax syntax de la règle
    */
    ParserRule(ROUTINE pFunction, const char *pSyntax)
    {
        function = pFunction;
        syntax = pSyntax;
    };
};

//! Parser.
/*! Parser à pseudo langage programmable.
*/
template <class T> class Parser
{
private :
    vector<ParserRule *>    rules;          /*!< Chaque lignes est une règle.                       */
    T                       *obj;           /*!< Classe ou structure à passer aux routines.         */
    char                    none[1];        /*!< Valeur d'un get non trouvé.                        */

public  :
    /*! Initialise avec des paramétres par defaut.
        \param pObj class ou structure à passer au routine
    */
    Parser(T *pObj)
    {
        obj = pObj;
        *none   = '\0';
    };

    /*! Libère la mémoire proprement
    */
    ~Parser()
    {
        unsigned int    i;

        for(i = 0; i < rules.size(); i ++)
            delete rules[i];
        rules.clear();
    };

    //! Ajoute une règle.
    /*! Ajoute une règle avec une syntax et une routine lier.
        \param pFunction routine a lier.
        \param pSyntax syntax de la règle.
    */
    void    AddRule(ROUTINE pFunction, const char *pSyntax, ...)
    {
        char        temp[PARSER_BUFFER];
        va_list     args;

        va_start(args, pSyntax);
        vsprintf(temp, pSyntax, args);
        va_end(args);

        rules.push_back(new ParserRule(pFunction, temp));
    };

    //! Supprime une règle.
    /*! Supprime la règle à la position \a iPos.
        \param iPos position de la règle.
    */
    void    DelRule(unsigned int iPos)
    {
        if(iPos < rules.size())
            rules.erase(rules.begin() + iPos);
    };

    //! Retourne la syntax de la règle.
    /*! Retourne la syntax de la règle \a iPos.
        \param iPos Position de la règle.
        \return pointeur sur la syntax de la règle.
    */
    inline const char   *GetSyntax(unsigned int iPos)
    {
        if(iPos < rules.size())
            return rules[iPos]->syntax.data();

        return none;
    };

    //! Retourne le nombre de règles.
    /*! Retourne le nombre de règles du parser.
        \return nombre de requette du parser.
    */
    inline unsigned int     GetNbRule()
    {
        return rules.size();
    };

    //! Parse un buffer.
    /*! Parse un buffer ligne à ligne, recherche et éxécute les routines.
        \param pBuffer buffer à parser.
    */
    void    ParseLine(const char *pBuffer)
    {
        char            out[PARSER_BUFFER];
        const char      *b = pBuffer;
        char            *o = out;
        TRY

        while(*b)
        {
            if((*b != '\n') && (*b != '\r'))
            {
                *o++ = *b;
            }
            else if(out != o)
            {
                *o = '\0';
                Parse(out);
                o = out;
            }

            b++;
        }

        CATCH
    };

    //! Parse un buffer.
    /*! Parse le buffer en un seul block, recherche et éxécute une routine.
        \param pBuffer buffer à parser.
    */
    void    Parse(const char *pBuffer)
    {
        unsigned int            i = 0;
        const char              *pSyntax = NULL;
        char                    end = '\0';
        char                    buffer[PARSER_BUFFER];
        char                    temp[PARSER_BUFFER];
        char                    label[PARSER_LABEL];
        char                    *pBuf = NULL;
        char                    *pTemp = NULL;
        char                    *pLabel = NULL;
        ParserRuleParameter<T>  *parameter = NULL;
        TRY

        strncpy(buffer, pBuffer, PARSER_BUFFER);

        for(i = 0; i < rules.size(); i++)
        {
            pBuf = buffer;
            pSyntax = rules[i]->syntax.c_str();
            parameter = new ParserRuleParameter<T>(obj);

            do
            {
                if(*pSyntax == PARSER_TOK) //si c'est un paramètre
                {
                    pLabel = label;
                    pTemp = temp;

                    pSyntax++; //passe le PARSER_TOK
                    while(IsAlphaNumCar(*pSyntax))
                        *pLabel++ = *pSyntax++; //copie le nom du paramètre
                    *pLabel = '\0';

                    end = *pSyntax; //carractère où s'arrète le paramètre

                    while((*pBuf != '\0') && (*pBuf != end))
                    {
                        *pTemp = *pBuf; //copie la valeur du paramètre
                        pTemp++;
                        pBuf++;
                    }
                    *pTemp = '\0';
                    pBuf++; //pour être différent de Tok

                    parameter->Add(label, temp);
                }
                else //si c'est un carractère non utile
                {
                    if(*pSyntax == *pBuf)
                        pBuf++;
                    else //si la requette ne correspond pas au mask
                        break;
                }

                if(*pSyntax != '\0')
                    pSyntax++;
            }
            while(*pBuf && *pSyntax);

            if((*pSyntax == '\0') && (*pBuf == '\0'))
                rules[i]->function((PARAMETRE)parameter);

            delete parameter;
        }

        CATCH
    };
};

#endif

---