rpl/src/instructions_r7.c - diff

Return to instructions_r7.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_r7.c between versions 1.17 and 1.20

-version 1.17, 2013/04/01 15:29:37
+version 1.20, 2013/09/04 10:03:19
  Line 1
  /*
  ================================================================================
-   RPL/2 (R) version 4.1.14
+   RPL/2 (R) version 4.1.15
    Copyright (C) 1989-2013 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 136  instruction_regex(struct_processus *s_et
              printf("(regular expression)\n\n");
          }
-         printf("    1: %s\n", d_LST);
+         printf("    2: %s\n", d_LST);
          printf("    1: %s\n", d_CHN);
          printf("->  1: %s\n\n", d_LST);
  Line 148  instruction_regex(struct_processus *s_et
      }
      else if ((*s_etat_processus).test_instruction == 'Y')
      {
-         (*s_etat_processus).nombre_arguments = 2;
+         (*s_etat_processus).nombre_arguments = -1;
          return;
      }
  Line 321  instruction_regex(struct_processus *s_et
      if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
              s_objet_resultat) == d_erreur)
+     {
+         return;
+     }
+     return;
+ }
+ /*
+ ================================================================================
+   Fonction 'rgdl'
+ ================================================================================
+   Entrées : pointeur sur une structure struct_processus
+ --------------------------------------------------------------------------------
+   Sorties :
+ --------------------------------------------------------------------------------
+   Effets de bord : néant
+ ================================================================================
+ */
+ void
+ instruction_rgdl(struct_processus *s_etat_processus)
+ {
+     integer8                        i;
+     integer8                        l;
+     struct_objet                    *s_objet_argument_1;
+     struct_objet                    *s_objet_argument_2;
+     struct_objet                    *s_objet_argument_3;
+     struct_objet                    *s_objet_resultat;
+     unsigned char                   *ptr_e;
+     unsigned char                   *ptr_l;
+     (*s_etat_processus).erreur_execution = d_ex;
+     if ((*s_etat_processus).affichage_arguments == 'Y')
+     {
+         printf("\n  RGDL ");
+         if ((*s_etat_processus).langue == 'F')
+         {
+             printf("(fer à droite)\n\n");
+         }
+         else
+         {
+             printf("(ragged left)\n\n");
+         }
+         printf("    3: %s\n", d_CHN);
+         printf("    2: %s\n", d_INT);
+         printf("    1: %s\n", d_CHN);
+         printf("->  1: %s\n", d_CHN);
+         return;
+     }
+     else if ((*s_etat_processus).test_instruction == 'Y')
+     {
+         (*s_etat_processus).nombre_arguments = -1;
+         return;
+     }
+     if (test_cfsf(s_etat_processus, 31) == d_vrai)
+     {
+         if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
+         {
+             return;
+         }
+     }
+     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             &s_objet_argument_1) == d_erreur)
+     {
+         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
+         return;
+     }
+     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             &s_objet_argument_2) == d_erreur)
+     {
+         liberation(s_etat_processus, s_objet_argument_1);
+         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
+         return;
+     }
+     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             &s_objet_argument_3) == d_erreur)
+     {
+         liberation(s_etat_processus, s_objet_argument_1);
+         liberation(s_etat_processus, s_objet_argument_2);
+         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
+         return;
+     }
+     if (((*s_objet_argument_1).type == CHN) &&
+             ((*s_objet_argument_2).type == INT) &&
+             ((*s_objet_argument_3).type == CHN))
+     {
+         if ((strlen((unsigned char *) (*s_objet_argument_1).objet) != 1) ||
+                 ((*((integer8 *) (*s_objet_argument_2).objet)) < 0))
+         {
+             liberation(s_etat_processus, s_objet_argument_1);
+             liberation(s_etat_processus, s_objet_argument_2);
+             liberation(s_etat_processus, s_objet_argument_3);
+             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
+             return;
+         }
+         if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if (((*s_objet_resultat).objet = malloc(((size_t) ((*((integer8 *)
+                 (*s_objet_argument_2).objet)) + 1)) * sizeof(unsigned char)))
+                 == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if (((l = (integer8) strlen((unsigned char *) (*s_objet_argument_3)
+                 .objet))) >= (*((integer8 *) (*s_objet_argument_2).objet)))
+         {
+             // Recadrage simple
+             ptr_e = (unsigned char *) (*s_objet_resultat).objet;
+             ptr_l = ((unsigned char *) (*s_objet_argument_3).objet)
+                     + (l - (*((integer8 *) (*s_objet_argument_2).objet)));
+             while((*ptr_l) != d_code_fin_chaine)
+             {
+                 *ptr_e++ = *ptr_l++;
+             }
+             (*ptr_e) = d_code_fin_chaine;
+         }
+         else
+         {
+             // Ajout des caractères
+             ptr_e = (unsigned char *) (*s_objet_resultat).objet;
+             ptr_l = (unsigned char *) (*s_objet_argument_3).objet;
+             for(i = 0; i < (*((integer8 *) (*s_objet_argument_2).objet)) - l;
+                     i++)
+             {
+                 *ptr_e++ = ((unsigned char *) (*s_objet_argument_1).objet)[0];
+             }
+             while((*ptr_l) != d_code_fin_chaine)
+             {
+                 *ptr_e++ = *ptr_l++;
+             }
+             (*ptr_e) = d_code_fin_chaine;
+         }
+     }
+     else
+     {
+         liberation(s_etat_processus, s_objet_argument_1);
+         liberation(s_etat_processus, s_objet_argument_2);
+         liberation(s_etat_processus, s_objet_argument_3);
+         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+         return;
+     }
+     liberation(s_etat_processus, s_objet_argument_1);
+     liberation(s_etat_processus, s_objet_argument_2);
+     liberation(s_etat_processus, s_objet_argument_3);
+     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             s_objet_resultat) == d_erreur)
+     {
+         return;
+     }
+     return;
+ }
+ /*
+ ================================================================================
+   Fonction 'rgdr'
+ ================================================================================
+   Entrées : pointeur sur une structure struct_processus
+ --------------------------------------------------------------------------------
+   Sorties :
+ --------------------------------------------------------------------------------
+   Effets de bord : néant
+ ================================================================================
+ */
+ void
+ instruction_rgdr(struct_processus *s_etat_processus)
+ {
+     integer8                        i;
+     integer8                        l;
+     struct_objet                    *s_objet_argument_1;
+     struct_objet                    *s_objet_argument_2;
+     struct_objet                    *s_objet_argument_3;
+     struct_objet                    *s_objet_resultat;
+     unsigned char                   *ptr_e;
+     unsigned char                   *ptr_l;
+     (*s_etat_processus).erreur_execution = d_ex;
+     if ((*s_etat_processus).affichage_arguments == 'Y')
+     {
+         printf("\n  RGDR ");
+         if ((*s_etat_processus).langue == 'F')
+         {
+             printf("(fer à gauche)\n\n");
+         }
+         else
+         {
+             printf("(ragged right)\n\n");
+         }
+         printf("    3: %s\n", d_CHN);
+         printf("    2: %s\n", d_INT);
+         printf("    1: %s\n", d_CHN);
+         printf("->  1: %s\n", d_CHN);
+         return;
+     }
+     else if ((*s_etat_processus).test_instruction == 'Y')
+     {
+         (*s_etat_processus).nombre_arguments = -1;
+         return;
+     }
+     if (test_cfsf(s_etat_processus, 31) == d_vrai)
+     {
+         if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
+         {
+             return;
+         }
+     }
+     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             &s_objet_argument_1) == d_erreur)
+     {
+         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
+         return;
+     }
+     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             &s_objet_argument_2) == d_erreur)
+     {
+         liberation(s_etat_processus, s_objet_argument_1);
+         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
+         return;
+     }
+     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             &s_objet_argument_3) == d_erreur)
+     {
+         liberation(s_etat_processus, s_objet_argument_1);
+         liberation(s_etat_processus, s_objet_argument_2);
+         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
+         return;
+     }
+     if (((*s_objet_argument_1).type == CHN) &&
+             ((*s_objet_argument_2).type == INT) &&
+             ((*s_objet_argument_3).type == CHN))
+     {
+         if ((strlen((unsigned char *) (*s_objet_argument_1).objet) != 1) ||
+                 ((*((integer8 *) (*s_objet_argument_2).objet)) < 0))
+         {
+             liberation(s_etat_processus, s_objet_argument_1);
+             liberation(s_etat_processus, s_objet_argument_2);
+             liberation(s_etat_processus, s_objet_argument_3);
+             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
+             return;
+         }
+         if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if (((*s_objet_resultat).objet = malloc(((size_t) ((*((integer8 *)
+                 (*s_objet_argument_2).objet)) + 1)) * sizeof(unsigned char)))
+                 == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if (((l = (integer8) strlen((unsigned char *) (*s_objet_argument_3)
+                 .objet))) >= (*((integer8 *) (*s_objet_argument_2).objet)))
+         {
+             // Recadrage simple
+             ptr_e = (unsigned char *) (*s_objet_resultat).objet;
+             ptr_l = ((unsigned char *) (*s_objet_argument_3).objet);
+             for(i = 0; i < (*((integer8 *) (*s_objet_argument_2).objet)); i++)
+             {
+                 *ptr_e++ = *ptr_l++;
+             }
+             (*ptr_e) = d_code_fin_chaine;
+         }
+         else
+         {
+             // Ajout des caractères
+             ptr_e = (unsigned char *) (*s_objet_resultat).objet;
+             ptr_l = (unsigned char *) (*s_objet_argument_3).objet;
+             while((*ptr_l) != d_code_fin_chaine)
+             {
+                 *ptr_e++ = *ptr_l++;
+             }
+             for(i = 0; i < (*((integer8 *) (*s_objet_argument_2).objet)) - l;
+                     i++)
+             {
+                 *ptr_e++ = ((unsigned char *) (*s_objet_argument_1).objet)[0];
+             }
+             (*ptr_e) = d_code_fin_chaine;
+         }
+     }
+     else
+     {
+         liberation(s_etat_processus, s_objet_argument_1);
+         liberation(s_etat_processus, s_objet_argument_2);
+         liberation(s_etat_processus, s_objet_argument_3);
+         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+         return;
+     }
+     liberation(s_etat_processus, s_objet_argument_1);
+     liberation(s_etat_processus, s_objet_argument_2);
+     liberation(s_etat_processus, s_objet_argument_3);
+     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             s_objet_resultat) == d_erreur)
      {
          return;
      }

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.17
changed lines
	Added in v.1.20