/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A P P A R I E M E N T   D E   P A R E N T H E S E S   E T   A U T R E S                                                    */
/*        C A R A C T E R E S   D U   M E M E   T Y P E  :                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Fonction :                                                                                                                 */
/*                                                                                                                                   */
/*                    Cette commande est destinee a reproduire                                                                       */
/*                  le fichier Argument jusqu'a la "fermeture"                                                                       */
/*                  d'un certain caractere ou bien l'inverse,                                                                        */
/*                  c'est-a-dire ne pas reproduire le fichier                                                                        */
/*                  jusqu'a la "fermeture" d'un certain caractere.                                                                   */
/*                                                                                                                                   */
/*                  Ainsi :                                                                                                          */
/*                                                                                                                                   */
/*                                      xxxx(yyyy(...)zzzz)tttt                                                                      */
/*                                                                                                                                   */
/*                  deviendra :                                                                                                      */
/*                                                                                                                                   */
/*                                      xxxx(yyyy(...)zzzz)                                                                          */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xcp/appariement$K' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 19990309105636).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N T E R F A C E   ' listG '  :                                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        :Debut_listG:                                                                                                              */
/*        :Fin_listG:                                                                                                                */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D I R E C T I V E S   S P E C I F I Q U E S   D E   C O M P I L A T I O N  :                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I C H I E R S   D ' I N C L U D E S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  INCLUDES_MINI

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   INVERSES_LE_PROCESSUS_D_APPARIEMENT                                                                                           \
                    FAUX                                                                                                                \
                                        /* En temps "normal" ('FAUX') la sortie a lieu du debut du fichier jusqu'au caractere        */ \
                                        /* "apparie" inclus ; l'inversion ('VRAI') permet de ne sortir que ce qui suit le caractere  */ \
                                        /* "apparie" (introduit le 20020206134816).                                                  */

#define   SYMBOLE_GAUCHE                                                                                                                \
                    K_PG                                                                                                                \
                                        /* Symbole gauche assurant l'ouverture...                                                    */
#define   SYMBOLE_DROITE                                                                                                                \
                    K_PD                                                                                                                \
                                        /* Symbole droite assurant la fermeture...                                                   */

#define   NOMBRE_DE_CARACTERES_A_CONSERVER_DERRIERE_LE_SYMBOLE_DROITE_FERMANT                                                           \
                    ZERO                                                                                                                \
                                        /* Nombre de caracteres a conserver derriere le symbole droite "fermant". Ceci a ete         */ \
                                        /* introduit le 20041206091340...                                                            */

#define   IGNORER_LES_APOSTROPHES_ET_LES_QUOTES                                                                                         \
                    VRAI                                                                                                                \
                                        /* Permet de controler les apostrophes et les quotes dans le fichier. Cet indicateur a ete   */ \
                                        /* introduit le 19990309131650 a cause de 'v $xiMo/CONTENTS$Z appariement' ou des quotes     */ \
                                        /* peuvent apparaitre dans des titres sans pour cela encadrer des chaines de caracteres ;    */ \
                                        /* cela peut aussi se retrouver evidemment dans des "abstracts"...                           */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A P P A R I E M E N T   D E   P A R E N T H E S E S   E T   A U T R E S                                                    */
/*        C A R A C T E R E S   D U   M E M E   T Y P E  :                                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(Logical,INIT(inverser_le_processus_d_appariement,INVERSES_LE_PROCESSUS_D_APPARIEMENT));
                                        /* En temps "normal" ('FAUX') la sortie a lieu du debut du fichier jusqu'au caractere        */
                                        /* "apparie" inclus ; l'inversion ('VRAI') permet de ne sortie que ce qui suit le caractere  */
                                        /* "apparie" (introduit le 20020206134816).                                                  */

     DEFV(CHAR,INIT(symbole_gauche,SYMBOLE_GAUCHE));
                                        /* Symbole gauche assurant l'ouverture...                                                    */
     DEFV(CHAR,INIT(symbole_droite,SYMBOLE_DROITE));
                                        /* Symbole droite assurant la fermeture...                                                   */

     DEFV(Int,INIT(nombre_de_caracteres_a_conserver_derriere_le_symbole_droite_fermant
                  ,NOMBRE_DE_CARACTERES_A_CONSERVER_DERRIERE_LE_SYMBOLE_DROITE_FERMANT
                   )
          );
                                        /* Nombre de caracteres a conserver derriere le symbole droite "fermant". Ceci a ete         */
                                        /* introduit le 20041206091340...                                                            */

     DEFV(Logical,INIT(ignorer_les_apostrophes_et_les_quotes,IGNORER_LES_APOSTROPHES_ET_LES_QUOTES));
                                        /* Permet de controler les apostrophes et les quotes dans le fichier. Cet indicateur a ete   */
                                        /* introduit le 19990309131650 a cause de 'v $xiMo/CONTENTS$Z appariement' ou des quotes     */
                                        /* peuvent apparaitre dans des titres sans pour cela encadrer des chaines de caracteres ;    */
                                        /* cela peut aussi se retrouver evidemment dans des "abstracts"...                           */

     DEFV(Char,INIT(caractere_courant,K_UNDEF));
                                        /* Caractere courant.                                                                        */
     DEFV(Logical,INIT(on_vient_de_rencontrer_une_apostrophe,FAUX));
                                        /* Cet indicateur indique en permanence si l'on vient de rencontrer                          */
                                        /* immediatement une apostrophe (') :                                                        */
                                        /*                                                                                           */
                                        /*                  VRAI    : apres la premiere rencontree,                                  */
                                        /*                  FAUX    : apres la seconde,                                              */
                                        /*                                                                                           */
                                        /* cet indicateur fonctionnant en bascule, puisque les apostrophes forment                   */
                                        /* des couples de parentheses...                                                             */
     DEFV(Logical,INIT(on_vient_de_rencontrer_une_quote,FAUX));
                                        /* Cet indicateur indique en permanence si l'on vient de rencontrer                          */
                                        /* immediatement une quote (") :                                                             */
                                        /*                                                                                           */
                                        /*                  VRAI    : apres la premiere rencontree,                                  */
                                        /*                  FAUX    : apres la seconde,                                              */
                                        /*                                                                                           */
                                        /* cet indicateur fonctionnant en bascule, puisque les quotes forment                        */
                                        /* des couples de parentheses...                                                             */
     DEFV(Logical,INIT(on_a_rencontre_au_moins_un_symbole_gauche,FAUX));
                                        /* Cet indicateur indique en permanence si l'on a rencontre au moins un symbole "gauche".    */
     DEFV(Int,INIT(compteur_d_imbrication,ZERO));
                                        /* Afin de compter les imbrications de {symbole_gauche,symbole_droite}.                      */
     DEFV(Int,INIT(numero_du_caractere_courant,ZERO));
     DEFV(Int,INIT(numero_du_symbole_droite_fermant,UNDEF));
                                        /* Afin de numeroter le 'symbole_droite' fermant (introduit le 20041206091340).              */
     /*..............................................................................................................................*/
     GET_ARGUMENTS_(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_L("inverser=",inverser_le_processus_d_appariement);
                         GET_ARGUMENT_K("ouverture=""gauche=",symbole_gauche);
                         GET_ARGUMENT_L("quotes=""quote=""ignorer=""apostrophes=""apostrophe="
                                       ,ignorer_les_apostrophes_et_les_quotes
                                        );
                         GET_ARGUMENT_I("derriere=""conserver="
                                       ,nombre_de_caracteres_a_conserver_derriere_le_symbole_droite_fermant
                                        );
                         )
                    );

     Choi(symbole_gauche)
          Bblock
          Ca1e(K_PG)
               Bblock
               EGAL(symbole_droite,K_PD);
                                        /* Association "(" --> ")".                                                                  */
               Eblock
          ECa1

          Ca1e(K_CG)
               Bblock
               EGAL(symbole_droite,K_CD);
                                        /* Association "[" --> "]".                                                                  */
               Eblock
          ECa1

          Ca1e(K_AG)
               Bblock
               EGAL(symbole_droite,K_AD);
                                        /* Association "{" --> "}".                                                                  */
               Eblock
          ECa1

          Defo
               Bblock
               PRINT_ERREUR("le caractere d'ouverture demande n'est pas reconnu");

               EGAL(symbole_gauche,SYMBOLE_GAUCHE);
               EGAL(symbole_droite,SYMBOLE_DROITE);
                                        /* Association "(" --> ")".                                                                  */
               Eblock
          EDef
          Eblock
     ECho

     Tant(GetcharT(caractere_courant))
          Bblock
                                        /* Le caractere courant de l'entree courante est recupere ; et on boucle                     */
                                        /* sur cette recuperation tant que l'on n'est pas au bout du fichier.                        */
          Test(IFET(EST_VRAI(on_a_rencontre_au_moins_un_symbole_gauche)
                   ,IZLE(compteur_d_imbrication)
                    )
               )
               Bblock
                                        /* Lorsque l'on a trouve l'appariement, on ne sort plus les caracteres courants du fichier,  */
                                        /* sauf si le processus doit etre inverse...                                                 */
               Test(IL_FAUT(inverser_le_processus_d_appariement))
                    Bblock
                    Test(IFLE(SOUS(numero_du_caractere_courant,numero_du_symbole_droite_fermant)
                             ,nombre_de_caracteres_a_conserver_derriere_le_symbole_droite_fermant
                              )
                         )
                                        /* Introduit le 20041207140358 afin de sauter quleques caracteres apres l'appariement...     */
                         Bblock
                         Eblock
                    ATes
                         Bblock
                         CALS(Putchar(caractere_courant));
                                        /* A partir du moment ou l'appariement a ete trouve, on sort les caracteres courants du      */
                                        /* fichier dans le cas du "processus inverse"...                                             */
                         Eblock
                    ETes
                    Eblock
               ATes
                    Bblock
                    Test(IFLE(SOUS(numero_du_caractere_courant,numero_du_symbole_droite_fermant)
                             ,nombre_de_caracteres_a_conserver_derriere_le_symbole_droite_fermant
                              )
                         )
                         Bblock
                         CALS(Putchar(caractere_courant));
                                        /* Introduit le 20041206091340 afin de garder, par exemple, un caractere ";" derriere        */
                                        /* une ")"...                                                                                */
                                        /*                                                                                           */
                                        /*Le 20041207091348, je donne le code utile pour verifier la bonne fermeture par un ";"      */
                                        /*des 'GET_ARGUMENTS?(...)' :                                                                */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*   :Debut_listG_FermetureDes_GET_ARGUMENTS_Par_K_POINT_VIRGULE:                            */
                                        /*                                                                                           */
                                        /*        $Z        set       FiLe_TmP=`GetXTmp`                                             */
                                        /*        $Z        $DELETE   $FiLe_TmP                                                      */
                                        /*                                                                                           */
                                        /*        $Z        set       VaLiDe=`$CA $FiLeA | $GRE '^ *GET_ARGUMENTS.('`                */
                                        /*                                                                                           */
                                        /*        $Z        if        ("$VaLiDe" != "$K_VIDE") then                                  */
                                        /*        $Z                  $CA       $FiLeA                                       |    \  */
                                        /*        $Z                  $SE       -e "s/\( GET_ARGUMENTS\).(/\1x /"            |    \  */
                                        /*        $Z                  $AW       " /GET_ARGUMENTSx/,/ECommande/ "             |    \  */
                                        /*        $Z                  $SE       -e "s/GET_ARGUMENTSx/GET_ARGUMENTSx(/"       |    \  */
                                        /*        $Z                  $xcp/appariement$X                                          \  */
                                        /*        $Z                            conserver=1                                       \  */
                                        /*        $Z                                                          > $FiLe_TmP            */
                                        /*        $Z                                                                                 */
                                        /*        $Z                  set       ErReUr=`$CA $FiLe_TmP | $GRE '^ *);$'`               */
                                        /*        $Z                                                                                 */
                                        /*        $Z                  if        ("$ErReUr" != "$K_VIDE") then                        */
                                        /*        $Z                            echo      "ERREUR : $FiLeA"                          */
                                        /*        $Z                  else                                                           */
                                        /*        $Z                  endif                                                          */
                                        /*        $Z                                                                                 */
                                        /*        $Z                  unset     ErReUr                                               */
                                        /*        $Z        else                                                                     */
                                        /*        $Z        endif                                                                    */
                                        /*        $Z                                                                                 */
                                        /*        $Z        unset     VaLiDe                                                         */
                                        /*                                                                                           */
                                        /*        $Z        $DELETE   $FiLe_TmP                                                      */
                                        /*        $Z        unset     FiLe_TmP                                                       */
                                        /*                                                                                           */
                                        /*   :Fin_listG_FermetureDes_GET_ARGUMENTS_Par_K_POINT_VIRGULE:                              */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* ou '$FiLeA' designe le fichier Argument a valider...                                      */
                         Eblock
                    ATes
                         Bblock
                         Eblock
                    ETes
                    Eblock
               ETes
               Eblock
          ATes
               Bblock
                                        /* Lorsque l'on a pas encore trouve l'appariement :                                          */
               Test(IL_FAUT(inverser_le_processus_d_appariement))
                    Bblock
                    Eblock
               ATes
                    Bblock
                    CALS(Putchar(caractere_courant));
                                        /* Tant que l'appariement n'est pas trouve, on sort les caracteres courants du fichier       */
                                        /* dans le cas du "processus normal"...                                                      */
                    Eblock
               ETes

               Test(IFET(IFEQ(caractere_courant,K_QUOTE),EST_FAUX(on_vient_de_rencontrer_une_apostrophe)))
                    Bblock
                    EGAL(on_vient_de_rencontrer_une_quote,NOTL(on_vient_de_rencontrer_une_quote));
                                        /* On gere les quotes comme des parentheses...                                               */
                    Eblock
               ATes
                    Bblock
                    Eblock
               ETes

               Test(IFET(IFEQ(caractere_courant,K_APOSTROPHE),EST_FAUX(on_vient_de_rencontrer_une_quote)))
                    Bblock
                    EGAL(on_vient_de_rencontrer_une_apostrophe,NOTL(on_vient_de_rencontrer_une_apostrophe));
                                        /* On gere les apostrophes comme des parentheses...                                          */
                    Eblock
               ATes
                    Bblock
                    Eblock
               ETes

               Test(IFEQ(caractere_courant,K_LF))
                    Bblock
                    EGAL(on_vient_de_rencontrer_une_apostrophe,FAUX);
                    EGAL(on_vient_de_rencontrer_une_quote,FAUX);
                                        /* Au changement de ligne, on reinitialise la gestion des quotes et apostrophes...           */
                    Eblock
               ATes
                    Bblock
                    Eblock
               ETes

               Test(IFOU(IL_FAUT(ignorer_les_apostrophes_et_les_quotes)
                        ,IFET(IL_NE_FAUT_PAS(ignorer_les_apostrophes_et_les_quotes)
                             ,IFET(EST_FAUX(on_vient_de_rencontrer_une_quote)
                                  ,EST_FAUX(on_vient_de_rencontrer_une_apostrophe)
                                   )
                              )
                         )
                    )
                    Bblock
                    Test(IFEQ(caractere_courant,symbole_gauche))
                         Bblock
                         INCR(compteur_d_imbrication,I);
                         EGAL(on_a_rencontre_au_moins_un_symbole_gauche,VRAI);
                                        /* Cas d'un symbole "ouvrant".                                                               */
                         Eblock
                    ATes
                         Bblock
                         Eblock
                    ETes

                    Test(IFEQ(caractere_courant,symbole_droite))
                         Bblock
                         DECR(compteur_d_imbrication,I);
                                        /* Cas d'un symbole "fermant".                                                               */

                         Test(IZEQ(compteur_d_imbrication))
                              Bblock
                              EGAL(numero_du_symbole_droite_fermant,numero_du_caractere_courant);
                                        /* Reperage du 'symbole_droite' fermant...                                                   */
                              Eblock
                         ATes
                              Bblock
                              Eblock
                         ETes
                         Eblock
                    ATes
                         Bblock
                         Eblock
                    ETes
                    Eblock
               ATes
                    Bblock
                    Eblock
               ETes
               Eblock
          ETes

          INCR(numero_du_caractere_courant,I);
          Eblock
     ETan

     RETU_Commande;
     Eblock
ECommande



Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.