NetParser.cpp

/*! \file NetParser.cpp
    \brief Parser de protocol.

    Parser de protocol programmable.

    \author     aerith (contact@aerith.biz - www.aerith.biz)
    \version    1.0
    \date       26/07/2007
*/

#include    "NetParser.h"

NetParser::NetParser(NetConnect *pConnect)
{
    NbRequest       = 0;
    Connect         = pConnect;
}

NetParser::~NetParser()
{
    while(NbRequest)
        DelRequest(NbRequest - 1);
    Requests.clear();
}

int     NetParser::AddRequest(char *pName, int iPos, ROUTINE pFunction, char *pMask, int iComplet, char *pToks)
{
    Requests.push_back(new NetRequest);

    if(!Requests[NbRequest])
        return ERROR_C_MEMORY;
    else
    {
        Requests[NbRequest]->Name = new char[strlen(pName) + 1];
        strcpy(Requests[NbRequest]->Name, pName);
        Requests[NbRequest]->Pos = iPos;
        Requests[NbRequest]->Function = pFunction;
        Requests[NbRequest]->Mask = new char[strlen(pMask) + 1];
        strcpy(Requests[NbRequest]->Mask, pMask);
        Requests[NbRequest]->Complet = iComplet;
        Requests[NbRequest]->Toks = new char[strlen(pToks) + 1];
        strcpy(Requests[NbRequest]->Toks, pToks);
    }
    NbRequest++;

    return ERROR_C_NOERROR;
}

int     NetParser::DelRequest(int iPos)
{

    if(iPos < NbRequest)
    {
        delete [] Requests[iPos]->Name;
        delete [] Requests[iPos]->Mask;
        delete [] Requests[iPos]->Toks;
        delete Requests[iPos];
        Requests.erase(Requests.begin() + iPos);

        NbRequest--;
    }
    
    return ERROR_C_NOERROR;
}

int     NetParser::ParseLine(char *pBuffer)
{
    char    *Buffer, *Out;
    char    *pBuf, *pOut;
    int     Size;
    BEGIN

    Size = strlen(pBuffer);
    Buffer = (char *)malloc(sizeof(char) * (Size + 1));
    Out = (char *)malloc(sizeof(char) * (Size + 1));
    strncpy(Buffer, pBuffer, Size);
    pBuf = Buffer;
    pOut = Out;

    while(*pBuf && !CERROR)
    {
        if((*pBuf != '\n') && (*pBuf != '\r'))
        {
            *pOut = *pBuf;
            pOut++;
        }
        else if(pOut != Out)
        {
            *pOut = '\0';
            CERROR = Parse(Out);
            pOut = Out;
        }

        pBuf++;
    }

    free(Buffer);
    free(Out);

    ENDBEGIN
}

int     NetParser::Parse(char *pBuffer)
{
    int     i;
    char    *pMask;
    char    Tok;
    char    Buffer[NET_BUFFER];
    char    Temp[NET_BUFFER];
    char    Label[NET_NAME];
    char    *pCur;
    char    *pTemp;
    char    *pLabel;
    BEGIN

    for(i = 0; (i < NbRequest) && !CERROR; i++)
    {
        if(!strcmp(Requests[i]->Name, gettok(pBuffer, Requests[i]->Pos, Requests[i]->Toks)))
        {
            TRY if(i < NbRequest)
            {
                NetRequestParameter Parameter(Connect);
                Parameter.SetName(Requests[i]->Name, Requests[i]->Pos);
                strncpy(Buffer, pBuffer, NET_BUFFER);
                pCur = Buffer;
                pMask = Requests[i]->Mask;

                do
                {
                    TRY {
                        if(*pMask == '%')
                        {
                            pMask++;
                            pLabel = Label;
                            pTemp = Temp;

                            while(IsAlphaNumCar(*pMask))
                                *pLabel++ = *pMask++;

                            Tok = *pMask;

                            while(*pCur)
                            {
                                if(*pCur == Tok)
                                {
                                    *pCur++;
                                    break;
                                }
                                *pTemp++ = *pCur++;
                            }

                            *pTemp = '\0';
                            *pLabel = '\0';

                            Parameter.Add(Label, Temp);
                        }
                        else
                        {
                            if(*pMask == *pCur)
                                pCur++;
                        }
                    }

                    if(*pMask)
                        pMask++;
                }
                while(*pCur && *pMask && !CERROR);

                TRY if((Requests[i]->Complet && !*pMask) || (!Requests[i]->Complet))
                {
                    CERROR = (int)Requests[i]->Function((PARAMETRE)&Parameter);
                }
            }
        }
    }

    ENDBEGIN
}

---