[BACK]Return to instructions_e4.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_e4.c between versions 1.17.2.3 and 1.73

version 1.17.2.3, 2011/05/09 13:52:15 version 1.73, 2025/04/15 10:17:53
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.24    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 55  instruction_exsub(struct_processus *s_et Line 55  instruction_exsub(struct_processus *s_et
     unsigned char                   *registre_definitions_chainees;      unsigned char                   *registre_definitions_chainees;
     unsigned char                   *registre_instruction_courante;      unsigned char                   *registre_instruction_courante;
   
     unsigned long                   position_courante;      integer8                        position_courante;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 637  instruction_exget(struct_processus *s_et Line 637  instruction_exget(struct_processus *s_et
     {      {
         return;          return;
     }      }
   
       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;      return;
 }  }
Removed from v.1.17.2.3  
changed lines
  Added in v.1.73

CVSweb interface <joel.bertrand@systella.fr>