rpl/src/instructions_e4.c - diff

Return to instructions_e4.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_e4.c between versions 1.49 and 1.50

-version 1.49, 2014/07/17 08:07:20
+version 1.50, 2014/10/05 19:53:16
  Line 641  instruction_exget(struct_processus *s_et
      return;
  }
+ /*
+ ================================================================================
+   Fonction 'eqv'
+ ================================================================================
+   Entrées : pointeur sur une structure struct_processus
+ --------------------------------------------------------------------------------
+   Sorties :
+ --------------------------------------------------------------------------------
+   Effets de bord : néant
+ ================================================================================
+ */
+ void
+ instruction_eqv(struct_processus *s_etat_processus)
+ {
+     struct_liste_chainee        *l_element_courant;
+     struct_liste_chainee        *l_element_precedent;
+     struct_objet                *s_copie_argument_1;
+     struct_objet                *s_copie_argument_2;
+     struct_objet                *s_objet_argument_1;
+     struct_objet                *s_objet_argument_2;
+     struct_objet                *s_objet_resultat;
+     integer8                    nombre_elements;
+     (*s_etat_processus).erreur_execution = d_ex;
+     if ((*s_etat_processus).affichage_arguments == 'Y')
+     {
+         printf("\n  EQV ");
+         if ((*s_etat_processus).langue == 'F')
+         {
+             printf("(opérateur equivalence)\n\n");
+         }
+         else
+         {
+             printf("(equivalence operator)\n\n");
+         }
+         printf("    2: %s, %s\n", d_INT, d_REL);
+         printf("    1: %s, %s\n", d_INT, d_REL);
+         printf("->  1: %s\n\n", d_INT);
+         printf("    2: %s\n", d_BIN);
+         printf("    1: %s\n", d_BIN);
+         printf("->  1: %s\n\n", d_BIN);
+         printf("    2: %s\n", d_NOM);
+         printf("    1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
+         printf("->  1: %s\n\n", d_ALG);
+         printf("    2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
+         printf("    1: %s\n", d_NOM);
+         printf("->  1: %s\n\n", d_ALG);
+         printf("    2: %s\n", d_ALG);
+         printf("    1: %s\n", d_ALG);
+         printf("->  1: %s\n\n", d_ALG);
+         printf("    2: %s\n", d_RPN);
+         printf("    1: %s\n", d_RPN);
+         printf("->  1: %s\n", d_RPN);
+         return;
+     }
+     else if ((*s_etat_processus).test_instruction == 'Y')
+     {
+         (*s_etat_processus).nombre_arguments = 0;
+         return;
+     }
+     if (test_cfsf(s_etat_processus, 31) == d_vrai)
+     {
+         if (empilement_pile_last(s_etat_processus, 2) == 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;
+     }
+ /*
+ --------------------------------------------------------------------------------
+   EQV logique
+ --------------------------------------------------------------------------------
+ */
+     if ((((*s_objet_argument_1).type == INT) ||
+             ((*s_objet_argument_1).type == REL)) &&
+             (((*s_objet_argument_2).type == INT) ||
+             ((*s_objet_argument_2).type == REL)))
+     {
+         if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if ((*s_objet_argument_1).type == INT)
+         {
+             if ((*s_objet_argument_2).type == INT)
+             {
+                 if ((((*((integer8 *) (*s_objet_argument_1).objet)) == 0) &&
+                         ((*((integer8 *) (*s_objet_argument_2).objet)) == 0))
+                         || (((*((integer8 *) (*s_objet_argument_1).objet))
+                         != 0) && ((*((integer8 *) (*s_objet_argument_2).objet))
+                         != 0)))
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = -1;
+                 }
+                 else
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = 0;
+                 }
+             }
+             else
+             {
+                 if ((((*((integer8 *) (*s_objet_argument_1).objet)) == 0) &&
+                         ((*((real8 *) (*s_objet_argument_2).objet)) == 0))
+                         || (((*((integer8 *) (*s_objet_argument_1).objet))
+                         != 0) && ((*((real8 *) (*s_objet_argument_2).objet))
+                         != 0)))
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = -1;
+                 }
+                 else
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = 0;
+                 }
+             }
+         }
+         else
+         {
+             if ((*s_objet_argument_2).type == INT)
+             {
+                 if ((((*((real8 *) (*s_objet_argument_1).objet)) == 0) &&
+                         ((*((integer8 *) (*s_objet_argument_2).objet)) == 0))
+                         || (((*((real8 *) (*s_objet_argument_1).objet))
+                         != 0) && ((*((integer8 *) (*s_objet_argument_2).objet))
+                         != 0)))
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = -1;
+                 }
+                 else
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = 0;
+                 }
+             }
+             else
+             {
+                 if ((((*((real8 *) (*s_objet_argument_1).objet)) == 0) &&
+                         ((*((real8 *) (*s_objet_argument_2).objet)) == 0))
+                         || (((*((real8 *) (*s_objet_argument_1).objet))
+                         != 0) && ((*((real8 *) (*s_objet_argument_2).objet))
+                         != 0)))
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = -1;
+                 }
+                 else
+                 {
+                     (*((integer8 *) (*s_objet_resultat).objet)) = 0;
+                 }
+             }
+         }
+     }
+ /*
+ --------------------------------------------------------------------------------
+   EQV binaire
+ --------------------------------------------------------------------------------
+ */
+     else if (((*s_objet_argument_1).type == BIN) &&
+             ((*s_objet_argument_2).type == BIN))
+     {
+         if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*((logical8 *) (*s_objet_resultat).objet)) =
+                 ~((*((logical8 *) (*s_objet_argument_1).objet)) ^
+                 (*((logical8 *) (*s_objet_argument_2).objet)));
+     }
+ /*
+ --------------------------------------------------------------------------------
+    EQV entre des arguments complexes
+ --------------------------------------------------------------------------------
+ */
+     /*
+      * Nom ou valeur numérique / Nom ou valeur numérique
+      */
+     else if ((((*s_objet_argument_1).type == NOM) &&
+             (((*s_objet_argument_2).type == NOM) ||
+             ((*s_objet_argument_2).type == INT) ||
+             ((*s_objet_argument_2).type == REL))) ||
+             (((*s_objet_argument_2).type == NOM) &&
+             (((*s_objet_argument_1).type == INT) ||
+             ((*s_objet_argument_1).type == REL))))
+     {
+         if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if (((*s_objet_resultat).objet =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (*s_objet_resultat).objet;
+         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
+                 == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nombre_arguments = 0;
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .fonction = instruction_vers_niveau_superieur;
+         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction, "<<");
+         if (((*l_element_courant).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (*l_element_courant).suivant;
+         (*l_element_courant).donnee = s_objet_argument_2;
+         if (((*l_element_courant).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (*l_element_courant).suivant;
+         (*l_element_courant).donnee = s_objet_argument_1;
+         if (((*l_element_courant).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (*l_element_courant).suivant;
+         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
+                 == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nombre_arguments = 0;
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .fonction = instruction_xor;
+         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction, "EQV");
+         if (((*l_element_courant).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (*l_element_courant).suivant;
+         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
+                 == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nombre_arguments = 0;
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .fonction = instruction_vers_niveau_inferieur;
+         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction, ">>");
+         (*l_element_courant).suivant = NULL;
+         s_objet_argument_1 = NULL;
+         s_objet_argument_2 = NULL;
+     }
+     /*
+      * Nom ou valeur numérique / Expression
+      */
+     else if ((((*s_objet_argument_1).type == ALG) ||
+             ((*s_objet_argument_1).type == RPN)) &&
+             (((*s_objet_argument_2).type == NOM) ||
+             ((*s_objet_argument_2).type == INT) ||
+             ((*s_objet_argument_2).type == REL)))
+     {
+         nombre_elements = 0;
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_objet_argument_1).objet;
+         while(l_element_courant != NULL)
+         {
+             nombre_elements++;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         if (nombre_elements == 2)
+         {
+             liberation(s_etat_processus, s_objet_argument_1);
+             liberation(s_etat_processus, s_objet_argument_2);
+             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
+             return;
+         }
+         if ((s_objet_resultat = copie_objet(s_etat_processus,
+                 s_objet_argument_1, 'N')) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_objet_resultat).objet;
+         l_element_precedent = l_element_courant;
+         l_element_courant = (*l_element_courant).suivant;
+         if (((*l_element_precedent).suivant = (struct_liste_chainee *)
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
+         (*(*l_element_precedent).suivant).suivant = l_element_courant;
+         while((*l_element_courant).suivant != NULL)
+         {
+             l_element_precedent = l_element_courant;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         if (((*l_element_precedent).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if (((*(*l_element_precedent).suivant).donnee =
+                 allocation(s_etat_processus, FCT)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
+                 .donnee).objet)).nombre_arguments = 0;
+         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
+                 .donnee).objet)).fonction = instruction_xor;
+         if (((*((struct_fonction *) (*(*(*l_element_precedent)
+                 .suivant).donnee).objet)).nom_fonction =
+                 malloc(4 * sizeof(unsigned char))) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
+                 .suivant).donnee).objet)).nom_fonction, "EQV");
+         (*(*l_element_precedent).suivant).suivant = l_element_courant;
+         s_objet_argument_2 = NULL;
+     }
+     /*
+      * Expression / Nom ou valeur numérique
+      */
+     else if ((((*s_objet_argument_1).type == NOM) ||
+             ((*s_objet_argument_1).type == INT) ||
+             ((*s_objet_argument_1).type == REL)) &&
+             (((*s_objet_argument_2).type == ALG) ||
+             ((*s_objet_argument_2).type == RPN)))
+     {
+         nombre_elements = 0;
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_objet_argument_2).objet;
+         while(l_element_courant != NULL)
+         {
+             nombre_elements++;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         if (nombre_elements == 2)
+         {
+             liberation(s_etat_processus, s_objet_argument_1);
+             liberation(s_etat_processus, s_objet_argument_2);
+             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
+             return;
+         }
+         if ((s_objet_resultat = copie_objet(s_etat_processus,
+                 s_objet_argument_2, 'N')) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_objet_resultat).objet;
+         l_element_precedent = l_element_courant;
+         while((*l_element_courant).suivant != NULL)
+         {
+             l_element_precedent = l_element_courant;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         if (((*l_element_precedent).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
+         l_element_precedent = (*l_element_precedent).suivant;
+         if (((*l_element_precedent).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if (((*(*l_element_precedent).suivant).donnee =
+                 allocation(s_etat_processus, FCT)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
+                 .donnee).objet)).nombre_arguments = 0;
+         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
+                 .donnee).objet)).fonction = instruction_xor;
+         if (((*((struct_fonction *) (*(*(*l_element_precedent)
+                 .suivant).donnee).objet)).nom_fonction =
+                 malloc(4 * sizeof(unsigned char))) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
+                 .suivant).donnee).objet)).nom_fonction, "EQV");
+         (*(*l_element_precedent).suivant).suivant = l_element_courant;
+         s_objet_argument_1 = NULL;
+     }
+     /*
+      * Expression / Expression
+      */
+     else if ((((*s_objet_argument_1).type == ALG) &&
+             ((*s_objet_argument_2).type == ALG)) ||
+             (((*s_objet_argument_1).type == RPN) &&
+             ((*s_objet_argument_2).type == RPN)))
+     {
+         nombre_elements = 0;
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_objet_argument_1).objet;
+         while(l_element_courant != NULL)
+         {
+             nombre_elements++;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         if (nombre_elements == 2)
+         {
+             liberation(s_etat_processus, s_objet_argument_1);
+             liberation(s_etat_processus, s_objet_argument_2);
+             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
+             return;
+         }
+         nombre_elements = 0;
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_objet_argument_2).objet;
+         while(l_element_courant != NULL)
+         {
+             nombre_elements++;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         if (nombre_elements == 2)
+         {
+             liberation(s_etat_processus, s_objet_argument_1);
+             liberation(s_etat_processus, s_objet_argument_2);
+             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
+             return;
+         }
+         if ((s_copie_argument_1 = copie_objet(s_etat_processus,
+                 s_objet_argument_1, 'N')) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         if ((s_copie_argument_2 = copie_objet(s_etat_processus,
+                 s_objet_argument_2, 'N')) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_copie_argument_1).objet;
+         (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
+                 (*s_copie_argument_1).objet)).suivant;
+         liberation(s_etat_processus, (*l_element_courant).donnee);
+         free(l_element_courant);
+         l_element_courant = (struct_liste_chainee *)
+                 (*s_copie_argument_2).objet;
+         l_element_precedent = l_element_courant;
+         s_objet_resultat = s_copie_argument_2;
+         while((*l_element_courant).suivant != NULL)
+         {
+             l_element_precedent = l_element_courant;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         liberation(s_etat_processus, (*l_element_courant).donnee);
+         free(l_element_courant);
+         (*l_element_precedent).suivant = (struct_liste_chainee *)
+                 (*s_copie_argument_1).objet;
+         free(s_copie_argument_1);
+         l_element_courant = (*l_element_precedent).suivant;
+         while((*l_element_courant).suivant != NULL)
+         {
+             l_element_precedent = l_element_courant;
+             l_element_courant = (*l_element_courant).suivant;
+         }
+         if (((*l_element_precedent).suivant =
+                 allocation_maillon(s_etat_processus)) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*(*l_element_precedent).suivant).suivant = l_element_courant;
+         l_element_courant = (*l_element_precedent).suivant;
+         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
+                 == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nombre_arguments = 0;
+         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .fonction = instruction_xor;
+         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
+         {
+             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+             return;
+         }
+         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
+                 .nom_fonction, "EQV");
+     }
+ /*
+ --------------------------------------------------------------------------------
+   EQV impossible
+ --------------------------------------------------------------------------------
+ */
+     else
+     {
+         liberation(s_etat_processus, s_objet_argument_1);
+         liberation(s_etat_processus, s_objet_argument_2);
+         (*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);
+     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+             s_objet_resultat) == d_erreur)
+     {
+         return;
+     }
+     return;
+ }
  // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.49
changed lines
	Added in v.1.50