/* ================================================================================ RPL/2 (R) version 4.1.32 Copyright (C) 1989-2020 Dr. BERTRAND Joël This file is part of RPL/2. RPL/2 is free software; you can redistribute it and/or modify it under the terms of the CeCILL V2 License as published by the french CEA, CNRS and INRIA. RPL/2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License for more details. You should have received a copy of the CeCILL License along with RPL/2. If not, write to info@cecill.info. ================================================================================ */ #include "rpl-conv.h" /* ================================================================================ Fonction 'neg' ================================================================================ Entrées : -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_neg(struct_processus *s_etat_processus) { logical1 drapeau; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; struct_liste_chainee *l_element_tampon; struct_objet *s_copie_argument; struct_objet *s_objet_argument; struct_objet *s_objet_resultat; integer8 i; integer8 j; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n NEG "); if ((*s_etat_processus).langue == 'F') { printf("(opposition)\n\n"); } else { printf("(opposition)\n\n"); } printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); printf("-> 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL); printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX); printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX); printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX); printf(" 1: %s, %s\n", d_NOM, d_ALG); printf("-> 1: %s\n\n", d_ALG); 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 = 1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } /* -------------------------------------------------------------------------------- Opposition d'un entier -------------------------------------------------------------------------------- */ if ((*s_objet_argument).type == INT) { if ((*((integer8 *) (*s_objet_argument).objet)) != INT64_MIN) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } /* * Permet d'éviter les résultats du type -0. Valable pour tous * les types... */ if ((*((integer8 *) (*s_objet_argument).objet)) != 0) { (*((integer8 *) (*s_objet_resultat).objet)) = -(*((integer8 *) (*s_objet_argument).objet)); } } else { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((real8 *) (*s_objet_resultat).objet)) = -((real8) (*((integer8 *) (*s_objet_argument).objet))); } } /* -------------------------------------------------------------------------------- Opposition d'un réel -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == REL) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((real8 *) (*s_objet_argument).objet)) != 0) { (*((real8 *) (*s_objet_resultat).objet)) = -(*((real8 *) (*s_objet_argument).objet)); } } /* -------------------------------------------------------------------------------- Opposition d'un complexe -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == CPL) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((struct_complexe16 *) (*s_objet_argument).objet)).partie_reelle != 0) { (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle = -(*((struct_complexe16 *) (*s_objet_argument).objet)) .partie_reelle; } if ((*((struct_complexe16 *) (*s_objet_argument).objet)) .partie_imaginaire != 0) { (*((struct_complexe16 *) (*s_objet_resultat).objet)) .partie_imaginaire = -(*((struct_complexe16 *) (*s_objet_argument).objet)) .partie_imaginaire; } } /* -------------------------------------------------------------------------------- Opposition d'un vecteur d'entiers -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == VIN) { drapeau = d_faux; for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet)) .taille; i++) { if (((integer8 *) (*((struct_vecteur *) (*s_objet_argument).objet)).tableau)[i] == INT64_MIN) { drapeau = d_vrai; break; } } if (drapeau == d_vrai) { if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*((struct_vecteur *) (*s_objet_argument) .objet)).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet)) .taille; i++) { if (((real8 *) (*(((struct_vecteur *) (*s_objet_argument).objet))).tableau)[i] != 0) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = -((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument).objet)).tableau)[i]); } else { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = 0; } } } else { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet))) .taille; i++) { if (((integer8 *) (*(((struct_vecteur *) (*s_objet_argument).objet))).tableau)[i] != 0) { ((integer8 *) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).tableau)[i] = -((integer8 *) (*(((struct_vecteur *) (*s_objet_argument).objet))).tableau)[i]; } } } } /* -------------------------------------------------------------------------------- Opposition d'un vecteur de réels -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == VRL) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet))) .taille; i++) { if (((real8 *) (*(((struct_vecteur *) (*s_objet_argument).objet))) .tableau)[i] != 0) { ((real8 *) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).tableau)[i] = -((real8 *) (*(((struct_vecteur *) (*s_objet_argument).objet))).tableau)[i]; } } } /* -------------------------------------------------------------------------------- Opposition d'un vecteur de complexes -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == VCX) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet))) .taille; i++) { if (((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument).objet))).tableau)[i].partie_reelle != 0) { ((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).tableau)[i].partie_reelle = -((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument).objet))).tableau)[i].partie_reelle; } if (((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument).objet))).tableau)[i].partie_imaginaire != 0) { ((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_resultat).objet))).tableau)[i] .partie_imaginaire = -((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument).objet))) .tableau)[i].partie_imaginaire; } } } /* -------------------------------------------------------------------------------- Opposition d'une matrice d'entiers -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == MIN) { drapeau = d_faux; for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet)) .nombre_lignes; i++) { for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet)) .nombre_colonnes; j++) { if (((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[i][j] == INT64_MIN) { drapeau = d_vrai; break; } } if (drapeau == d_vrai) { break; } } if (drapeau == d_vrai) { if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*((struct_matrice *) (*s_objet_argument) .objet)).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet)) .nombre_lignes; i++) { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i] = malloc(((size_t) ((*((struct_matrice *) (*s_objet_argument).objet)) .nombre_colonnes)) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*((struct_matrice *) (*s_objet_argument) .objet)).nombre_colonnes; j++) { if (((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[i][j] != 0) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = -((real8) ((integer8 **) (*(((struct_matrice *) (*s_objet_argument).objet))).tableau)[i][j]); } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = 0; } } } } else { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet)) .nombre_lignes; i++) { for(j = 0; j < (*((struct_matrice *) (*s_objet_argument) .objet)).nombre_colonnes; j++) { if (((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[i][j] != 0) { ((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = -((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[i][j]; } } } } } /* -------------------------------------------------------------------------------- Opposition d'une matrice de réels -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == MRL) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet))) .nombre_lignes; i++) { for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet))) .nombre_colonnes; j++) { if (((real8 **) (*(((struct_matrice *) (*s_objet_argument) .objet))).tableau)[i][j] != 0) { ((real8 **) (*(((struct_matrice *) (*s_objet_resultat) .objet))).tableau)[i][j] = -((real8 **) (*(((struct_matrice *) (*s_objet_argument).objet))).tableau)[i][j]; } } } } /* -------------------------------------------------------------------------------- Opposition d'une matrice de complexes -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == MCX) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'Q')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet))) .nombre_lignes; i++) { for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet))) .nombre_colonnes; j++) { if (((struct_complexe16 **) (*(((struct_matrice *) (*s_objet_argument).objet))).tableau)[i][j] .partie_reelle != 0) { ((struct_complexe16 **) (*(((struct_matrice *) (*s_objet_resultat).objet))).tableau)[i][j] .partie_reelle = -((struct_complexe16 **) (*(((struct_matrice *) (*s_objet_argument).objet))) .tableau)[i][j].partie_reelle; } if (((struct_complexe16 **) (*(((struct_matrice *) (*s_objet_argument).objet))).tableau)[i][j] .partie_imaginaire != 0) { ((struct_complexe16 **) (*(((struct_matrice *) (*s_objet_resultat).objet))).tableau)[i][j] .partie_imaginaire = -((struct_complexe16 **) (*(((struct_matrice *) (*s_objet_argument).objet))) .tableau)[i][j].partie_imaginaire; } } } } /* -------------------------------------------------------------------------------- Opposition d'un nom -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == NOM) { 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; 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 = 1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_neg; 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, "NEG"); 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 = NULL; } /* -------------------------------------------------------------------------------- Opposition d'une expression -------------------------------------------------------------------------------- */ else if (((*s_objet_argument).type == ALG) || ((*s_objet_argument).type == RPN)) { if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } liberation(s_etat_processus, s_objet_argument); s_objet_argument = s_copie_argument; l_element_courant = (struct_liste_chainee *) (*s_objet_argument).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; } drapeau = d_vrai; if ((*(*l_element_precedent).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_element_precedent).donnee) .objet)).nom_fonction, "NEG") == 0) { drapeau = d_faux; l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet; while((*l_element_courant).suivant != l_element_precedent) { l_element_courant = (*l_element_courant).suivant; } l_element_tampon = (*l_element_courant).suivant; (*l_element_courant).suivant = (*l_element_precedent).suivant; liberation(s_etat_processus, (*l_element_tampon).donnee); free(l_element_tampon); } } if (drapeau == d_vrai) { 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 = 1; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_neg; 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, "NEG"); (*(*l_element_precedent).suivant).suivant = l_element_courant; } s_objet_resultat = s_objet_argument; s_objet_argument = NULL; } /* -------------------------------------------------------------------------------- Opposition impossible -------------------------------------------------------------------------------- */ else { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet_argument); if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } return; } /* ================================================================================ Fonction 'not' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_not(struct_processus *s_etat_processus) { struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; struct_objet *s_copie_argument; struct_objet *s_objet_argument; struct_objet *s_objet_resultat; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n NOT "); if ((*s_etat_processus).langue == 'F') { printf("(complément)\n\n"); } else { printf("(complement)\n\n"); } printf(" 1: %s, %s\n", d_INT, d_REL); printf("-> 1: %s\n\n", d_INT); printf(" 1: %s\n", d_BIN); printf("-> 1: %s\n\n", d_BIN); printf(" 1: %s, %s\n", d_NOM, d_ALG); printf("-> 1: %s\n\n", d_ALG); 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 = 1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } /* -------------------------------------------------------------------------------- NOT logique -------------------------------------------------------------------------------- */ if (((*s_objet_argument).type == INT) || ((*s_objet_argument).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).type == INT) { if ((*((integer8 *) (*s_objet_argument).objet)) == 0) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } } else { if ((*((real8 *) (*s_objet_argument).objet)) == 0) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } } } /* -------------------------------------------------------------------------------- NOT binaire -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).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).objet)); } /* -------------------------------------------------------------------------------- NOT d'un nom -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == NOM) { 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; 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 = 1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_not; 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, "NOT"); 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 = NULL; } /* -------------------------------------------------------------------------------- NOT d'une expression -------------------------------------------------------------------------------- */ else if (((*s_objet_argument).type == ALG) || ((*s_objet_argument).type == RPN)) { if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_copie_argument).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; } 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 = 1; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_not; 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, "NOT"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_resultat = s_copie_argument; } /* -------------------------------------------------------------------------------- NOT impossible -------------------------------------------------------------------------------- */ else { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet_argument); if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } return; } /* ================================================================================ Fonction '<>' ================================================================================ Entrées : -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_ne(struct_processus *s_etat_processus) { struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_courant_1; struct_liste_chainee *l_element_courant_2; 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; struct_objet *s_objet_resultat_intermediaire; logical1 difference; integer8 i; integer8 j; integer8 nombre_elements; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n <> "); if ((*s_etat_processus).langue == 'F') { printf("(opérateur différence)\n\n"); } else { printf("(different)\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_INT); printf(" 2: %s\n", d_CHN); printf(" 1: %s\n", d_CHN); printf("-> 1: %s\n\n", d_INT); 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; } /* -------------------------------------------------------------------------------- SAME NOT sur des valeurs numériques -------------------------------------------------------------------------------- */ 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) { (*((integer8 *) (*s_objet_resultat).objet)) = ((*((integer8 *) (*s_objet_argument_1).objet)) != (*((integer8 *) (*s_objet_argument_2).objet))) ? -1 : 0; } else { (*((integer8 *) (*s_objet_resultat).objet)) = ((*((integer8 *) (*s_objet_argument_1).objet)) != (*((real8 *) (*s_objet_argument_2).objet))) ? -1 : 0; } } else { if ((*s_objet_argument_2).type == INT) { (*((integer8 *) (*s_objet_resultat).objet)) = ((*((real8 *) (*s_objet_argument_1).objet)) != (*((integer8 *) (*s_objet_argument_2).objet))) ? -1 : 0; } else { (*((integer8 *) (*s_objet_resultat).objet)) = ((*((real8 *) (*s_objet_argument_1).objet)) != (*((real8 *) (*s_objet_argument_2).objet))) ? -1 : 0; } } } /* -------------------------------------------------------------------------------- SAME NOT complexe -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == CPL)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet_resultat).objet)) = (((*((struct_complexe16 *) (*s_objet_argument_1).objet)) .partie_reelle != (*((struct_complexe16 *) (*s_objet_argument_2) .objet)).partie_reelle) || ((*((struct_complexe16 *) (*s_objet_argument_1).objet)).partie_imaginaire != ((*((struct_complexe16 *) (*s_objet_argument_1).objet)) .partie_imaginaire))) ? -1 : 0; } /* -------------------------------------------------------------------------------- SAME NOT binaire -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == BIN) && ((*s_objet_argument_2).type == BIN)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet_resultat).objet)) = ((*((logical8 *) (*s_objet_argument_1).objet)) != (*((logical8 *) (*s_objet_argument_2).objet))) ? -1 : 0; } /* -------------------------------------------------------------------------------- SAME NOT portant sur des chaînes de caractères -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == CHN) && ((*s_objet_argument_2).type == CHN)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet_resultat).objet)) = (strcmp((unsigned char *) (*s_objet_argument_1).objet, (unsigned char *) (*s_objet_argument_2).objet) != 0) ? -1 : 0; } /* -------------------------------------------------------------------------------- SAME NOT portant sur des listes -------------------------------------------------------------------------------- */ /* * Il y a de la récursivité dans l'air... */ else if ((((*s_objet_argument_1).type == LST) && ((*s_objet_argument_2).type == LST)) || (((*s_objet_argument_1).type == ALG) && ((*s_objet_argument_2).type == ALG)) || (((*s_objet_argument_1).type == RPN) && ((*s_objet_argument_2).type == RPN))) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant_1 = (struct_liste_chainee *) (*s_objet_argument_1).objet; l_element_courant_2 = (struct_liste_chainee *) (*s_objet_argument_2).objet; difference = d_faux; while((l_element_courant_1 != NULL) && (l_element_courant_2 != NULL) && (difference == d_faux)) { if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), (*l_element_courant_1).donnee) == d_erreur) { return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), (*l_element_courant_2).donnee) == d_erreur) { return; } instruction_same(s_etat_processus); (*l_element_courant_1).donnee = NULL; (*l_element_courant_2).donnee = NULL; if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_resultat_intermediaire) == d_erreur) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet_resultat_intermediaire).type != INT) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); liberation(s_etat_processus, s_objet_resultat); return; } difference = (*(((integer8 *) (*s_objet_resultat_intermediaire) .objet)) == 0) ? d_vrai : d_faux; liberation(s_etat_processus, s_objet_resultat_intermediaire); l_element_courant_1 = (*l_element_courant_1).suivant; l_element_courant_2 = (*l_element_courant_2).suivant; } if (((l_element_courant_1 != NULL) && (l_element_courant_2 == NULL)) || ((l_element_courant_1 == NULL) && (l_element_courant_2 != NULL))) { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } else { (*((integer8 *) (*s_objet_resultat).objet)) = (difference == d_vrai) ? -1 : 0; } } /* -------------------------------------------------------------------------------- SAME NOT portant sur des vecteurs -------------------------------------------------------------------------------- */ /* * Vecteurs d'entiers */ else if (((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == VIN)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { difference = d_faux; for(i = 0; (i < (*((struct_vecteur *) (*s_objet_argument_1).objet)) .taille) && (difference == d_faux); i++) { difference = (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i] == ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]) ? d_faux : d_vrai; } (*((integer8 *) (*s_objet_resultat).objet)) = (difference == d_vrai) ? -1 : 0; } } /* * Vecteurs de réels */ else if (((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == VRL)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { difference = d_faux; for(i = 0; (i < (*((struct_vecteur *) (*s_objet_argument_1).objet)) .taille) && (difference == d_faux); i++) { difference = (((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i] == ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]) ? d_faux : d_vrai; } (*((integer8 *) (*s_objet_resultat).objet)) = (difference == d_vrai) ? -1 : 0; } } /* * Vecteurs de complexes */ else if (((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == VCX)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { difference = d_faux; for(i = 0; (i < (*((struct_vecteur *) (*s_objet_argument_1).objet)) .taille) && (difference == d_faux); i++) { difference = ((((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i].partie_reelle == ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i].partie_reelle) && (((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i] .partie_imaginaire == ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)) .tableau)[i].partie_imaginaire)) ? d_faux : d_vrai; } (*((integer8 *) (*s_objet_resultat).objet)) = (difference == d_vrai) ? -1 : 0; } } /* -------------------------------------------------------------------------------- SAME NOT portant sur des matrices -------------------------------------------------------------------------------- */ /* * Matrice d'entiers */ else if (((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == MIN)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes) || ((*((struct_matrice *) (*s_objet_argument_1) .objet)).nombre_colonnes != (*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_colonnes)) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { difference = d_faux; for(i = 0; (i < (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes) && (difference == d_faux); i++) { for(j = 0; (j < (*((struct_matrice *) (*s_objet_argument_1) .objet)).nombre_colonnes) && (difference == d_faux); j++) { difference = (((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j] == ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]) ? d_faux : d_vrai; } } (*((integer8 *) (*s_objet_resultat).objet)) = (difference == d_vrai) ? -1 : 0; } } /* * Matrice de réels */ else if (((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == MRL)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes) || ((*((struct_matrice *) (*s_objet_argument_1) .objet)).nombre_colonnes != (*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_colonnes)) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { difference = d_faux; for(i = 0; (i < (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes) && (difference == d_faux); i++) { for(j = 0; (j < (*((struct_matrice *) (*s_objet_argument_1) .objet)).nombre_colonnes) && (difference == d_faux); j++) { difference = (((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j] == ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]) ? d_faux : d_vrai; } } (*((integer8 *) (*s_objet_resultat).objet)) = (difference == d_vrai) ? -1 : 0; } } /* * Matrice de complexes */ else if (((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == MCX)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes) || ((*((struct_matrice *) (*s_objet_argument_1) .objet)).nombre_colonnes != (*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_colonnes)) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { difference = d_faux; for(i = 0; (i < (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes) && (difference == d_faux); i++) { for(j = 0; (j < (*((struct_matrice *) (*s_objet_argument_1) .objet)).nombre_colonnes) && (difference == d_faux); j++) { difference = ((((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j] .partie_reelle == ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][j].partie_reelle) && (((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j] .partie_imaginaire == ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][j].partie_imaginaire)) ? d_faux : d_vrai; } } (*((integer8 *) (*s_objet_resultat).objet)) = (difference == d_vrai) ? -1 : 0; } } /* -------------------------------------------------------------------------------- SAME NOT 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_ne; 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; 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_ne; 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 = 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_ne; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).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_precedent) .suivant).donnee).objet)).nom_fonction, "<>"); (*(*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_ne; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).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_precedent) .suivant).donnee).objet)).nom_fonction, "<>"); (*(*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_precedent).suivant) .donnee).objet)).fonction = instruction_ne; 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, "<>"); } /* -------------------------------------------------------------------------------- SAME NOT nul -------------------------------------------------------------------------------- */ else { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet_resultat).objet)) = -1; } 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; } /* ================================================================================ Fonction 'next' ================================================================================ Entrées : -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_next(struct_processus *s_etat_processus) { struct_objet *s_objet; struct_objet *s_copie_objet; logical1 fin_boucle; logical1 presence_compteur; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n NEXT "); if ((*s_etat_processus).langue == 'F') { printf("(fin d'une boucle définie)\n\n"); } else { printf("(end of defined loop)\n\n"); } if ((*s_etat_processus).langue == 'F') { printf(" Utilisation :\n\n"); } else { printf(" Usage:\n\n"); } printf(" %s/%s %s/%s START\n", d_INT, d_REL, d_INT, d_REL); printf(" (expression)\n"); printf(" [EXIT]/[CYCLE]\n"); printf(" ...\n"); printf(" NEXT\n\n"); printf(" %s/%s %s/%s FOR (variable)\n", d_INT, d_REL, d_INT, d_REL); printf(" (expression)\n"); printf(" [EXIT]/[CYCLE]\n"); printf(" ...\n"); printf(" NEXT\n"); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'A') { // FOR ou START presence_compteur = ((*(*s_etat_processus).l_base_pile_systeme) .type_cloture == 'F') ? d_vrai : d_faux; if (((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'S') && (presence_compteur == d_faux)) { (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; return; } /* * Pour une boucle avec indice, on fait pointer * (*(*s_etat_processus).l_base_pile_systeme).indice_boucle sur * la variable correspondante. Remarque, le contenu de la variable * est détruit au courant de l'opération. */ if (presence_compteur == d_vrai) { if (recherche_variable(s_etat_processus, (*(*s_etat_processus) .l_base_pile_systeme).nom_variable) == d_faux) { (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; return; } if ((*(*s_etat_processus).pointeur_variable_courante) .variable_verrouillee == d_vrai) { (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; return; } if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { (*s_etat_processus).erreur_execution = d_ex_variable_partagee; return; } (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = (*(*s_etat_processus).pointeur_variable_courante).objet; } /* * Empilement pour calculer le nouvel indice. Au passage, la * variable (*(*s_etat_processus).l_base_pile_systeme).indice_boucle * est libérée. */ if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), (*(*s_etat_processus).l_base_pile_systeme).indice_boucle) == d_erreur) { return; } if ((s_objet = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet).objet)) = 1; if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet) == d_erreur) { return; } instruction_plus(s_etat_processus); if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if (((*s_objet).type != INT) && ((*s_objet).type != REL)) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; return; } if (presence_compteur == d_vrai) { /* * L'addition crée si besoin une copie de l'objet */ (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL; (*(*s_etat_processus).pointeur_variable_courante).objet = s_objet; } else { (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet; } if ((s_copie_objet = copie_objet(s_etat_processus, s_objet, 'P')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_copie_objet) == d_erreur) { return; } if ((s_copie_objet = copie_objet(s_etat_processus, (*(*s_etat_processus).l_base_pile_systeme) .limite_indice_boucle, 'P')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_copie_objet) == d_erreur) { return; } instruction_le(s_etat_processus); if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet).type != INT) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; return; } if ((*((integer8 *) (*s_objet).objet)) != 0) { if ((*(*s_etat_processus).l_base_pile_systeme) .origine_routine_evaluation == 'N') { (*s_etat_processus).position_courante = (*(*s_etat_processus) .l_base_pile_systeme).adresse_retour; } else { (*s_etat_processus).expression_courante = (*(*s_etat_processus) .l_base_pile_systeme).pointeur_objet_retour; } } else { depilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { return; } if (presence_compteur == d_vrai) { (*s_etat_processus).niveau_courant--; if (retrait_variables_par_niveau(s_etat_processus) == d_erreur) { return; } } } liberation(s_etat_processus, s_objet); } else { // FORALL if ((*(*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle) .type == NON) { // L'objet initial était vide. (*s_etat_processus).niveau_courant--; depilement_pile_systeme(s_etat_processus); liberation(s_etat_processus, (*(*s_etat_processus) .l_base_pile_systeme).limite_indice_boucle); return; } else if ((*(*(*s_etat_processus).l_base_pile_systeme) .limite_indice_boucle).type == LST) { // FORALL sur une liste if ((*((struct_liste_chainee *) (*(*(*s_etat_processus) .l_base_pile_systeme).indice_boucle).objet)).suivant != NULL) { if (recherche_variable(s_etat_processus, (*(*s_etat_processus) .l_base_pile_systeme).nom_variable) == d_faux) { (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; return; } if ((*(*s_etat_processus).pointeur_variable_courante) .variable_verrouillee == d_vrai) { (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; return; } if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { (*s_etat_processus).erreur_execution = d_ex_variable_partagee; return; } (*(*(*s_etat_processus).l_base_pile_systeme).indice_boucle) .objet = (*((struct_liste_chainee *) (*(*(*s_etat_processus).l_base_pile_systeme) .indice_boucle).objet)).suivant; liberation(s_etat_processus, (*(*s_etat_processus) .pointeur_variable_courante).objet); if (((*(*s_etat_processus).pointeur_variable_courante).objet = copie_objet(s_etat_processus, (*((struct_liste_chainee *) (*(*(*s_etat_processus) .l_base_pile_systeme).indice_boucle).objet)).donnee, 'P')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } fin_boucle = d_faux; } else { fin_boucle = d_vrai; } } else { // FORALL sur une table (*((integer8 *) (*(*(*s_etat_processus).l_base_pile_systeme) .indice_boucle).objet))++; if ((*((integer8 *) (*(*(*s_etat_processus).l_base_pile_systeme) .indice_boucle).objet)) < (integer8) (*((struct_tableau *) (*(*(*s_etat_processus).l_base_pile_systeme) .limite_indice_boucle).objet)).nombre_elements) { if (recherche_variable(s_etat_processus, (*(*s_etat_processus) .l_base_pile_systeme).nom_variable) == d_faux) { (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; return; } if ((*(*s_etat_processus).pointeur_variable_courante) .variable_verrouillee == d_vrai) { (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; return; } if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { (*s_etat_processus).erreur_execution = d_ex_variable_partagee; return; } liberation(s_etat_processus, (*(*s_etat_processus) .pointeur_variable_courante).objet); if (((*(*s_etat_processus).pointeur_variable_courante).objet = copie_objet(s_etat_processus, (*((struct_tableau *) (*(*(*s_etat_processus).l_base_pile_systeme) .limite_indice_boucle).objet)).elements[(*((integer8 *) (*(*(*s_etat_processus).l_base_pile_systeme) .indice_boucle).objet))], 'P')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } fin_boucle = d_faux; } else { fin_boucle = d_vrai; } } if (fin_boucle == d_vrai) { depilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { return; } (*s_etat_processus).niveau_courant--; if (retrait_variables_par_niveau(s_etat_processus) == d_erreur) { return; } } else { if ((*(*s_etat_processus).l_base_pile_systeme) .origine_routine_evaluation == 'N') { (*s_etat_processus).position_courante = (*(*s_etat_processus) .l_base_pile_systeme).adresse_retour; } else { (*s_etat_processus).expression_courante = (*(*s_etat_processus) .l_base_pile_systeme).pointeur_objet_retour; } } } return; } /* ================================================================================ Fonction 'nrand' ================================================================================ Entrées : structure processus ------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_nrand(struct_processus *s_etat_processus) { struct_objet *s_objet; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n NRAND "); if ((*s_etat_processus).langue == 'F') { printf("(valeur aléatoire gaussienne)\n\n"); } else { printf("(normal random number)\n\n"); } printf("-> 1: %s\n", d_REL); 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, 0) == d_erreur) { return; } } if ((*s_etat_processus).generateur_aleatoire == NULL) { initialisation_generateur_aleatoire(s_etat_processus, d_vrai, 0); } if ((s_objet = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((real8 *) (*s_objet).objet)) = gsl_ran_gaussian_ratio_method( (*s_etat_processus).generateur_aleatoire, 1.0); if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet) == d_erreur) { return; } return; } // vim: ts=4