parse.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       parse.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:54:00 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
 
 
#include <string>
#include <string.h>
#include "parse.h"
 
#include "pars_argument.h"
 
#define VRAI 1
#define FAUX 0
#define SIMPLE 103
#define LISTE_VIRGULE 100
#define LISTE_PVIRGULE 101
#define LISTE_ESPACE 102
#define ERREUR -1
 
 
PARSE::PARSE()
{
}
 
PARSE::~PARSE()
{
}
 
 
std::string PARSE::lire(FILE *in,char fin,int *ierr)
{
    char c;
    std::string chainelue="";
    *ierr=0;
    do
    {
        size_t res=fread(&c,sizeof(char),1,in);
        if (feof(in))
        {
            *ierr=1;
            return "";
        }
        if (c>31) chainelue+=c;
    }
    while (c!=fin);
    return chainelue;
}
 
 
 
void PARSE::decode(char *code,std::string masque,class PARS_ARGUMENT *arg)
{
    char* mask=(char *)masque.c_str();
    decode_old(code,mask,arg);
}
 
void PARSE::decode(const char *code,std::string masque,class PARS_ARGUMENT *arg)
{
    char* mask=(char *)masque.c_str();
    decode_old((char*)code,mask,arg);
}
 
void PARSE::decode_old(const char *code,char *mask,class PARS_ARGUMENT *arg)
{
    decode((char*)code,mask,arg);
}
 
void PARSE::decode_old(char *code,char *mask2,PARS_ARGUMENT *arg)
{
    int nb_arg;
    char **param;
 
 
    char *mask;
    mask=new char[strlen(mask2)+2];
    strcpy(mask,mask2);
    char *ptrM=mask;
    int p_arg=0;
    while (*ptrM)
    {
        if ((*ptrM=='@') || (*ptrM=='?') || (*ptrM=='&') || (*ptrM=='~')) p_arg++;
        ptrM++;
    }
    nb_arg=p_arg;
    int *type_param=new int[nb_arg];
 
    p_arg=0;
    ptrM=mask;
    while (*ptrM)
    {
        if ((*ptrM=='@') || (*ptrM=='&')  || (*ptrM=='~') || (*ptrM=='?') )
        {
            if (*ptrM=='@') type_param[p_arg]=SIMPLE;
            if (*ptrM=='&') type_param[p_arg]=LISTE_VIRGULE;
            if (*ptrM=='~') type_param[p_arg]=LISTE_ESPACE;
            if (*ptrM=='?') type_param[p_arg]=LISTE_PVIRGULE;
            p_arg++;
            *ptrM='@';
        }
        ptrM++;
    }
 
    param=new char*[nb_arg];
    long lg=strlen(code)+1;
    for (int i=0;i<nb_arg;i++)
    {
        param[i]=new char[lg];
        strcpy(param[i],"");
        arg[i].argument.clear();
    }
    Match (code,mask,param);
    for (int i=0;i<nb_arg;i++)
        arg[i].argument.insert(arg[i].argument.end(),param[i]);
    for (int i=0;i<nb_arg;i++)
        if (type_param[i]!=SIMPLE)
        {
            char *param_tmp[2];
            param_tmp[0]=new char[lg];
            param_tmp[1]=new char[lg];
            strcpy(param_tmp[0],arg[i].argument[0].c_str());
            arg[i].argument.clear();
            int code;
            char *p=param_tmp[0];
            do
            {
                char format[4]={'@',',','@',0};
                if (type_param[i]==LISTE_VIRGULE) code=Match(p,format,&(param_tmp[0]));
                if (type_param[i]==LISTE_ESPACE) code=Match(p,format,&(param_tmp[0]));
                if (type_param[i]==LISTE_PVIRGULE) code=Match(p,format,&(param_tmp[0]));
                arg[i].argument.insert(arg[i].argument.end(),param_tmp[0]);
                strcpy(param_tmp[0],"");
                p=param_tmp[1];
            }
            while (code==VRAI);
            delete [] param_tmp[0];
            delete [] param_tmp[1];
        }
 
    for (int i=0;i<nb_arg;i++)
        delete [] param[i];
    delete [] param;
    delete [] type_param;
    delete [] mask;
}
 
 
 
 
int PARSE::Match(char *code,char *mask,char **param)
{
    int i=0;
    char *ptrC,*ptrM,*ptrP;
 
    ptrC = code;
    ptrM = mask;
    while (*ptrM && *ptrC)
    {
        if (*ptrM == '@')
        {
            ++ptrM;
            ptrP = param[i];
            if (!*ptrM)
                while (*ptrC)   *ptrP++ = *ptrC++;
            else
            {
                if (!MatchC(&ptrC,&ptrP,*ptrM)) return(FAUX);
                else   --ptrP;
            }
            *ptrP = 0;
            ++i;
        }
        else
        {
            if (*ptrM != *ptrC) return(FAUX);
            ++ptrC;
        }
        if (*ptrM) ++ptrM;
    }
    if (*ptrM)  return(FAUX);
    return(VRAI);
}
 
int PARSE::MatchC(char **ptrC,char **ptrP,char cFin)
{
    char *lPtrC,*lPtrP;
    int noOuverture;
 
    lPtrC = *ptrC;
    lPtrP = *ptrP;
 
    while (*lPtrC != cFin && *lPtrC)
    {
        if ((noOuverture = Ouverture(*lPtrC)) == ERREUR)
            *lPtrP++ = *lPtrC++;
        else
        {
            *lPtrP++ = *lPtrC++;
            if (!MatchC(&lPtrC,&lPtrP,Fermeture(noOuverture)))  return(FAUX);
        }
    }
    if (!*lPtrC)
    {
        *lPtrP++='\0';
        return(FAUX);
    }
    *lPtrP++ = *lPtrC++;
    *ptrC = lPtrC;
    *ptrP = lPtrP;
    return(VRAI);
}
 
int PARSE::Ouverture(char c)
{
    static char ouverture[4]= {'(','[','{'};
    char *ptr;
 
    ptr = ouverture;
    while (*ptr)
        if (*ptr == c)  return(ptr-ouverture);
        else                    ++ptr;
    return(ERREUR);
}
 
char PARSE::Fermeture(int i)
{
    static char fermeture[4] = {')',']','}'};
 
    return(fermeture[i]);
}