/* ================================================================================ RPL/2 (R) version 4.1.0 Copyright (C) 1989-2011 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 'swap' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_swap(struct_processus *s_etat_processus) { struct_liste_chainee *l_liste; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n SWAP "); if ((*s_etat_processus).langue == 'F') { printf("(inversion de deux objets)\n\n"); } else { printf("(swap two objects)\n\n"); } printf(" 2: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SLB, d_PRC, d_MTX, d_SQL); printf(" 1: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SLB, d_PRC, d_MTX, d_SQL); printf("-> 2: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SLB, d_PRC, d_MTX, d_SQL); printf(" 1: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SLB, d_PRC, d_MTX, d_SQL); 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, 2) == d_erreur) { return; } } if ((*s_etat_processus).hauteur_pile_operationnelle < 2) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } l_liste = (*s_etat_processus).l_base_pile; (*s_etat_processus).l_base_pile = (*l_liste).suivant; (*l_liste).suivant = (*(*s_etat_processus).l_base_pile).suivant; (*(*s_etat_processus).l_base_pile).suivant = l_liste; return; } /* ================================================================================ Fonction 'sq' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_sq(struct_processus *s_etat_processus) { integer8 a; integer8 r; logical1 depassement; logical1 erreur_memoire; 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; unsigned long i; unsigned long j; unsigned long k; void *accumulateur; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n SQ "); if ((*s_etat_processus).langue == 'F') { printf("(élevation au carré)\n\n"); } else { printf("(square)\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_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; } /* -------------------------------------------------------------------------------- Carré d'un entier -------------------------------------------------------------------------------- */ if ((*s_objet_argument).type == INT) { a = (*((integer8 *) (*s_objet_argument).objet)); if (depassement_multiplication(&a, &a, &r) == d_absence_erreur) { 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)) = r; } 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)) = ((double) (*((integer8 *) (*s_objet_argument).objet))) * ((double) (*((integer8 *) (*s_objet_argument).objet))); } } /* -------------------------------------------------------------------------------- Carré d'un réel -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == REL) { 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 *) (*s_objet_argument).objet)) * (*((real8 *) (*s_objet_argument).objet)); } /* -------------------------------------------------------------------------------- Carré d'un complexe -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == CPL) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77multiplicationcc_(&((*((struct_complexe16 *) (*s_objet_argument).objet))), &((*((struct_complexe16 *) (*s_objet_argument).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } /* -------------------------------------------------------------------------------- Carré d'une matrice entière -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == MIN) { if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes != (*((struct_matrice *) (*s_objet_argument).objet)) .nombre_colonnes) { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(integer8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } depassement = d_faux; for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_colonnes * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_colonnes; j++) { ((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes; k++) { if (depassement_multiplication(&(((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)) .tableau)[i][k]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)) .tableau)[k][j]), &a) == d_erreur) { depassement = d_vrai; } if (depassement_addition(&(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)) .tableau)[i][j]), &a, &r) == d_erreur) { depassement = d_vrai; } ((integer8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = r; } } } if (depassement == d_vrai) { (*s_objet_resultat).type = MRL; (*((struct_matrice *) (*s_objet_resultat).objet)).type = 'R'; if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument).objet))).nombre_colonnes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { free(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]); if (((*((struct_matrice *) (*s_objet_resultat).objet)) .tableau[i] = malloc((*(((struct_matrice *) (*s_objet_resultat).objet))).nombre_colonnes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_colonnes; j++) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes; k++) { ((real8 *) accumulateur)[k] = ((real8) (((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[i][k]) * ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[k][j])); } ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_reel(accumulateur, &((*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } } /* -------------------------------------------------------------------------------- Carré d'une matrice réelle -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == MRL) { if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes != (*((struct_matrice *) (*s_objet_argument).objet)) .nombre_colonnes) { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument).objet))).nombre_colonnes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_colonnes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_colonnes; j++) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes; k++) { ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[i][k] * ((real8 **) (*((struct_matrice *) (*s_objet_argument).objet)).tableau)[k][j]); } ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)) .tableau)[i][j] = sommation_vecteur_reel( accumulateur, &((*(((struct_matrice *) (*s_objet_argument).objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } /* -------------------------------------------------------------------------------- Carré d'une matrice complexe -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == MCX) { if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes != (*((struct_matrice *) (*s_objet_argument).objet)) .nombre_colonnes) { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument).objet))).nombre_colonnes * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_colonnes * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_colonnes; j++) { ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] .partie_reelle = 0; ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] .partie_imaginaire = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument) .objet))).nombre_colonnes; k++) { f77multiplicationcc_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument).objet)) .tableau)[i][k]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument).objet)) .tableau)[k][j]), &(((complex16 *) accumulateur)[k])); } ((complex16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_complexe(accumulateur, &((*(((struct_matrice *) (*s_objet_argument).objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } /* -------------------------------------------------------------------------------- Carré 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_sq; 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, "SQ"); 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; } /* -------------------------------------------------------------------------------- Carré 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_sq; 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, "SQ"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_resultat = s_copie_argument; } /* -------------------------------------------------------------------------------- Carré 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 'sqrt' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_sqrt(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 SQRT "); if ((*s_etat_processus).langue == 'F') { printf("(racine carrée)\n\n"); } else { printf("(square root)\n\n"); } printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); printf("-> 1: %s, %s\n\n", d_REL, d_CPL); 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; } /* -------------------------------------------------------------------------------- Racine carrée d'un entier -------------------------------------------------------------------------------- */ if ((*s_objet_argument).type == INT) { if ((*((integer8 *) (*s_objet_argument).objet)) >= 0) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77racinecarreeip_(&((*((integer8 *) (*s_objet_argument).objet))), &((*((real8 *) (*s_objet_resultat).objet)))); } else { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77racinecarreein_(&((*((integer8 *) (*s_objet_argument).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } } /* -------------------------------------------------------------------------------- Racine carré d'un réel -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == REL) { if ((*((real8 *) (*s_objet_argument).objet)) >= 0) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77racinecarreerp_(&((*((real8 *) (*s_objet_argument).objet))), &((*((real8 *) (*s_objet_resultat).objet)))); } else { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77racinecarreern_(&((*((real8 *) (*s_objet_argument).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } } /* -------------------------------------------------------------------------------- Racine carrée d'un complexe -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == CPL) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77racinecarreec_(&((*((struct_complexe16 *) (*s_objet_argument) .objet))), &((*((struct_complexe16 *) (*s_objet_resultat) .objet)))); } /* -------------------------------------------------------------------------------- Racine carrée 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_sqrt; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "SQRT"); 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; } /* -------------------------------------------------------------------------------- Racine carrée 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_sqrt; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(5 * 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, "SQRT"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_resultat = s_copie_argument; } /* -------------------------------------------------------------------------------- Racine carrée 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 'same' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_same(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; unsigned long i; unsigned long j; unsigned long nombre_elements; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n SAME "); if ((*s_etat_processus).langue == 'F') { printf("(opérateur égalité)\n\n"); } else { printf("(equality operator)\n\n"); } printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL); printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); 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_LST); printf(" 1: %s\n", d_LST); printf("-> 1: %s\n\n", d_INT); printf(" 2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX); printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX); printf("-> 1: %s\n\n", d_INT); printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); printf("-> 1: %s\n\n", d_INT); printf(" 2: %s\n", d_TAB); printf(" 1: %s\n", d_TAB); 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); printf(" 2: %s\n", d_PRC); printf(" 1: %s\n", d_PRC); printf("-> 1: %s\n", d_INT); 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, 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 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 Processus -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == PRC) && ((*s_objet_argument_2).type == PRC)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet)).thread) .processus_detache != (*(*((struct_processus_fils *) (*s_objet_argument_2).objet)).thread).processus_detache) { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } else { if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet)) .thread).processus_detache == d_vrai) { (*((integer8 *) (*s_objet_resultat).objet)) = ((*(*((struct_processus_fils *) (*s_objet_argument_1) .objet)).thread).pid == (*(*((struct_processus_fils *) (*s_objet_argument_2) .objet)).thread).pid) ? -1 : 0; } else { (*((integer8 *) (*s_objet_resultat).objet)) = ((pthread_equal((*(*((struct_processus_fils *) (*s_objet_argument_1).objet)).thread).tid, (*(*((struct_processus_fils *) (*s_objet_argument_2) .objet)).thread).tid) != 0) && ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet)).thread).pid == (*(*((struct_processus_fils *) (*s_objet_argument_2) .objet)).thread).pid)) ? -1 : 0; } } } /* -------------------------------------------------------------------------------- SAME 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 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 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 portant sur des listes ou (instruction "SAME") des expressions -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == FCT) && ((*s_objet_argument_2).type == FCT)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((strcmp((*((struct_fonction *) (*s_objet_argument_1).objet)) .nom_fonction, (*((struct_fonction *) (*s_objet_argument_2) .objet)).nom_fonction) == 0) && ((*((struct_fonction *) (*s_objet_argument_1).objet)) .nombre_arguments == (*((struct_fonction *) (*s_objet_argument_2).objet)).nombre_arguments)) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } } /* * 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))) && (strcmp((*s_etat_processus).instruction_courante, "==") != 0))) { 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 ((s_copie_argument_1 = copie_objet(s_etat_processus, (*l_element_courant_1).donnee, '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_argument_1) == d_erreur) { return; } if ((s_copie_argument_2 = copie_objet(s_etat_processus, (*l_element_courant_2).donnee, '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_argument_2) == d_erreur) { return; } instruction_same(s_etat_processus); 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); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 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 ((difference == d_vrai) || ((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)) = -1; } } /* -------------------------------------------------------------------------------- SAME portant sur des tables des expressions -------------------------------------------------------------------------------- */ /* * Il y a de la récursivité dans l'air... */ else if (((*s_objet_argument_1).type == TBL) && ((*s_objet_argument_2).type == TBL) && (strcmp((*s_etat_processus).instruction_courante, "==") != 0)) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((struct_tableau *) (*s_objet_argument_1).objet)).nombre_elements != (*((struct_tableau *) (*s_objet_argument_2).objet)) .nombre_elements) { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } else { difference = d_faux; for(i = 0; i < (*((struct_tableau *) (*s_objet_argument_1).objet)) .nombre_elements; i++) { if ((s_copie_argument_1 = copie_objet(s_etat_processus, (*((struct_tableau *) (*s_objet_argument_1).objet)).elements[i], '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_argument_1) == d_erreur) { return; } if ((s_copie_argument_2 = copie_objet(s_etat_processus, (*((struct_tableau *) (*s_objet_argument_2).objet)).elements[i], '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_argument_2) == d_erreur) { return; } instruction_same(s_etat_processus); 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); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } difference = (*(((integer8 *) (*s_objet_resultat_intermediaire) .objet)) == 0) ? d_vrai : d_faux; liberation(s_etat_processus, s_objet_resultat_intermediaire); } if (difference == d_vrai) { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } else { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } } } /* -------------------------------------------------------------------------------- SAME 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)) = 0; } 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_faux) ? -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)) = 0; } 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_faux) ? -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)) = 0; } 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_faux) ? -1 : 0; } } /* -------------------------------------------------------------------------------- SAME 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)) = 0; } 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_faux) ? -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)) = 0; } 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_faux) ? -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)) = 0; } 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_faux) ? -1 : 0; } } /* -------------------------------------------------------------------------------- SAME portant sur des noms (instruction "SAME") -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == NOM) && ((*s_objet_argument_2).type == NOM) && (strcmp((*s_etat_processus).instruction_courante, "==") != 0)) { 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((*((struct_nom *) (*s_objet_argument_1).objet)).nom, (*((struct_nom *) (*s_objet_argument_2).objet)).nom) == 0) ? -1 : 0; } /* -------------------------------------------------------------------------------- SAME entre des arguments complexes (instruction '==') -------------------------------------------------------------------------------- */ /* * 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)))) && (strcmp((*s_etat_processus).instruction_courante, "==") == 0)) { 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_same; 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_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)) && (strcmp((*s_etat_processus).instruction_courante, "==") == 0)) && (((*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_same; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc((strlen((*s_etat_processus).instruction_courante) + 1) * 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, (*s_etat_processus).instruction_courante); (*(*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)) && (strcmp((*s_etat_processus).instruction_courante, "==") == 0))) { 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_same; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc((strlen((*s_etat_processus).instruction_courante) + 1) * 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, (*s_etat_processus).instruction_courante); (*(*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) && (strcmp((*s_etat_processus).instruction_courante, "==") == 0)) || (((*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_same; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc((strlen( (*s_etat_processus).instruction_courante) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, (*s_etat_processus).instruction_courante); } /* -------------------------------------------------------------------------------- SAME 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)) = 0; } 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 'start' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_start(struct_processus *s_etat_processus) { struct_objet *s_objet_1; struct_objet *s_objet_2; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n START "); if ((*s_etat_processus).langue == 'F') { printf("(boucle définie sans compteur)\n\n"); } else { printf("(define a loop without counter)\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 START\n", d_INT, d_REL, d_INT, d_REL); printf(" (expression)\n"); printf(" [EXIT]/[CYCLE]\n"); printf(" ...\n"); printf(" %s/%s STEP\n", d_INT, d_REL); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if ((*s_etat_processus).erreur_systeme != d_es) { return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 2) == d_erreur) { return; } } empilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { return; } (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'S'; if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_1) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if (((*s_objet_1).type != INT) && ((*s_objet_1).type != REL)) { liberation(s_etat_processus, s_objet_1); (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; return; } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_2) == d_erreur) { liberation(s_etat_processus, s_objet_1); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if (((*s_objet_2).type != INT) && ((*s_objet_2).type != REL)) { liberation(s_etat_processus, s_objet_1); liberation(s_etat_processus, s_objet_2); (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; return; } (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet_2; (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1; if ((*s_etat_processus).mode_execution_programme == 'Y') { (*(*s_etat_processus).l_base_pile_systeme).adresse_retour = (*s_etat_processus).position_courante; (*(*s_etat_processus).l_base_pile_systeme) .origine_routine_evaluation = 'N'; } else { (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour = (*s_etat_processus).expression_courante; (*(*s_etat_processus).l_base_pile_systeme) .origine_routine_evaluation = 'Y'; } return; } /* ================================================================================ Fonction 'step' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_step(struct_processus *s_etat_processus) { struct_objet *s_objet; struct_objet *s_copie_objet; logical1 incrementation; logical1 presence_compteur; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n STEP "); 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(" (value) STEP\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(" (value) STEP\n"); 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; } } 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; } 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) && ((*s_objet).type != REL)) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; return; } if ((*s_objet).type == INT) { incrementation = ((*((integer8 *) (*s_objet).objet)) >= 0) ? d_vrai : d_faux; } else { incrementation = ((*((real8 *) (*s_objet).objet)) >= 0) ? d_vrai : d_faux; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet) == d_erreur) { 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) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; return; } if ((*(*s_etat_processus).pointeur_variable_courante) .variable_verrouillee == d_vrai) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; return; } if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { liberation(s_etat_processus, s_objet); (*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; } instruction_plus(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) && ((*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; } if (incrementation == d_vrai) { instruction_le(s_etat_processus); } else { instruction_ge(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_variable_par_niveau(s_etat_processus) == d_erreur) { return; } } } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction 'sf' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_sf(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 SF "); if ((*s_etat_processus).langue == 'F') { printf("(positionne un indicateur binaire)\n\n"); } else { printf("(set flag)\n\n"); } printf(" 1: 1 <= %s <= 64\n", d_INT); 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) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet).type == INT) { if (((*((integer8 *) (*s_objet).objet)) < 1) || ((*((integer8 *) (*s_objet).objet)) > 64)) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_drapeau_inexistant; return; } sf(s_etat_processus, (unsigned char) (*((integer8 *) (*s_objet).objet))); } else { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction 'stof' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_stof(struct_processus *s_etat_processus) { struct_objet *s_objet; t_8_bits masque; unsigned char indice_bit; unsigned char indice_bloc; unsigned char indice_drapeau; unsigned char taille_bloc; unsigned long i; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n STOF "); if ((*s_etat_processus).langue == 'F') { printf("(positionne les drapeaux d'état)\n\n"); } else { printf("(set flags)\n\n"); } printf("-> 1: %s\n", d_BIN); 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) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet).type == BIN) { taille_bloc = sizeof(t_8_bits) * 8; for(i = 0; i < 8; (*s_etat_processus).drapeaux_etat[i++] = 0); for(i = 1; i <= 64; i++) { indice_drapeau = i - 1; indice_bloc = indice_drapeau / taille_bloc; indice_bit = indice_drapeau % taille_bloc; masque = ((t_8_bits) 1) << (taille_bloc - indice_bit - 1); if (((*((logical8 *) (*s_objet).objet)) & ((logical8) 1) << indice_drapeau) != 0) { (*s_etat_processus).drapeaux_etat[indice_bloc] |= masque; } } } else { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction 'sto' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_sto(struct_processus *s_etat_processus) { struct_objet *s_objet_1; struct_objet *s_objet_2; struct_variable s_variable; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n STO "); if ((*s_etat_processus).langue == 'F') { printf("(affecte un objet à une variable)\n\n"); } else { printf("(store an object in a variable)\n\n"); } printf(" 2: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SLB, d_PRC, d_MTX, d_SQL); printf(" 1: %s\n", d_NOM); 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, 2) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_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_2) == d_erreur) { liberation(s_etat_processus, s_objet_1); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet_1).type != NOM) { liberation(s_etat_processus, s_objet_1); liberation(s_etat_processus, s_objet_2); (*s_etat_processus).erreur_execution = d_ex_nom_invalide; return; } if (recherche_variable(s_etat_processus, (*((struct_nom *) (*s_objet_1).objet)).nom) == d_vrai) { /* * La variable est accessible. */ if ((*(*s_etat_processus).pointeur_variable_courante) .variable_verrouillee == d_vrai) { liberation(s_etat_processus, s_objet_1); liberation(s_etat_processus, s_objet_2); (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; return; } if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { if (pthread_mutex_lock(&((*(*s_etat_processus) .s_liste_variables_partagees).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (recherche_variable_partagee(s_etat_processus, (*(*s_etat_processus).pointeur_variable_courante).nom, (*(*s_etat_processus).pointeur_variable_courante) .variable_partagee, (*(*s_etat_processus) .pointeur_variable_courante).origine) == d_faux) { if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if ((*s_etat_processus).autorisation_nom_implicite == 'N') { liberation(s_etat_processus, s_objet_1); liberation(s_etat_processus, s_objet_2); (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex_creation_variable_globale; return; } if ((s_variable.nom = malloc((strlen((*((struct_nom *) (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_1).objet)).nom); s_variable.niveau = 1; /* * Le niveau 0 correspond aux définitions. Les variables * commencent à 1 car elles sont toujours incluses dans * une définition. */ s_variable.objet = s_objet_2; if (creation_variable(s_etat_processus, &s_variable, 'V', 'P') == d_erreur) { return; } (*s_etat_processus).erreur_systeme = d_es; } else { liberation(s_etat_processus, (*(*s_etat_processus) .s_liste_variables_partagees).table [(*(*s_etat_processus).s_liste_variables_partagees) .position_variable].objet); (*(*s_etat_processus).s_liste_variables_partagees).table [(*(*s_etat_processus).s_liste_variables_partagees) .position_variable].objet = s_objet_2; if (pthread_mutex_unlock(&((*(*s_etat_processus) .s_liste_variables_partagees).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } } else { if ((*s_etat_processus).autorisation_nom_implicite == 'N') { if ((*(*s_etat_processus).pointeur_variable_courante) .niveau == 1) { liberation(s_etat_processus, s_objet_1); liberation(s_etat_processus, s_objet_2); (*s_etat_processus).erreur_execution = d_ex_creation_variable_globale; return; } } liberation(s_etat_processus, (*(*s_etat_processus).pointeur_variable_courante).objet); (*(*s_etat_processus).pointeur_variable_courante).objet = s_objet_2; } } else { /* * La variable n'est pas accessible ou n'existe pas et on crée * une variable globale. */ if ((*s_etat_processus).autorisation_nom_implicite == 'N') { liberation(s_etat_processus, s_objet_1); liberation(s_etat_processus, s_objet_2); (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex_creation_variable_globale; return; } if ((s_variable.nom = malloc((strlen((*((struct_nom *) (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_1).objet)).nom); s_variable.niveau = 1; /* * Le niveau 0 correspond aux définitions. Les variables * commencent à 1 car elles sont toujours incluses dans * une définition. */ s_variable.objet = s_objet_2; if (creation_variable(s_etat_processus, &s_variable, 'V', 'P') == d_erreur) { return; } (*s_etat_processus).erreur_systeme = d_es; } liberation(s_etat_processus, s_objet_1); return; } /* ================================================================================ Fonction 'syseval' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_syseval(struct_processus *s_etat_processus) { char **arguments; int ios; int pipes_entree[2]; int pipes_erreur[2]; int pipes_sortie[2]; int status; logical1 drapeau_fin; logical1 presence_stdin; long i; long nombre_arguments; pid_t pid; sigset_t oldset; sigset_t set; ssize_t longueur_ecriture; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; struct_liste_chainee *l_element_stdin; struct_objet *s_objet; struct_objet *s_objet_composite; struct_objet *s_objet_resultat; struct_objet *s_objet_temporaire; struct sigaction action_courante; struct sigaction action_passee; unsigned char *ptr; unsigned char *ptr2; unsigned char registre_autorisation_empilement_programme; unsigned char *registre_instruction_courante; unsigned char *registre_programme; unsigned char *tampon; unsigned long longueur_lecture; unsigned long longueur_tampon; unsigned long nombre_iterations; unsigned long nombre_lignes; unsigned long pointeur; unsigned long registre_position_courante; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n SYSEVAL "); if ((*s_etat_processus).langue == 'F') { printf("(exécute une commande système)\n\n"); } else { printf("(execute a shell command)\n\n"); } printf(" 1: %s\n", d_CHN); printf("-> 1: %s\n\n", d_LST); printf(" 1: %s\n", d_LST); printf("-> 1: %s\n", d_LST); 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) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } s_objet_composite = NULL; l_element_stdin = NULL; presence_stdin = d_faux; if ((*s_objet).type == LST) { s_objet_composite = s_objet; s_objet = (*((struct_liste_chainee *) (*s_objet_composite) .objet)).donnee; l_element_stdin = (*((struct_liste_chainee *) (*s_objet_composite) .objet)).suivant; l_element_courant = l_element_stdin; if (l_element_courant == NULL) { liberation(s_etat_processus, s_objet_composite); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } while(l_element_courant != NULL) { if ((*(*l_element_courant).donnee).type != CHN) { liberation(s_etat_processus, s_objet_composite); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } l_element_courant = (*l_element_courant).suivant; } presence_stdin = d_vrai; } if ((*s_objet).type == CHN) { registre_autorisation_empilement_programme = (*s_etat_processus).autorisation_empilement_programme; registre_instruction_courante = (*s_etat_processus).instruction_courante; registre_programme = (*s_etat_processus).definitions_chainees; registre_position_courante = (*s_etat_processus).position_courante; (*s_etat_processus).definitions_chainees = (unsigned char *) (*s_objet).objet; (*s_etat_processus).position_courante = 0; (*s_etat_processus).autorisation_empilement_programme = 'N'; /* * Échappement des guillemets */ ptr = (*s_etat_processus).definitions_chainees; ptr2 = ptr; i = 0; while((*ptr) != d_code_fin_chaine) { if ((*ptr) == '\\') { switch (*(ptr + 1)) { case '"': case '\\': { ptr++; break; } } } *ptr2++ = *ptr++; } *ptr2 = d_code_fin_chaine; /* * Scission de la chaîne en différents arguments */ nombre_arguments = 0; drapeau_fin = d_faux; do { if (recherche_instruction_suivante(s_etat_processus) == d_erreur) { (*s_etat_processus).autorisation_empilement_programme = registre_autorisation_empilement_programme; (*s_etat_processus).instruction_courante = registre_instruction_courante; (*s_etat_processus).definitions_chainees = registre_programme; (*s_etat_processus).position_courante = registre_position_courante; return; } if ((*(*s_etat_processus).instruction_courante) != d_code_fin_chaine) { if ((s_objet_temporaire = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).autorisation_empilement_programme = registre_autorisation_empilement_programme; (*s_etat_processus).instruction_courante = registre_instruction_courante; (*s_etat_processus).definitions_chainees = registre_programme; (*s_etat_processus).position_courante = registre_position_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*s_objet_temporaire).objet = (*s_etat_processus) .instruction_courante; /* * S'il y a des guillemets en début de chaîne, il y en * a aussi à la fin de la chaîne et on les ôte. Les * guillements intermédiaires sont protégés par une * séquence d'échappement qui est enlevée. */ if ((*s_etat_processus).instruction_courante[0] == '"') { if (strlen((*s_etat_processus).instruction_courante) >= 2) { ptr = (*s_etat_processus).instruction_courante; ptr2 = ptr + 1; while((*ptr2) != d_code_fin_chaine) { *ptr++ = *ptr2++; } (*(--ptr)) = d_code_fin_chaine; } } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_temporaire) == d_erreur) { return; } } else { free((*s_etat_processus).instruction_courante); drapeau_fin = d_vrai; } nombre_arguments++; } while(drapeau_fin == d_faux); (*s_etat_processus).autorisation_empilement_programme = registre_autorisation_empilement_programme; (*s_etat_processus).instruction_courante = registre_instruction_courante; (*s_etat_processus).definitions_chainees = registre_programme; (*s_etat_processus).position_courante = registre_position_courante; if ((arguments = malloc(nombre_arguments * sizeof(char *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*s_etat_processus).l_base_pile; nombre_arguments--; for(i = nombre_arguments, arguments[i--] = NULL; i >= 0; i--) { arguments[i] = (char *) (*(*l_element_courant).donnee).objet; l_element_courant = (*l_element_courant).suivant; } action_courante.sa_handler = SIG_IGN; action_courante.sa_flags = SA_NODEFER | SA_ONSTACK; if (sigaction(SIGINT, &action_courante, &action_passee) != 0) { for(i = 0; i < nombre_arguments; i++) { depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_temporaire); liberation(s_etat_processus, s_objet_temporaire); } free(arguments); (*s_etat_processus).erreur_systeme = d_es_signal; return; } if (pipe(pipes_entree) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (pipe(pipes_sortie) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (pipe(pipes_erreur) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } fflush(NULL); sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); verrouillage_threads_concurrents(s_etat_processus); pid = fork(); deverrouillage_threads_concurrents(s_etat_processus); pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); if (pid < 0) { if (close(pipes_entree[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_entree[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_sortie[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_sortie[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_erreur[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_erreur[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } (*s_etat_processus).erreur_systeme = d_es_processus; return; } else if (pid == 0) { if (close(pipes_entree[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_sortie[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_erreur[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (pipes_entree[0] != STDIN_FILENO) { if (dup2(pipes_entree[0], STDIN_FILENO) == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if (pipes_sortie[1] != STDOUT_FILENO) { if (dup2(pipes_sortie[1], STDOUT_FILENO) == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if (pipes_sortie[1] != STDERR_FILENO) { if (dup2(pipes_sortie[1], STDERR_FILENO) == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if (nombre_arguments != 0) { execvp(arguments[0], arguments); } else { exit(EXIT_SUCCESS); } /* * L'appel système execvp() a généré une erreur et n'a pu exécuter * argument[0] (fichier non exécutable ou inexistant). */ close(pipes_entree[0]); close(pipes_sortie[1]); for(i = 0; i < nombre_arguments; i++) { depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_temporaire); liberation(s_etat_processus, s_objet_temporaire); } free(arguments); (*s_etat_processus).erreur_systeme = d_es_processus; /* * Envoi d'une erreur dans le pipe idoine. On ne regarde pas * le nombre d'octets écrits car l'erreur ne pourra de toute * façon pas être traitée. */ write_atomic(s_etat_processus, pipes_erreur[1], " ", 1); close(pipes_erreur[1]); exit(EXIT_SUCCESS); } else { if (close(pipes_entree[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_sortie[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_erreur[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (presence_stdin == d_vrai) { l_element_courant = l_element_stdin; while(l_element_courant != NULL) { longueur_ecriture = strlen((unsigned char *) (*(*l_element_courant).donnee).objet); # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } while(write_atomic(s_etat_processus, pipes_entree[1], (unsigned char *) (*(*l_element_courant).donnee).objet, longueur_ecriture) != longueur_ecriture) { # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus) .semaphore_fork)) == -1) # else while(sem_wait((*s_etat_processus) .semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if (longueur_ecriture == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus) .semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus) .semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } while(write_atomic(s_etat_processus, pipes_entree[1], "\n", 1) != 1) { # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus) .semaphore_fork)) == -1) # else while(sem_wait((*s_etat_processus) .semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if (longueur_ecriture == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus) .semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus) .semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) # else while(sem_wait((*s_etat_processus).semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } l_element_courant = (*l_element_courant).suivant; } } if (close(pipes_entree[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } do { if (kill(pid, 0) != 0) { break; } /* * Récupération de la valeur de retour du processus détaché */ # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (waitpid(pid, &status, 0) == -1) { # ifndef SEMAPHORES_NOMMES if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) # else if (sem_wait((*s_etat_processus).semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } (*s_etat_processus).erreur_systeme = d_es_processus; return; } # ifndef SEMAPHORES_NOMMES if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) # else if (sem_wait((*s_etat_processus).semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } } while((!WIFEXITED(status)) && (!WIFSIGNALED(status))); longueur_lecture = 256; pointeur = 0; nombre_iterations = 1; if ((tampon = malloc((longueur_lecture + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } # endif while((ios = read_atomic(s_etat_processus, pipes_sortie[0], &(tampon[pointeur]), longueur_lecture)) > 0) { # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) # else while(sem_wait((*s_etat_processus).semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } tampon[pointeur + ios] = d_code_fin_chaine; pointeur += longueur_lecture; nombre_iterations++; if ((tampon = realloc(tampon, ((nombre_iterations * longueur_lecture) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) # else while(sem_wait((*s_etat_processus).semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if ((tampon = realloc(tampon, (strlen(tampon) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (ios == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (close(pipes_sortie[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } /* * Transformation de la chaîne en liste */ longueur_tampon = strlen(tampon); for(i = 0, ptr = tampon, nombre_lignes = 0; i < (long) longueur_tampon; i++, ptr++) { if ((*ptr) == d_code_retour_chariot) { nombre_lignes++; (*ptr) = d_code_fin_chaine; } } if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (nombre_lignes == 0) { (*s_objet_resultat).objet = NULL; } else { if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_precedent = NULL; l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; for(i = 0, ptr = tampon; i < (long) nombre_lignes; i++) { if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*l_element_courant).donnee).objet = malloc((strlen(ptr) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*(*l_element_courant).donnee).objet, ptr); while((*ptr) != d_code_fin_chaine) { ptr++; } ptr++; if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } free(l_element_courant); if (l_element_precedent != NULL) { (*l_element_precedent).suivant = NULL; } } free(tampon); } if (sigaction(SIGINT, &action_passee, NULL) != 0) { for(i = 0; i < nombre_arguments; i++) { depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_temporaire); liberation(s_etat_processus, s_objet_temporaire); } free(arguments); (*s_etat_processus).erreur_systeme = d_es_signal; return; } for(i = 0; i < nombre_arguments; i++) { depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_temporaire); liberation(s_etat_processus, s_objet_temporaire); } if ((tampon = malloc(sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if (read_atomic(s_etat_processus, pipes_erreur[0], tampon, 1) > 0) { // Le processus fils renvoie une erreur. (*s_etat_processus).erreur_execution = d_ex_erreur_processus; liberation(s_etat_processus, s_objet_resultat); } else if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) # else while(sem_wait((*s_etat_processus).semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if (close(pipes_erreur[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } free(tampon); return; } # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) # else while(sem_wait((*s_etat_processus).semaphore_fork) == -1) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if (close(pipes_erreur[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } free(arguments); free(tampon); } else { if (presence_stdin == d_vrai) { s_objet = s_objet_composite; } liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } if (presence_stdin == d_vrai) { s_objet = s_objet_composite; } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction 'sign' ================================================================================ Entrées : -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_sign(struct_processus *s_etat_processus) { real8 norme; 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 SIGN "); if ((*s_etat_processus).langue == 'F') { printf("(signe)\n\n"); } else { printf("(sign)\n\n"); } printf(" 1: %s, %s\n", d_INT, d_REL); printf("-> 1: %s\n\n", d_INT); printf(" 1: %s\n", d_CPL); printf("-> 1: %s\n\n", d_CPL); 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; } /* -------------------------------------------------------------------------------- Signe d'un entier -------------------------------------------------------------------------------- */ if ((*s_objet_argument).type == INT) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((integer8 *) (*s_objet_argument).objet)) > 0) { (*((integer8 *) (*s_objet_resultat).objet)) = 1; } else if ((*((integer8 *) (*s_objet_argument).objet)) < 0) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } } /* -------------------------------------------------------------------------------- Signe d'un réel -------------------------------------------------------------------------------- */ else if ((*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 ((*((real8 *) (*s_objet_argument).objet)) > 0) { (*((integer8 *) (*s_objet_resultat).objet)) = 1; } else if ((*((real8 *) (*s_objet_argument).objet)) < 0) { (*((integer8 *) (*s_objet_resultat).objet)) = -1; } else { (*((integer8 *) (*s_objet_resultat).objet)) = 0; } } /* -------------------------------------------------------------------------------- Vecteur unité dans la direction du complexe -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == CPL) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == 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_argument).objet)) .partie_imaginaire != 0)) { f77absc_((struct_complexe16 *) (*s_objet_argument).objet, &norme); f77divisioncr_((struct_complexe16 *) (*s_objet_argument).objet, &norme, (struct_complexe16 *) (*s_objet_resultat).objet); } else { (*((struct_complexe16 *) (*s_objet_argument).objet)) .partie_reelle = 0; (*((struct_complexe16 *) (*s_objet_argument).objet)) .partie_imaginaire = 0; } } /* -------------------------------------------------------------------------------- Signe 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_sign; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "SIGN"); 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; } /* -------------------------------------------------------------------------------- Signe 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_sign; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(5 * 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, "SIGN"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_resultat = s_copie_argument; } /* -------------------------------------------------------------------------------- Fonction signe impossible à réaliser -------------------------------------------------------------------------------- */ else { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } liberation(s_etat_processus, s_objet_argument); return; } /* ================================================================================ Fonction 'select' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_select(struct_processus *s_etat_processus) { (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n SELECT "); if ((*s_etat_processus).langue == 'F') { printf("(structure de contrôle)\n\n"); printf(" Utilisation :\n\n"); } else { printf("(control statement)\n\n"); printf(" Usage:\n\n"); } printf(" SELECT (expression test)\n"); printf(" CASE (clause 1) THEN (expression 1) END\n"); printf(" CASE (clause 2) THEN (expression 2) END\n"); printf(" ...\n"); printf(" CASE (clause n) THEN (expression n) END\n"); printf(" DEFAULT\n"); printf(" (expression)\n"); printf(" END\n\n"); printf(" SELECT (expression test)\n"); printf(" CASE (clause 1) THEN (expression 1) END\n"); printf(" (expression)\n"); printf(" CASE (clause 2) THEN (expression 2) END\n"); printf(" END\n"); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } empilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { return; } (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'C'; (*(*s_etat_processus).l_base_pile_systeme).clause = 'S'; return; } /* ================================================================================ Fonction 'std' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_std(struct_processus *s_etat_processus) { (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n STD "); if ((*s_etat_processus).langue == 'F') { printf("(format standard)\n\n"); printf(" Aucun argument\n"); } else { printf("(standard format)\n\n"); printf(" No argument\n"); } 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; } } cf(s_etat_processus, 49); cf(s_etat_processus, 50); return; } /* ================================================================================ Fonction 'sci' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_sci(struct_processus *s_etat_processus) { struct_objet *s_objet_argument; struct_objet *s_objet; logical1 i43; logical1 i44; unsigned char *valeur_binaire; unsigned long i; unsigned long j; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n SCI "); if ((*s_etat_processus).langue == 'F') { printf("(format scientifique)\n\n"); } else { printf("(scientific format)\n\n"); } printf(" 1: %s\n", d_INT); 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; } if ((*s_objet_argument).type == INT) { if (((*((integer8 *) (*s_objet_argument).objet)) >= 0) && ((*((integer8 *) (*s_objet_argument).objet)) <= 15)) { if ((s_objet = allocation(s_etat_processus, BIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((logical8 *) (*s_objet).objet)) = (*((integer8 *) (*s_objet_argument).objet)); i43 = test_cfsf(s_etat_processus, 43); i44 = test_cfsf(s_etat_processus, 44); sf(s_etat_processus, 44); cf(s_etat_processus, 43); if ((valeur_binaire = formateur(s_etat_processus, 0, s_objet)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (i43 == d_vrai) { sf(s_etat_processus, 43); } else { cf(s_etat_processus, 43); } if (i44 == d_vrai) { sf(s_etat_processus, 44); } else { cf(s_etat_processus, 44); } for(j = 53, i = strlen(valeur_binaire) - 2; i >= 2; i--) { if (valeur_binaire[i] == '0') { cf(s_etat_processus, j++); } else { sf(s_etat_processus, j++); } } for(; j <= 56; cf(s_etat_processus, j++)); cf(s_etat_processus, 49); sf(s_etat_processus, 50); free(valeur_binaire); liberation(s_etat_processus, s_objet); } else { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } } 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); return; } // vim: ts=4