/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E S T   D E S   F O N C T I O N S   D E   G E S T I O N   D E S                                                          */
/*        " E X P R E S S I O N S "   R E G U L I E R E S   ( A   L A   ' sed ' )                                                    */
/*        A V E C   U T I L I S A T I O N   D ' I N D E X                                                                            */
/*        E T   T E S T   D E S   S O U S - E X P R E S S I O N S                                                                    */
/*        E T   T E S T   D U   M A R Q U E U R   ' ^$ '  :                                                                          */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/regul_exp.05$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

extern    void      *malloc();

#include  <stdio.h>

#define   INIT                                                                                                                          \
                    char      *sp = expression_reguliere;
#define   GETC()                                                                                                                        \
                    (*sp++)
#define   PEEKC()                                                                                                                       \
                    (*sp)
#define   UNGETC(c)                                                                                                                     \
                    (--sp)
#define   RETURN(c)                                                                                                                     \
                    return(c);
#define   ERROR(c)                                                                                                                      \
                    exit();

static    char      *expression_reguliere="^";

#include  <regexp.h>

#define   LONGUEUR                                                                                                                      \
                    10000

main()
          {
          char      *pointeur;
          char      *chaineA="123\n\n456\n\n789\n";
          char      *sous_chaineA;
          int       indexA;
          char      *chaineR;
          int       indexR;

          char      *loc1_precedent=0,*loc2_precedent=0;

          char      *chaineS="+-";

          char      *expression_compilee=malloc(LONGUEUR);
          char      *fin_expression_compilee;

          int       iterer=0;

          chaineR=malloc(2*strlen(chaineA));

          fin_expression_compilee=compile(expression_reguliere,expression_compilee,&expression_compilee[(LONGUEUR-1)+1],'\0');

          printf("\n expression reguliere......=%s",expression_reguliere);
          printf("\n nombre de sous-expressions=%d",nbra);
          printf("\n longueur..................=(%d,%d)=%d"
                ,expression_compilee,fin_expression_compilee,fin_expression_compilee-expression_compilee
                 );
          printf("\n expression compilee.......=(");

          for       (pointeur=expression_compilee ; pointeur <= fin_expression_compilee ; pointeur++)
                    {
                    printf(" %02x",*pointeur);
                    }

          printf(" )\n");

          if        ((fin_expression_compilee-expression_compilee) > LONGUEUR)
                    {
                    printf("\n expression trop compliquee");
                    }
          else
                    {
                    }

          sous_chaineA=chaineA;
          indexA=0;
          indexR=0;

          while     (iterer == 0)
                    {
                    if        (step(sous_chaineA,expression_compilee) != 0)
                              {
                              if        ((loc1 != loc1_precedent) && (loc2 != loc2_precedent))
                                        {
                                        int       indexS=0;
                                        int       NSousExp=0;

                                        printf("\n loc1(%d)='%02x' loc2(%d)='%02x'",loc1,*loc1,loc2,*loc2);
                                        printf("\n nbra......................=%d",nbra);
                                        printf("\n sous_chaineA..............=(");

                                        for       (pointeur=sous_chaineA ; pointeur < loc2 ; pointeur++)
                                                  {
                                                  printf(" %02x",*pointeur);
                                                  }

                                        printf(" )\n");

                                        for       (NSousExp=1 ; NSousExp<=nbra ; NSousExp++)
                                                  {
                                                  char      *SousExp;
                                                  printf("\n sous-expression(%d)=",NSousExp);
                                                  for       (SousExp=_braslist[NSousExp-1] ; SousExp<_braelist[NSousExp-1] ; SousExp++)
                                                            {
                                                            printf("%c",*SousExp);
                                                            }
                                                  }

                                        for       (indexA=indexA ; indexA<(loc1-chaineA) ; indexA++)
                                                  {
                                                  *(chaineR+indexR) = *(chaineA+indexA);
                                                  indexR++;
                                                  }

                                        for       (indexS=indexS ; indexS<strlen(chaineS) ; indexS++)
                                                  {
                                                  *(chaineR+indexR) = *(chaineS+indexS);
                                                  indexR++;
                                                  }

                                        printf("\n trouvee='%02x' en (%d,%d)",*loc1,loc1-chaineA,loc2-chaineA);
                                        sous_chaineA=loc2;

                                        indexA=sous_chaineA-chaineA;

                                        loc1_precedent=loc1;
                                        loc2_precedent=loc2;
                                        }
                              else
                                        {
                                        printf("\n bouclage");
                                        iterer++;
                                        }
                              }
                    else
                              {
                              printf("\n fin (ou absente)");
                              iterer++;
                              }
                    }

          for       (indexA=indexA ; indexA<strlen(chaineA) ; indexA++)
                    {
                    *(chaineR+indexR) = *(chaineA+indexA);
                    indexR++;
                    }

          *(chaineR+indexR) = 0;

          printf("\n chaineA=%s",chaineA);
          printf("\n chaineR=%s",chaineR);
          printf("\n");
          }



Copyright © Jean-François Colonna, 2021-2021.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2021-2021.