Annotation of rpl/src/instructions_d5.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
! 5:
! 6: This file is part of RPL/2.
! 7:
! 8: RPL/2 is free software; you can redistribute it and/or modify it
! 9: under the terms of the CeCILL V2 License as published by the french
! 10: CEA, CNRS and INRIA.
! 11:
! 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
! 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
! 15: for more details.
! 16:
! 17: You should have received a copy of the CeCILL License
! 18: along with RPL/2. If not, write to info@cecill.info.
! 19: ================================================================================
! 20: */
! 21:
! 22:
! 23: #include "rpl.conv.h"
! 24:
! 25:
! 26: /*
! 27: ================================================================================
! 28: Fonction 'DFT'
! 29: ================================================================================
! 30: Entrées : structure processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_dft(struct_processus *s_etat_processus)
! 40: {
! 41: integer4 erreur;
! 42: integer4 inverse;
! 43: integer4 nombre_colonnes;
! 44: integer4 nombre_lignes;
! 45:
! 46: logical1 presence_longueur_dft;
! 47:
! 48: long longueur_dft_signee;
! 49:
! 50: struct_complexe16 *matrice_f77;
! 51:
! 52: struct_objet *s_objet_argument;
! 53: struct_objet *s_objet_longueur_dft;
! 54: struct_objet *s_objet_resultat;
! 55:
! 56: unsigned long i;
! 57: unsigned long j;
! 58: unsigned long k;
! 59: unsigned long longueur_dft;
! 60:
! 61: (*s_etat_processus).erreur_execution = d_ex;
! 62:
! 63: if ((*s_etat_processus).affichage_arguments == 'Y')
! 64: {
! 65: printf("\n DFT ");
! 66:
! 67: if ((*s_etat_processus).langue == 'F')
! 68: {
! 69: printf("(transformée de Fourier discrète)\n\n");
! 70: }
! 71: else
! 72: {
! 73: printf("(discrete Fourier transform)\n\n");
! 74: }
! 75:
! 76: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
! 77: printf("-> 1: %s\n\n", d_VCX);
! 78:
! 79: printf(" 2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
! 80: printf(" 1: %s\n", d_INT);
! 81: printf("-> 1: %s\n\n", d_VCX);
! 82:
! 83: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 84: printf("-> 1: %s\n\n", d_VCX);
! 85:
! 86: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 87: printf(" 1: %s\n", d_INT);
! 88: printf("-> 1: %s\n", d_MCX);
! 89:
! 90: return;
! 91: }
! 92: else if ((*s_etat_processus).test_instruction == 'Y')
! 93: {
! 94: (*s_etat_processus).nombre_arguments = -1;
! 95: return;
! 96: }
! 97:
! 98: /*
! 99: * Il est possible d'imposer une longueur de DFT au premier niveau
! 100: * de la pile.
! 101: */
! 102:
! 103: if ((*s_etat_processus).l_base_pile == NULL)
! 104: {
! 105: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 106: return;
! 107: }
! 108:
! 109: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == INT)
! 110: {
! 111: presence_longueur_dft = d_vrai;
! 112:
! 113: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 114: {
! 115: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 116: {
! 117: return;
! 118: }
! 119: }
! 120:
! 121: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 122: &s_objet_longueur_dft) == d_erreur)
! 123: {
! 124: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 125: return;
! 126: }
! 127:
! 128: longueur_dft_signee = (*((integer8 *) (*s_objet_longueur_dft).objet));
! 129:
! 130: liberation(s_etat_processus, s_objet_longueur_dft);
! 131:
! 132: if (longueur_dft_signee <= 0)
! 133: {
! 134: (*s_etat_processus).erreur_execution = d_ex_longueur_dft;
! 135: return;
! 136: }
! 137:
! 138: longueur_dft = longueur_dft_signee;
! 139: }
! 140: else
! 141: {
! 142: presence_longueur_dft = d_faux;
! 143: longueur_dft = 0;
! 144:
! 145: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 146: {
! 147: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 148: {
! 149: return;
! 150: }
! 151: }
! 152: }
! 153:
! 154: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 155: &s_objet_argument) == d_erreur)
! 156: {
! 157: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 158: return;
! 159: }
! 160:
! 161: /*
! 162: --------------------------------------------------------------------------------
! 163: Vecteur
! 164: --------------------------------------------------------------------------------
! 165: */
! 166:
! 167: if (((*s_objet_argument).type == VIN) ||
! 168: ((*s_objet_argument).type == VRL) ||
! 169: ((*s_objet_argument).type == VCX))
! 170: {
! 171: if (presence_longueur_dft == d_faux)
! 172: {
! 173: longueur_dft = (*((struct_vecteur *)
! 174: (*s_objet_argument).objet)).taille;
! 175: }
! 176:
! 177: if ((matrice_f77 = malloc(longueur_dft *
! 178: sizeof(struct_complexe16))) == NULL)
! 179: {
! 180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 181: return;
! 182: }
! 183:
! 184: if ((*s_objet_argument).type == VIN)
! 185: {
! 186: for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
! 187: .taille; i++)
! 188: {
! 189: matrice_f77[i].partie_reelle = (real8) ((integer8 *)
! 190: (*((struct_vecteur *) (*s_objet_argument).objet))
! 191: .tableau)[i];
! 192: matrice_f77[i].partie_imaginaire = (real8) 0;
! 193: }
! 194: }
! 195: else if ((*s_objet_argument).type == VRL)
! 196: {
! 197: for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
! 198: .taille; i++)
! 199: {
! 200: matrice_f77[i].partie_reelle = ((real8 *)
! 201: (*((struct_vecteur *) (*s_objet_argument).objet))
! 202: .tableau)[i];
! 203: matrice_f77[i].partie_imaginaire = (real8) 0;
! 204: }
! 205: }
! 206: else
! 207: {
! 208: for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
! 209: .taille; i++)
! 210: {
! 211: matrice_f77[i].partie_reelle = ((struct_complexe16 *)
! 212: (*((struct_vecteur *) (*s_objet_argument).objet))
! 213: .tableau)[i].partie_reelle;
! 214: matrice_f77[i].partie_imaginaire = ((struct_complexe16 *)
! 215: (*((struct_vecteur *) (*s_objet_argument).objet))
! 216: .tableau)[i].partie_imaginaire;
! 217: }
! 218: }
! 219:
! 220: for(; i < longueur_dft; i++)
! 221: {
! 222: matrice_f77[i].partie_reelle = (real8) 0;
! 223: matrice_f77[i].partie_imaginaire = (real8) 0;
! 224: }
! 225:
! 226: nombre_lignes = 1;
! 227: nombre_colonnes = longueur_dft;
! 228: inverse = 0;
! 229:
! 230: dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
! 231:
! 232: if (erreur != 0)
! 233: {
! 234: liberation(s_etat_processus, s_objet_argument);
! 235: free(matrice_f77);
! 236:
! 237: (*s_etat_processus).erreur_execution = d_ex_longueur_dft;
! 238: return;
! 239: }
! 240:
! 241: if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL)
! 242: {
! 243: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 244: return;
! 245: }
! 246:
! 247: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = longueur_dft;
! 248: (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = matrice_f77;
! 249: }
! 250:
! 251: /*
! 252: --------------------------------------------------------------------------------
! 253: Matrice
! 254: --------------------------------------------------------------------------------
! 255: */
! 256:
! 257: else if (((*s_objet_argument).type == MIN) ||
! 258: ((*s_objet_argument).type == MRL) ||
! 259: ((*s_objet_argument).type == MCX))
! 260: {
! 261: if (presence_longueur_dft == d_faux)
! 262: {
! 263: longueur_dft = (*((struct_matrice *)
! 264: (*s_objet_argument).objet)).nombre_colonnes;
! 265: }
! 266:
! 267: if ((matrice_f77 = malloc(longueur_dft *
! 268: (*((struct_matrice *) (*s_objet_argument).objet))
! 269: .nombre_lignes * sizeof(struct_complexe16))) == NULL)
! 270: {
! 271: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 272: return;
! 273: }
! 274:
! 275: if ((*s_objet_argument).type == MIN)
! 276: {
! 277: for(k = 0, j = 0; j < (*((struct_matrice *) (*s_objet_argument)
! 278: .objet)).nombre_lignes; j++)
! 279: {
! 280: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument)
! 281: .objet)).nombre_colonnes; i++)
! 282: {
! 283: matrice_f77[k].partie_reelle = (real8) ((integer8 **)
! 284: (*((struct_matrice *) (*s_objet_argument).objet))
! 285: .tableau)[j][i];
! 286: matrice_f77[k++].partie_imaginaire = (real8) 0;
! 287: }
! 288: }
! 289:
! 290: for(; k < longueur_dft * (*((struct_matrice *) (*s_objet_argument)
! 291: .objet)).nombre_lignes; k++)
! 292: {
! 293: matrice_f77[k].partie_reelle = (real8) 0;
! 294: matrice_f77[k].partie_imaginaire = (real8) 0;
! 295: }
! 296: }
! 297: else if ((*s_objet_argument).type == MRL)
! 298: {
! 299: for(k = 0, j = 0; j < (*((struct_matrice *) (*s_objet_argument)
! 300: .objet)).nombre_lignes; j++)
! 301: {
! 302: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument)
! 303: .objet)).nombre_colonnes; i++)
! 304: {
! 305: matrice_f77[k].partie_reelle = ((real8 **)
! 306: (*((struct_matrice *) (*s_objet_argument).objet))
! 307: .tableau)[j][i];
! 308: matrice_f77[k++].partie_imaginaire = (real8) 0;
! 309: }
! 310: }
! 311:
! 312: for(; k < longueur_dft * (*((struct_matrice *) (*s_objet_argument)
! 313: .objet)).nombre_lignes; k++)
! 314: {
! 315: matrice_f77[k].partie_reelle = (real8) 0;
! 316: matrice_f77[k].partie_imaginaire = (real8) 0;
! 317: }
! 318: }
! 319: else
! 320: {
! 321: for(k = 0, j = 0; j < (*((struct_matrice *) (*s_objet_argument)
! 322: .objet)).nombre_lignes; j++)
! 323: {
! 324: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument)
! 325: .objet)).nombre_colonnes; i++)
! 326: {
! 327: matrice_f77[k].partie_reelle = ((struct_complexe16 **)
! 328: (*((struct_matrice *) (*s_objet_argument).objet))
! 329: .tableau)[j][i].partie_reelle;
! 330: matrice_f77[k++].partie_imaginaire =
! 331: ((struct_complexe16 **) (*((struct_matrice *)
! 332: (*s_objet_argument).objet)).tableau)[j][i]
! 333: .partie_imaginaire;
! 334: }
! 335: }
! 336:
! 337: for(; k < longueur_dft * (*((struct_matrice *) (*s_objet_argument)
! 338: .objet)).nombre_lignes; k++)
! 339: {
! 340: matrice_f77[k].partie_reelle = (real8) 0;
! 341: matrice_f77[k].partie_imaginaire = (real8) 0;
! 342: }
! 343: }
! 344:
! 345: nombre_lignes = (*((struct_matrice *) (*s_objet_argument).objet))
! 346: .nombre_lignes;
! 347: nombre_colonnes = longueur_dft;
! 348: inverse = 0;
! 349:
! 350: dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
! 351:
! 352: if (erreur != 0)
! 353: {
! 354: liberation(s_etat_processus, s_objet_argument);
! 355: free(matrice_f77);
! 356:
! 357: (*s_etat_processus).erreur_execution = d_ex_longueur_dft;
! 358: return;
! 359: }
! 360:
! 361: if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
! 362: {
! 363: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 364: return;
! 365: }
! 366:
! 367: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 368: (*((struct_matrice *) (*s_objet_argument).objet))
! 369: .nombre_lignes;
! 370: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 371: longueur_dft;
! 372:
! 373: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 374: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 375: .nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 376: {
! 377: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 378: return;
! 379: }
! 380:
! 381: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 382: .nombre_lignes; i++)
! 383: {
! 384: if ((((struct_complexe16 **) (*((struct_matrice *)
! 385: (*s_objet_resultat).objet)).tableau)[i] =
! 386: malloc((*((struct_matrice *)
! 387: (*s_objet_resultat).objet)).nombre_colonnes *
! 388: sizeof(struct_complexe16))) == NULL)
! 389: {
! 390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 391: return;
! 392: }
! 393: }
! 394:
! 395: for(k = 0, j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
! 396: .nombre_lignes; j++)
! 397: {
! 398: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 399: .nombre_colonnes; i++)
! 400: {
! 401: ((struct_complexe16 **) (*((struct_matrice *)
! 402: (*s_objet_resultat).objet)).tableau)[j][i]
! 403: .partie_reelle = matrice_f77[k].partie_reelle;
! 404: ((struct_complexe16 **) (*((struct_matrice *)
! 405: (*s_objet_resultat).objet)).tableau)[j][i]
! 406: .partie_imaginaire = matrice_f77[k++].partie_imaginaire;
! 407: }
! 408: }
! 409:
! 410: free(matrice_f77);
! 411: }
! 412:
! 413: /*
! 414: --------------------------------------------------------------------------------
! 415: Calcul de DFT impossible
! 416: --------------------------------------------------------------------------------
! 417: */
! 418:
! 419: else
! 420: {
! 421: liberation(s_etat_processus, s_objet_argument);
! 422:
! 423: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 424: return;
! 425: }
! 426:
! 427: liberation(s_etat_processus, s_objet_argument);
! 428:
! 429: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 430: s_objet_resultat) == d_erreur)
! 431: {
! 432: return;
! 433: }
! 434:
! 435: return;
! 436: }
! 437:
! 438:
! 439: /*
! 440: ================================================================================
! 441: Fonction 'DER'
! 442: ================================================================================
! 443: Entrées : structure processus
! 444: --------------------------------------------------------------------------------
! 445: Sorties :
! 446: --------------------------------------------------------------------------------
! 447: Effets de bord : néant
! 448: ================================================================================
! 449: */
! 450:
! 451: void
! 452: instruction_der(struct_processus *s_etat_processus)
! 453: {
! 454: logical1 expression_rpn;
! 455: logical1 last_valide;
! 456:
! 457: struct_liste_chainee *l_element_courant;
! 458: struct_liste_chainee *l_element_precedent;
! 459:
! 460: struct_objet *s_copie_argument_2;
! 461: struct_objet *s_objet_argument_1;
! 462: struct_objet *s_objet_argument_2;
! 463: struct_objet *s_objet_resultat;
! 464: struct_objet *s_objet_simplifie;
! 465:
! 466: (*s_etat_processus).erreur_execution = d_ex;
! 467:
! 468: if ((*s_etat_processus).affichage_arguments == 'Y')
! 469: {
! 470: printf("\n DER ");
! 471:
! 472: if ((*s_etat_processus).langue == 'F')
! 473: {
! 474: printf("(dérivation)\n\n");
! 475: }
! 476: else
! 477: {
! 478: printf("(derivation)\n\n");
! 479: }
! 480:
! 481: printf(" 2: %s, %s, %s, %s\n", d_INT, d_REL, d_CPL, d_NOM);
! 482: printf(" 1: %s\n", d_NOM);
! 483: printf("-> 1: %s\n\n", d_INT);
! 484:
! 485: printf(" 2: %s, %s\n", d_RPN, d_ALG);
! 486: printf(" 1: %s\n", d_NOM);
! 487: printf("-> 1: %s, %s\n", d_RPN, d_ALG);
! 488:
! 489: return;
! 490: }
! 491: else if ((*s_etat_processus).test_instruction == 'Y')
! 492: {
! 493: (*s_etat_processus).nombre_arguments = 2;
! 494: return;
! 495: }
! 496:
! 497: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
! 498: {
! 499: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 500: {
! 501: return;
! 502: }
! 503: }
! 504:
! 505: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 506: &s_objet_argument_1) == d_erreur)
! 507: {
! 508: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 509: return;
! 510: }
! 511:
! 512: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 513: &s_objet_argument_2) == d_erreur)
! 514: {
! 515: liberation(s_etat_processus, s_objet_argument_1);
! 516:
! 517: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 518: return;
! 519: }
! 520:
! 521: expression_rpn = d_faux;
! 522:
! 523: /*
! 524: * Dérivation d'une expression
! 525: */
! 526:
! 527: if (((*s_objet_argument_1).type == NOM) &&
! 528: (((*s_objet_argument_2).type == RPN) ||
! 529: ((*s_objet_argument_2).type == ALG)))
! 530: {
! 531: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
! 532: s_objet_argument_2, 'N')) == NULL)
! 533: {
! 534: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 535: return;
! 536: }
! 537:
! 538: if ((*s_copie_argument_2).type == RPN)
! 539: {
! 540: expression_rpn = d_vrai;
! 541: }
! 542:
! 543: l_element_courant = (struct_liste_chainee *)
! 544: (*s_copie_argument_2).objet;
! 545: l_element_precedent = l_element_courant;
! 546:
! 547: while((*l_element_courant).suivant != NULL)
! 548: {
! 549: l_element_precedent = l_element_courant;
! 550: l_element_courant = (*l_element_courant).suivant;
! 551: }
! 552:
! 553: if (((*l_element_precedent).suivant =
! 554: allocation_maillon(s_etat_processus)) == NULL)
! 555: {
! 556: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 557: return;
! 558: }
! 559:
! 560: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
! 561: l_element_precedent = (*l_element_precedent).suivant;
! 562:
! 563: if (((*l_element_precedent).suivant =
! 564: allocation_maillon(s_etat_processus)) == NULL)
! 565: {
! 566: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 567: return;
! 568: }
! 569:
! 570: if (((*(*l_element_precedent).suivant).donnee =
! 571: allocation(s_etat_processus, FCT)) == NULL)
! 572: {
! 573: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 574: return;
! 575: }
! 576:
! 577: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 578: .donnee).objet)).nombre_arguments = 2;
! 579: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 580: .donnee).objet)).fonction = instruction_der;
! 581:
! 582: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 583: .suivant).donnee).objet)).nom_fonction =
! 584: malloc(4 * sizeof(unsigned char))) == NULL)
! 585: {
! 586: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 587: return;
! 588: }
! 589:
! 590: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 591: .suivant).donnee).objet)).nom_fonction, "DER");
! 592:
! 593: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 594:
! 595: s_objet_resultat = s_copie_argument_2;
! 596: s_objet_argument_1 = NULL;
! 597: }
! 598:
! 599: /*
! 600: * Dérivation d'un nom ou d'une constante
! 601: */
! 602:
! 603: else if (((*s_objet_argument_1).type == NOM) &&
! 604: (((*s_objet_argument_2).type == NOM) ||
! 605: ((*s_objet_argument_2).type == INT) ||
! 606: ((*s_objet_argument_2).type == REL) ||
! 607: ((*s_objet_argument_2).type == CPL)))
! 608: {
! 609: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
! 610: {
! 611: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 612: return;
! 613: }
! 614:
! 615: if (((*s_objet_resultat).objet =
! 616: allocation_maillon(s_etat_processus)) == NULL)
! 617: {
! 618: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 619: return;
! 620: }
! 621:
! 622: l_element_courant = (*s_objet_resultat).objet;
! 623:
! 624: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 625: == NULL)
! 626: {
! 627: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 628: return;
! 629: }
! 630:
! 631: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 632: .nombre_arguments = 0;
! 633: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 634: .fonction = instruction_vers_niveau_superieur;
! 635:
! 636: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 637: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 638: {
! 639: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 640: return;
! 641: }
! 642:
! 643: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 644: .nom_fonction, "<<");
! 645:
! 646: if (((*l_element_courant).suivant =
! 647: allocation_maillon(s_etat_processus)) == NULL)
! 648: {
! 649: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 650: return;
! 651: }
! 652:
! 653: l_element_courant = (*l_element_courant).suivant;
! 654: (*l_element_courant).donnee = s_objet_argument_2;
! 655:
! 656: if (((*l_element_courant).suivant =
! 657: allocation_maillon(s_etat_processus)) == NULL)
! 658: {
! 659: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 660: return;
! 661: }
! 662:
! 663: l_element_courant = (*l_element_courant).suivant;
! 664: (*l_element_courant).donnee = s_objet_argument_1;
! 665:
! 666: if (((*l_element_courant).suivant =
! 667: allocation_maillon(s_etat_processus)) == NULL)
! 668: {
! 669: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 670: return;
! 671: }
! 672:
! 673: l_element_courant = (*l_element_courant).suivant;
! 674:
! 675: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 676: == NULL)
! 677: {
! 678: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 679: return;
! 680: }
! 681:
! 682: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 683: .nombre_arguments = 2;
! 684: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 685: .fonction = instruction_der;
! 686:
! 687: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 688: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
! 689: {
! 690: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 691: return;
! 692: }
! 693:
! 694: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 695: .nom_fonction, "DER");
! 696:
! 697: if (((*l_element_courant).suivant =
! 698: allocation_maillon(s_etat_processus)) == NULL)
! 699: {
! 700: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 701: return;
! 702: }
! 703:
! 704: l_element_courant = (*l_element_courant).suivant;
! 705:
! 706: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 707: == NULL)
! 708: {
! 709: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 710: return;
! 711: }
! 712:
! 713: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 714: .nombre_arguments = 0;
! 715: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 716: .fonction = instruction_vers_niveau_inferieur;
! 717:
! 718: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 719: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 720: {
! 721: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 722: return;
! 723: }
! 724:
! 725: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 726: .nom_fonction, ">>");
! 727:
! 728: (*l_element_courant).suivant = NULL;
! 729:
! 730: s_objet_argument_1 = NULL;
! 731: s_objet_argument_2 = NULL;
! 732: }
! 733:
! 734: /*
! 735: * Dérivation impossible
! 736: */
! 737:
! 738: else
! 739: {
! 740: liberation(s_etat_processus, s_objet_argument_1);
! 741: liberation(s_etat_processus, s_objet_argument_2);
! 742:
! 743: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 744: return;
! 745: }
! 746:
! 747: liberation(s_etat_processus, s_objet_argument_1);
! 748: liberation(s_etat_processus, s_objet_argument_2);
! 749:
! 750: if (expression_rpn == d_faux)
! 751: {
! 752: if (last_valide == d_vrai)
! 753: {
! 754: cf(s_etat_processus, 31);
! 755: }
! 756:
! 757: derivation(s_etat_processus, &s_objet_resultat);
! 758:
! 759: if (last_valide == d_vrai)
! 760: {
! 761: sf(s_etat_processus, 31);
! 762: }
! 763:
! 764: if (((*s_etat_processus).var_volatile_requete_arret == 0) &&
! 765: (s_objet_resultat != NULL))
! 766: {
! 767: if ((s_objet_simplifie = simplification(s_etat_processus,
! 768: s_objet_resultat)) == NULL)
! 769: {
! 770: return;
! 771: }
! 772:
! 773: liberation(s_etat_processus, s_objet_resultat);
! 774:
! 775: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 776: s_objet_simplifie) == d_erreur)
! 777: {
! 778: return;
! 779: }
! 780: }
! 781: else
! 782: {
! 783: if (s_objet_resultat != NULL)
! 784: {
! 785: liberation(s_etat_processus, s_objet_resultat);
! 786: }
! 787: }
! 788: }
! 789: else
! 790: {
! 791: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 792: s_objet_resultat) == d_erreur)
! 793: {
! 794: return;
! 795: }
! 796: }
! 797:
! 798: return;
! 799: }
! 800:
! 801:
! 802: /*
! 803: ================================================================================
! 804: Fonction 'DETACH'
! 805: ================================================================================
! 806: Entrées : structure processus
! 807: --------------------------------------------------------------------------------
! 808: Sorties :
! 809: --------------------------------------------------------------------------------
! 810: Effets de bord : néant
! 811: ================================================================================
! 812: */
! 813:
! 814: void
! 815: instruction_detach(struct_processus *s_etat_processus)
! 816: {
! 817: int status;
! 818:
! 819: logical1 drapeau;
! 820: logical1 variable_partagee;
! 821:
! 822: pid_t ppid;
! 823: pid_t pid_final;
! 824:
! 825: pthread_attr_t attributs;
! 826:
! 827: pthread_mutexattr_t attributs_mutex;
! 828:
! 829: pthread_t thread_surveillance;
! 830:
! 831: sig_atomic_t registre_stop;
! 832:
! 833: sigset_t oldset;
! 834: sigset_t oldset2;
! 835: sigset_t set;
! 836: sigset_t set2;
! 837:
! 838: ssize_t longueur_ecriture;
! 839:
! 840: struct_descripteur_thread *s_argument_thread;
! 841:
! 842: struct_liste_chainee *l_element_courant;
! 843: struct_liste_chainee *l_element_precedent;
! 844: struct_liste_chainee *l_element_suivant;
! 845:
! 846: struct_objet *s_copie;
! 847: struct_objet *s_objet;
! 848: struct_objet *s_objet_systeme;
! 849: struct_objet *s_objet_temporaire;
! 850:
! 851: struct sigaction action;
! 852: struct sigaction registre;
! 853:
! 854: struct timespec attente;
! 855:
! 856: unsigned char *message;
! 857:
! 858: unsigned int erreur;
! 859:
! 860: unsigned long i;
! 861:
! 862: (*s_etat_processus).erreur_execution = d_ex;
! 863:
! 864: attente.tv_sec = 0;
! 865: attente.tv_nsec = GRANULARITE_us * 1000;
! 866: s_copie = NULL;
! 867:
! 868: if ((*s_etat_processus).affichage_arguments == 'Y')
! 869: {
! 870: printf("\n DETACH ");
! 871:
! 872: if ((*s_etat_processus).langue == 'F')
! 873: {
! 874: printf("(détachement d'un processus)\n\n");
! 875: }
! 876: else
! 877: {
! 878: printf("(fork)\n\n");
! 879: }
! 880:
! 881: printf(" 1: %s, %s\n", d_NOM, d_RPN);
! 882: printf("-> 1: %s\n", d_PRC);
! 883:
! 884: return;
! 885: }
! 886: else if ((*s_etat_processus).test_instruction == 'Y')
! 887: {
! 888: (*s_etat_processus).nombre_arguments = -1;
! 889: return;
! 890: }
! 891:
! 892: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 893: {
! 894: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 895: {
! 896: return;
! 897: }
! 898: }
! 899:
! 900: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 901: &s_objet) == d_erreur)
! 902: {
! 903: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 904: return;
! 905: }
! 906:
! 907: /*
! 908: * Une routine fille doit pouvoir renvoyer des objets au processus
! 909: * père au travers de la fonction SEND. Il ne peut donc s'agir que
! 910: * d'une fonction ou d'une expression RPN.
! 911: */
! 912:
! 913: if (((*s_objet).type != NOM) && ((*s_objet).type != RPN))
! 914: {
! 915: liberation(s_etat_processus, s_objet);
! 916:
! 917: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 918: return;
! 919: }
! 920:
! 921: /*
! 922: * Si l'argument est de type NOM, il faut que la variable correspondante
! 923: * soit une variable de type RPN.
! 924: */
! 925:
! 926: variable_partagee = d_faux;
! 927:
! 928: if ((*s_objet).type == NOM)
! 929: {
! 930: if (recherche_variable(s_etat_processus, (*((struct_nom *)
! 931: (*s_objet).objet)).nom) == d_vrai)
! 932: {
! 933: if ((*s_etat_processus).s_liste_variables
! 934: [(*s_etat_processus).position_variable_courante].objet
! 935: == NULL)
! 936: {
! 937: if (pthread_mutex_lock(&((*(*s_etat_processus)
! 938: .s_liste_variables_partagees).mutex)) != 0)
! 939: {
! 940: (*s_etat_processus).erreur_systeme = d_es_processus;
! 941: return;
! 942: }
! 943:
! 944: if (recherche_variable_partagee(s_etat_processus,
! 945: (*s_etat_processus).s_liste_variables
! 946: [(*s_etat_processus).position_variable_courante].nom,
! 947: (*s_etat_processus).s_liste_variables
! 948: [(*s_etat_processus).position_variable_courante]
! 949: .variable_partagee, (*s_etat_processus)
! 950: .s_liste_variables[(*s_etat_processus)
! 951: .position_variable_courante].origine) == d_faux)
! 952: {
! 953: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 954: .s_liste_variables_partagees).mutex)) != 0)
! 955: {
! 956: (*s_etat_processus).erreur_systeme = d_es_processus;
! 957: return;
! 958: }
! 959:
! 960: liberation(s_etat_processus, s_objet);
! 961:
! 962: (*s_etat_processus).erreur_systeme = d_es;
! 963: (*s_etat_processus).erreur_execution =
! 964: d_ex_argument_invalide;
! 965: return;
! 966: }
! 967:
! 968: if (((*(*(*s_etat_processus).s_liste_variables_partagees)
! 969: .table[(*(*s_etat_processus)
! 970: .s_liste_variables_partagees).position_variable].objet)
! 971: .type != RPN) && ((*(*(*s_etat_processus)
! 972: .s_liste_variables_partagees).table
! 973: [(*(*s_etat_processus).s_liste_variables_partagees)
! 974: .position_variable].objet).type != ADR))
! 975: {
! 976: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 977: .s_liste_variables_partagees).mutex)) != 0)
! 978: {
! 979: (*s_etat_processus).erreur_systeme = d_es_processus;
! 980: return;
! 981: }
! 982:
! 983: liberation(s_etat_processus, s_objet);
! 984:
! 985: (*s_etat_processus).erreur_execution =
! 986: d_ex_argument_invalide;
! 987: return;
! 988: }
! 989:
! 990: if ((s_copie = copie_objet(s_etat_processus,
! 991: (*(*s_etat_processus).s_liste_variables_partagees).table
! 992: [(*(*s_etat_processus).s_liste_variables_partagees)
! 993: .position_variable].objet, 'P')) == NULL)
! 994: {
! 995: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 996: .s_liste_variables_partagees).mutex)) != 0)
! 997: {
! 998: (*s_etat_processus).erreur_systeme = d_es_processus;
! 999: return;
! 1000: }
! 1001:
! 1002: (*s_etat_processus).erreur_systeme =
! 1003: d_es_allocation_memoire;
! 1004:
! 1005: return;
! 1006: }
! 1007:
! 1008: variable_partagee = d_vrai;
! 1009:
! 1010: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1011: .s_liste_variables_partagees).mutex)) != 0)
! 1012: {
! 1013: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1014: return;
! 1015: }
! 1016: }
! 1017: else
! 1018: {
! 1019: if (((*(*s_etat_processus).s_liste_variables
! 1020: [(*s_etat_processus).position_variable_courante].objet)
! 1021: .type != RPN) && ((*(*s_etat_processus)
! 1022: .s_liste_variables[(*s_etat_processus)
! 1023: .position_variable_courante].objet).type != ADR))
! 1024: {
! 1025: liberation(s_etat_processus, s_objet);
! 1026:
! 1027: (*s_etat_processus).erreur_execution =
! 1028: d_ex_argument_invalide;
! 1029: return;
! 1030: }
! 1031: }
! 1032: }
! 1033: else // Variable inexistante
! 1034: {
! 1035: liberation(s_etat_processus, s_objet);
! 1036:
! 1037: (*s_etat_processus).erreur_systeme = d_es;
! 1038: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 1039: return;
! 1040: }
! 1041: }
! 1042:
! 1043: if (sigemptyset(&set) != 0)
! 1044: {
! 1045: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1046: return;
! 1047: }
! 1048:
! 1049: if (sigaddset(&set, SIGSTART) != 0)
! 1050: {
! 1051: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1052: return;
! 1053: }
! 1054:
! 1055: /*
! 1056: * Le signal SIGFSTOP doit être traité !
! 1057: */
! 1058:
! 1059: if (sigaddset(&set, SIGFSTOP) != 0)
! 1060: {
! 1061: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1062: return;
! 1063: }
! 1064:
! 1065: if (sigaddset(&set, SIGURG) != 0)
! 1066: {
! 1067: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1068: return;
! 1069: }
! 1070:
! 1071: if (pthread_sigmask(SIG_BLOCK, &set, &oldset) != 0)
! 1072: {
! 1073: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1074: return;
! 1075: }
! 1076:
! 1077: if ((s_argument_thread = malloc(sizeof(struct_descripteur_thread))) == NULL)
! 1078: {
! 1079: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1080: return;
! 1081: }
! 1082:
! 1083: if (pipe((*s_argument_thread).pipe_erreurs) != 0)
! 1084: {
! 1085: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1086: return;
! 1087: }
! 1088:
! 1089: if (pipe((*s_argument_thread).pipe_interruptions) != 0)
! 1090: {
! 1091: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1092: return;
! 1093: }
! 1094:
! 1095: if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0)
! 1096: {
! 1097: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1098: return;
! 1099: }
! 1100:
! 1101: if (pipe((*s_argument_thread).pipe_objets) != 0)
! 1102: {
! 1103: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1104: return;
! 1105: }
! 1106:
! 1107: if (pipe((*s_argument_thread).pipe_acquittement) != 0)
! 1108: {
! 1109: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1110: return;
! 1111: }
! 1112:
! 1113: if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0)
! 1114: {
! 1115: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1116: return;
! 1117: }
! 1118:
! 1119: if (pipe((*s_argument_thread).pipe_injections) != 0)
! 1120: {
! 1121: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1122: return;
! 1123: }
! 1124:
! 1125: if (pipe((*s_argument_thread).pipe_nombre_injections) != 0)
! 1126: {
! 1127: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1128: return;
! 1129: }
! 1130:
! 1131: ppid = getpid();
! 1132:
! 1133: /*
! 1134: * Le mutex suivant permet de copier un contexte propre.
! 1135: */
! 1136:
! 1137: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 1138: {
! 1139: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1140: return;
! 1141: }
! 1142:
! 1143: fflush(NULL);
! 1144:
! 1145: /*
! 1146: * On bloque tous les threads concurents pour qu'il n'y ait ni allocation
! 1147: * de mémoire, ni libération, ni copie d'objet concurrent au fork().
! 1148: */
! 1149:
! 1150: sigfillset(&set2);
! 1151: pthread_sigmask(SIG_BLOCK, &set2, &oldset2);
! 1152:
! 1153: verrouillage_threads_concurrents(s_etat_processus);
! 1154: (*s_argument_thread).pid = fork();
! 1155: deverrouillage_threads_concurrents(s_etat_processus);
! 1156:
! 1157: pthread_sigmask(SIG_SETMASK, &oldset2, NULL);
! 1158: sigpending(&set2);
! 1159:
! 1160: (*s_argument_thread).thread_pere = pthread_self();
! 1161: (*s_argument_thread).processus_detache = d_vrai;
! 1162:
! 1163: pthread_mutexattr_init(&attributs_mutex);
! 1164: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
! 1165: pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);
! 1166: pthread_mutexattr_destroy(&attributs_mutex);
! 1167:
! 1168: if ((*s_argument_thread).pid > 0)
! 1169: {
! 1170: /*
! 1171: * Processus père
! 1172: */
! 1173:
! 1174: if (variable_partagee == d_vrai)
! 1175: {
! 1176: liberation(s_etat_processus, s_copie);
! 1177: }
! 1178:
! 1179: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1180: {
! 1181: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1182: return;
! 1183: }
! 1184:
! 1185: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1186: {
! 1187: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1188: return;
! 1189: }
! 1190:
! 1191: if (close((*s_argument_thread).pipe_erreurs[1]) != 0)
! 1192: {
! 1193: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1194: return;
! 1195: }
! 1196:
! 1197: if (close((*s_argument_thread).pipe_interruptions[1]) != 0)
! 1198: {
! 1199: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1200: return;
! 1201: }
! 1202:
! 1203: if (close((*s_argument_thread).pipe_nombre_interruptions_attente[1])
! 1204: != 0)
! 1205: {
! 1206: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1207: return;
! 1208: }
! 1209:
! 1210: if (close((*s_argument_thread).pipe_objets[1]) != 0)
! 1211: {
! 1212: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1213: return;
! 1214: }
! 1215:
! 1216: if (close((*s_argument_thread).pipe_nombre_objets_attente[1]) != 0)
! 1217: {
! 1218: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1219: return;
! 1220: }
! 1221:
! 1222: if (close((*s_argument_thread).pipe_injections[0]) != 0)
! 1223: {
! 1224: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1225: return;
! 1226: }
! 1227:
! 1228: if (close((*s_argument_thread).pipe_nombre_injections[0]) != 0)
! 1229: {
! 1230: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1231: return;
! 1232: }
! 1233:
! 1234: if (close((*s_argument_thread).pipe_acquittement[0]) != 0)
! 1235: {
! 1236: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1237: return;
! 1238: }
! 1239:
! 1240: if (pthread_attr_init(&attributs) != 0)
! 1241: {
! 1242: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1243: return;
! 1244: }
! 1245:
! 1246: if (pthread_attr_setdetachstate(&attributs,
! 1247: PTHREAD_CREATE_DETACHED) != 0)
! 1248: {
! 1249: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1250: return;
! 1251: }
! 1252:
! 1253: if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
! 1254: {
! 1255: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1256: return;
! 1257: }
! 1258:
! 1259: if (pthread_attr_setinheritsched(&attributs,
! 1260: PTHREAD_EXPLICIT_SCHED) != 0)
! 1261: {
! 1262: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1263: return;
! 1264: }
! 1265:
! 1266: if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
! 1267: {
! 1268: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1269: return;
! 1270: }
! 1271:
! 1272: (*s_argument_thread).s_etat_processus = s_etat_processus;
! 1273:
! 1274: if (pthread_create(&thread_surveillance, &attributs,
! 1275: surveillance_processus, s_argument_thread) != 0)
! 1276: {
! 1277: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1278: return;
! 1279: }
! 1280:
! 1281: if (pthread_attr_destroy(&attributs) != 0)
! 1282: {
! 1283: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1284: return;
! 1285: }
! 1286: }
! 1287: else if ((*s_argument_thread).pid == 0)
! 1288: {
! 1289: /*
! 1290: * Processus fils
! 1291: */
! 1292:
! 1293: sem_post(&semaphore_gestionnaires_signaux);
! 1294: sem_destroy(&semaphore_gestionnaires_signaux);
! 1295: sem_init(&semaphore_gestionnaires_signaux, 0, 0);
! 1296:
! 1297: sem_post(&semaphore_liste_threads);
! 1298: sem_destroy(&semaphore_liste_threads);
! 1299: sem_init(&semaphore_liste_threads, 0, 1);
! 1300:
! 1301: sem_destroy(&semaphore_gestionnaires_signaux_atomique);
! 1302: sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
! 1303:
! 1304: sem_trywait(&((*s_etat_processus).semaphore_fork));
! 1305:
! 1306: if (pthread_setspecific(semaphore_fork_processus_courant,
! 1307: &((*s_etat_processus).semaphore_fork)) != 0)
! 1308: {
! 1309: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1310: }
! 1311:
! 1312: if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
! 1313: {
! 1314: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1315: }
! 1316: else if (close((*s_argument_thread).pipe_interruptions[0]) != 0)
! 1317: {
! 1318: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1319: }
! 1320: else if (close((*s_argument_thread)
! 1321: .pipe_nombre_interruptions_attente[0]) != 0)
! 1322: {
! 1323: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1324: }
! 1325: else if (close((*s_argument_thread).pipe_objets[0]) != 0)
! 1326: {
! 1327: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1328: }
! 1329: else if (close((*s_argument_thread).pipe_nombre_objets_attente[0]) != 0)
! 1330: {
! 1331: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1332: }
! 1333: else if (close((*s_argument_thread).pipe_injections[1]) != 0)
! 1334: {
! 1335: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1336: }
! 1337: else if (close((*s_argument_thread).pipe_nombre_injections[1]) != 0)
! 1338: {
! 1339: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1340: }
! 1341: else if (close((*s_argument_thread).pipe_acquittement[1]) != 0)
! 1342: {
! 1343: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1344: }
! 1345:
! 1346: l_element_courant = (*s_etat_processus).liste_mutexes;
! 1347: while(l_element_courant != NULL)
! 1348: {
! 1349: pthread_mutex_trylock(&((*((struct_mutex *) (*(*l_element_courant)
! 1350: .donnee).objet)).mutex));
! 1351: pthread_mutex_unlock(&((*((struct_mutex *) (*(*l_element_courant)
! 1352: .donnee).objet)).mutex));
! 1353: pthread_mutex_destroy(&((*((struct_mutex *) (*(*l_element_courant)
! 1354: .donnee).objet)).mutex));
! 1355:
! 1356: liberation(s_etat_processus, (*l_element_courant).donnee);
! 1357: l_element_suivant = (*l_element_courant).suivant;
! 1358: free(l_element_courant);
! 1359: l_element_courant = l_element_suivant;
! 1360: }
! 1361:
! 1362: (*s_etat_processus).liste_mutexes = NULL;
! 1363:
! 1364: liberation_threads(s_etat_processus);
! 1365:
! 1366: (*(*s_etat_processus).s_liste_variables_partagees)
! 1367: .table = NULL;
! 1368: (*(*s_etat_processus).s_liste_variables_partagees)
! 1369: .nombre_variables = 0;
! 1370: (*(*s_etat_processus).s_liste_variables_partagees)
! 1371: .nombre_variables_allouees = 0;
! 1372:
! 1373: insertion_thread(s_etat_processus, d_vrai);
! 1374:
! 1375: // Envoi d'une donnée pour signaler le démarrage du processus au thread
! 1376: // de surveillance.
! 1377:
! 1378: if (write_atomic(s_etat_processus,
! 1379: (*s_argument_thread).pipe_nombre_objets_attente[1],
! 1380: "-", sizeof(unsigned char)) != sizeof(unsigned char))
! 1381: {
! 1382: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 1383: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1384:
! 1385: pid_final = -2;
! 1386:
! 1387: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1388: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
! 1389: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1390: {
! 1391: if (longueur_ecriture == -1)
! 1392: {
! 1393: break;
! 1394: }
! 1395: }
! 1396:
! 1397: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1398: (*s_argument_thread).pipe_nombre_objets_attente[1],
! 1399: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1400: {
! 1401: if (longueur_ecriture == -1)
! 1402: {
! 1403: break;
! 1404: }
! 1405: }
! 1406:
! 1407: exit(EXIT_FAILURE);
! 1408: }
! 1409:
! 1410: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1411: {
! 1412: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1413:
! 1414: pid_final = -2;
! 1415:
! 1416: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1417: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
! 1418: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1419: {
! 1420: if (longueur_ecriture == -1)
! 1421: {
! 1422: break;
! 1423: }
! 1424: }
! 1425:
! 1426: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1427: (*s_argument_thread).pipe_nombre_objets_attente[1],
! 1428: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1429: {
! 1430: if (longueur_ecriture == -1)
! 1431: {
! 1432: break;
! 1433: }
! 1434: }
! 1435:
! 1436: exit(EXIT_FAILURE);
! 1437: }
! 1438:
! 1439: if (pthread_mutex_unlock(&((*s_etat_processus)
! 1440: .protection_liste_mutexes)) != 0)
! 1441: {
! 1442: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1443:
! 1444: pid_final = -2;
! 1445:
! 1446: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1447: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
! 1448: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1449: {
! 1450: if (longueur_ecriture == -1)
! 1451: {
! 1452: break;
! 1453: }
! 1454: }
! 1455:
! 1456: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1457: (*s_argument_thread).pipe_nombre_objets_attente[1],
! 1458: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1459: {
! 1460: if (longueur_ecriture == -1)
! 1461: {
! 1462: break;
! 1463: }
! 1464: }
! 1465:
! 1466: exit(EXIT_FAILURE);
! 1467: }
! 1468:
! 1469: if ((*s_etat_processus).evaluation_expression_compilee == 'N')
! 1470: {
! 1471: free((*s_etat_processus).instruction_courante);
! 1472: (*s_etat_processus).instruction_courante = NULL;
! 1473: }
! 1474:
! 1475: (*s_etat_processus).var_volatile_processus_pere = 0;
! 1476:
! 1477: // On réinitialise toutes les interruptions.
! 1478:
! 1479: (*s_etat_processus).traitement_interruption = 'N';
! 1480: (*s_etat_processus).traitement_interruptible = 'Y';
! 1481: (*s_etat_processus).nombre_interruptions_en_queue = 0;
! 1482: (*s_etat_processus).nombre_interruptions_non_affectees = 0;
! 1483: (*s_etat_processus).processus_detache = d_vrai;
! 1484:
! 1485: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
! 1486: {
! 1487: liberation(s_etat_processus,
! 1488: (*s_etat_processus).corps_interruptions[i]);
! 1489:
! 1490: (*s_etat_processus).corps_interruptions[i] = NULL;
! 1491: (*s_etat_processus).masque_interruptions[i] = 'N';
! 1492: (*s_etat_processus).queue_interruptions[i] = 0;
! 1493:
! 1494: l_element_courant = (*s_etat_processus)
! 1495: .pile_origine_interruptions[i];
! 1496:
! 1497: while(l_element_courant != NULL)
! 1498: {
! 1499: l_element_suivant = (*l_element_courant).suivant;
! 1500: liberation(s_etat_processus, (*l_element_courant).donnee);
! 1501: free(l_element_courant);
! 1502: l_element_courant = l_element_suivant;
! 1503: }
! 1504:
! 1505: (*s_etat_processus).pile_origine_interruptions[i] = NULL;
! 1506: }
! 1507:
! 1508: if ((*s_etat_processus).debug == d_vrai)
! 1509: if (((*s_etat_processus).type_debug &
! 1510: d_debug_processus) != 0)
! 1511: {
! 1512: if ((*s_etat_processus).langue == 'F')
! 1513: {
! 1514: printf("[%d] Lancement du processus fils %d de %d\n",
! 1515: (int) getpid(), (int) getpid(), (int) ppid);
! 1516: }
! 1517: else
! 1518: {
! 1519: printf("[%d] Start child process %d from %d\n", (int) getpid(),
! 1520: (int) getpid(), (int) ppid);
! 1521: }
! 1522:
! 1523: fflush(stdout);
! 1524: }
! 1525:
! 1526: /*
! 1527: * On bloque l'exécution du processus fils jusqu'à ce que
! 1528: * le père ait renseigné correctement la pile des processus.
! 1529: * Dans le cas contraire, on pourrait essayer de traiter
! 1530: * un RECV sur un système chargé avant que cette pile soit
! 1531: * renseignée.
! 1532: */
! 1533:
! 1534: if (sigpending(&set) != 0)
! 1535: {
! 1536: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1537: }
! 1538: else if (sigismember(&set, SIGSTART) == 0)
! 1539: {
! 1540: while(sigismember(&set, SIGSTART) == 0)
! 1541: {
! 1542: if (sigpending(&set) != 0)
! 1543: {
! 1544: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1545: }
! 1546:
! 1547: nanosleep(&attente, NULL);
! 1548: }
! 1549: }
! 1550:
! 1551: (*s_etat_processus).niveau_initial = (*s_etat_processus).niveau_courant;
! 1552: (*s_etat_processus).presence_pipes = d_vrai;
! 1553: (*s_etat_processus).debug_programme = d_faux;
! 1554: (*s_etat_processus).pipe_donnees = (*s_argument_thread).pipe_objets[1];
! 1555: (*s_etat_processus).pipe_nombre_objets_attente = (*s_argument_thread)
! 1556: .pipe_nombre_objets_attente[1];
! 1557: (*s_etat_processus).pipe_interruptions = (*s_argument_thread)
! 1558: .pipe_interruptions[1];
! 1559: (*s_etat_processus).pipe_nombre_interruptions_attente =
! 1560: (*s_argument_thread).pipe_nombre_interruptions_attente[1];
! 1561: (*s_etat_processus).pipe_injections =
! 1562: (*s_argument_thread).pipe_injections[0];
! 1563: (*s_etat_processus).pipe_nombre_injections =
! 1564: (*s_argument_thread).pipe_nombre_injections[0];
! 1565: (*s_etat_processus).pipe_acquittement =
! 1566: (*s_argument_thread).pipe_acquittement[0];
! 1567: (*s_etat_processus).nombre_objets_injectes = 0;
! 1568: (*s_etat_processus).nombre_objets_envoyes_non_lus = 0;
! 1569: (*s_etat_processus).temps_maximal_cpu = 0;
! 1570: (*s_etat_processus).presence_fusible = d_faux;
! 1571: (*s_etat_processus).thread_fusible = 0;
! 1572: (*s_etat_processus).pid_erreur_processus_fils = getpid();
! 1573:
! 1574: if ((*s_etat_processus).profilage == d_vrai)
! 1575: {
! 1576: liberation_profil(s_etat_processus);
! 1577: }
! 1578:
! 1579: (*s_etat_processus).pile_profilage = NULL;
! 1580:
! 1581: if ((*s_etat_processus).generateur_aleatoire != NULL)
! 1582: {
! 1583: liberation_generateur_aleatoire(s_etat_processus);
! 1584: }
! 1585:
! 1586: (*s_etat_processus).generateur_aleatoire = NULL;
! 1587:
! 1588: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
! 1589: {
! 1590: free((*s_etat_processus).instruction_derniere_erreur);
! 1591: (*s_etat_processus).instruction_derniere_erreur = NULL;
! 1592: }
! 1593:
! 1594: /*
! 1595: * Initialisation de la pile des processus
! 1596: */
! 1597:
! 1598: (*s_etat_processus).l_base_pile_processus = NULL;
! 1599: // Les données associées sont déjà effacées par liberation_thread().
! 1600:
! 1601: /*
! 1602: * Initialisation de la pile système
! 1603: */
! 1604:
! 1605: l_element_courant = (struct_liste_chainee *)
! 1606: (*s_etat_processus).l_base_pile_systeme;
! 1607: while(l_element_courant != NULL)
! 1608: {
! 1609: l_element_suivant = (struct_liste_chainee *)
! 1610: (*((struct_liste_pile_systeme *)
! 1611: l_element_courant)).suivant;
! 1612:
! 1613: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
! 1614: l_element_courant)).indice_boucle);
! 1615: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
! 1616: l_element_courant)).limite_indice_boucle);
! 1617: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
! 1618: l_element_courant)).objet_de_test);
! 1619:
! 1620: if ((*((struct_liste_pile_systeme *) l_element_courant))
! 1621: .nom_variable != NULL)
! 1622: {
! 1623: free((*((struct_liste_pile_systeme *)
! 1624: l_element_courant)).nom_variable);
! 1625: }
! 1626:
! 1627: free((struct_liste_pile_systeme *) l_element_courant);
! 1628:
! 1629: l_element_courant = l_element_suivant;
! 1630: }
! 1631:
! 1632: (*s_etat_processus).l_base_pile_systeme = NULL;
! 1633: (*s_etat_processus).hauteur_pile_systeme = 0;
! 1634:
! 1635: empilement_pile_systeme(s_etat_processus);
! 1636:
! 1637: if ((*s_etat_processus).erreur_systeme != d_es)
! 1638: {
! 1639: pid_final = -2;
! 1640:
! 1641: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1642: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
! 1643: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1644: {
! 1645: if (longueur_ecriture == -1)
! 1646: {
! 1647: break;
! 1648: }
! 1649: }
! 1650:
! 1651: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1652: (*s_argument_thread).pipe_nombre_objets_attente[1],
! 1653: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1654: {
! 1655: if (longueur_ecriture == -1)
! 1656: {
! 1657: break;
! 1658: }
! 1659: }
! 1660:
! 1661: exit(EXIT_FAILURE);
! 1662: }
! 1663:
! 1664: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
! 1665:
! 1666: l_element_courant = (struct_liste_chainee *)
! 1667: (*s_etat_processus).s_marques;
! 1668:
! 1669: while(l_element_courant != NULL)
! 1670: {
! 1671: free((*((struct_marque *) l_element_courant)).label);
! 1672: free((*((struct_marque *) l_element_courant)).position);
! 1673: l_element_suivant = (struct_liste_chainee *)
! 1674: (*((struct_marque *) l_element_courant)).suivant;
! 1675: free((struct_marque *) l_element_courant);
! 1676: l_element_courant = l_element_suivant;
! 1677: }
! 1678:
! 1679: (*s_etat_processus).s_marques = NULL;
! 1680:
! 1681: /*
! 1682: * On empile deux valeurs retour_definition pour pouvoir récupérer
! 1683: * les variables dans le cas d'un programme compilé.
! 1684: */
! 1685:
! 1686: empilement_pile_systeme(s_etat_processus);
! 1687:
! 1688: if ((*s_etat_processus).erreur_systeme != d_es)
! 1689: {
! 1690: pid_final = -2;
! 1691:
! 1692: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1693: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
! 1694: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1695: {
! 1696: if (longueur_ecriture == -1)
! 1697: {
! 1698: break;
! 1699: }
! 1700: }
! 1701:
! 1702: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1703: (*s_argument_thread).pipe_nombre_objets_attente[1],
! 1704: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1705: {
! 1706: if (longueur_ecriture == -1)
! 1707: {
! 1708: break;
! 1709: }
! 1710: }
! 1711:
! 1712: exit(EXIT_FAILURE);
! 1713: }
! 1714:
! 1715: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
! 1716:
! 1717: /*
! 1718: * Destruction des sorties graphiques et PostScript
! 1719: */
! 1720:
! 1721: while((*s_etat_processus).fichiers_graphiques != NULL)
! 1722: {
! 1723: free((*(*s_etat_processus).fichiers_graphiques).nom);
! 1724:
! 1725: if ((*(*s_etat_processus).fichiers_graphiques).legende != NULL)
! 1726: {
! 1727: free((*(*s_etat_processus).fichiers_graphiques).legende);
! 1728: }
! 1729:
! 1730: l_element_precedent = (void *) (*s_etat_processus)
! 1731: .fichiers_graphiques;
! 1732: (*s_etat_processus).fichiers_graphiques =
! 1733: (*(*s_etat_processus).fichiers_graphiques).suivant;
! 1734: free(l_element_precedent);
! 1735: }
! 1736:
! 1737: if ((*s_etat_processus).entree_standard != NULL)
! 1738: {
! 1739: pclose((*s_etat_processus).entree_standard);
! 1740: (*s_etat_processus).entree_standard = NULL;
! 1741: }
! 1742:
! 1743: (*s_etat_processus).requete_nouveau_plan = d_vrai;
! 1744: (*s_etat_processus).mise_a_jour_trace_requise = d_faux;
! 1745:
! 1746: if ((*s_etat_processus).nom_fichier_impression != NULL)
! 1747: {
! 1748: free((*s_etat_processus).nom_fichier_impression);
! 1749: (*s_etat_processus).nom_fichier_impression = NULL;
! 1750: }
! 1751:
! 1752: /*
! 1753: * Destruction des piles de fichiers
! 1754: */
! 1755:
! 1756: l_element_courant = (*s_etat_processus).s_fichiers;
! 1757:
! 1758: while(l_element_courant != NULL)
! 1759: {
! 1760: l_element_suivant = (*l_element_courant).suivant;
! 1761:
! 1762: fclose((*((struct_descripteur_fichier *)
! 1763: (*l_element_courant).donnee)).descripteur);
! 1764:
! 1765: free((*((struct_descripteur_fichier *) (*l_element_courant)
! 1766: .donnee)).nom);
! 1767: free((struct_descripteur_fichier *) (*l_element_courant).donnee);
! 1768: free(l_element_courant);
! 1769:
! 1770: l_element_courant = l_element_suivant;
! 1771: }
! 1772:
! 1773: /*
! 1774: * Destruction des piles de connecteurs SQL
! 1775: */
! 1776:
! 1777: l_element_courant = (*s_etat_processus).s_connecteurs_sql;
! 1778:
! 1779: while(l_element_courant != NULL)
! 1780: {
! 1781: l_element_suivant = (*l_element_courant).suivant;
! 1782:
! 1783: sqlclose((*l_element_courant).donnee);
! 1784: liberation(s_etat_processus, (*l_element_courant).donnee);
! 1785: l_element_courant = l_element_suivant;
! 1786: }
! 1787:
! 1788: /*
! 1789: * On ne détruit pas les sockets car il faut utiliser DETACH
! 1790: * pour traiter plusieurs connexions simultanées sur les sockets
! 1791: */
! 1792:
! 1793: (*s_etat_processus).s_fichiers = NULL;
! 1794:
! 1795: if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0)
! 1796: {
! 1797: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1798: }
! 1799:
! 1800: sigpending(&set);
! 1801:
! 1802: if ((*s_etat_processus).erreur_systeme == d_es)
! 1803: {
! 1804: if (variable_partagee == d_faux)
! 1805: {
! 1806: if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur)
! 1807: {
! 1808: if (((*s_etat_processus).erreur_execution == d_ex) &&
! 1809: ((*s_etat_processus).erreur_systeme == d_es))
! 1810: {
! 1811: (*s_etat_processus).erreur_execution =
! 1812: d_ex_erreur_evaluation;
! 1813: }
! 1814: }
! 1815: }
! 1816: else
! 1817: {
! 1818: if (evaluation(s_etat_processus, s_copie, 'E') == d_erreur)
! 1819: {
! 1820: if (((*s_etat_processus).erreur_execution == d_ex) &&
! 1821: ((*s_etat_processus).erreur_systeme == d_es))
! 1822: {
! 1823: (*s_etat_processus).erreur_execution =
! 1824: d_ex_erreur_evaluation;
! 1825: }
! 1826: }
! 1827:
! 1828: liberation(s_etat_processus, s_copie);
! 1829: }
! 1830: }
! 1831:
! 1832: l_element_courant = (*s_etat_processus).liste_mutexes;
! 1833: while(l_element_courant != NULL)
! 1834: {
! 1835: pthread_mutex_trylock(&((*((struct_mutex *)
! 1836: (*(*l_element_courant).donnee).objet)).mutex));
! 1837: pthread_mutex_unlock(&((*((struct_mutex *)
! 1838: (*(*l_element_courant).donnee).objet)).mutex));
! 1839: pthread_mutex_destroy(&((*((struct_mutex *)
! 1840: (*(*l_element_courant).donnee).objet)).mutex));
! 1841:
! 1842: liberation(s_etat_processus, (*l_element_courant).donnee);
! 1843: l_element_suivant = (*l_element_courant).suivant;
! 1844: free(l_element_courant);
! 1845: l_element_courant = l_element_suivant;
! 1846: }
! 1847:
! 1848: if ((*s_etat_processus).presence_fusible == d_vrai)
! 1849: {
! 1850: pthread_cancel((*s_etat_processus).thread_fusible);
! 1851: }
! 1852:
! 1853: pid_final = -2;
! 1854:
! 1855: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1856: (*s_argument_thread).pipe_nombre_interruptions_attente[1],
! 1857: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1858: {
! 1859: if (longueur_ecriture == -1)
! 1860: {
! 1861: break;
! 1862: }
! 1863: }
! 1864:
! 1865: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1866: (*s_argument_thread).pipe_nombre_objets_attente[1],
! 1867: &pid_final, sizeof(pid_final))) != sizeof(pid_final))
! 1868: {
! 1869: if (longueur_ecriture == -1)
! 1870: {
! 1871: break;
! 1872: }
! 1873: }
! 1874:
! 1875: if ((*s_etat_processus).var_volatile_processus_pere != 0)
! 1876: {
! 1877: // Racine des processus atteinte
! 1878:
! 1879: erreur = d_ex;
! 1880:
! 1881: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1882: (*s_argument_thread).pipe_erreurs[1], &erreur,
! 1883: sizeof((*s_etat_processus).erreur_execution))) !=
! 1884: sizeof((*s_etat_processus).erreur_execution))
! 1885: {
! 1886: if (longueur_ecriture == -1)
! 1887: {
! 1888: break;
! 1889: }
! 1890: }
! 1891: }
! 1892: else
! 1893: {
! 1894: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1895: (*s_argument_thread).pipe_erreurs[1],
! 1896: &((*s_etat_processus).erreur_execution),
! 1897: sizeof((*s_etat_processus).erreur_execution))) !=
! 1898: sizeof((*s_etat_processus).erreur_execution))
! 1899: {
! 1900: if (longueur_ecriture == -1)
! 1901: {
! 1902: break;
! 1903: }
! 1904: }
! 1905: }
! 1906:
! 1907: if ((*s_etat_processus).var_volatile_processus_pere != 0)
! 1908: {
! 1909: // Racine des processus atteinte
! 1910:
! 1911: erreur = d_es;
! 1912:
! 1913: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1914: (*s_argument_thread).pipe_erreurs[1], &erreur,
! 1915: sizeof((*s_etat_processus).erreur_systeme))) !=
! 1916: sizeof((*s_etat_processus).erreur_systeme))
! 1917: {
! 1918: if (longueur_ecriture == -1)
! 1919: {
! 1920: break;
! 1921: }
! 1922: }
! 1923: }
! 1924: else
! 1925: {
! 1926: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1927: (*s_argument_thread).pipe_erreurs[1],
! 1928: &((*s_etat_processus).erreur_systeme),
! 1929: sizeof((*s_etat_processus).erreur_systeme))) !=
! 1930: sizeof((*s_etat_processus).erreur_systeme))
! 1931: {
! 1932: if (longueur_ecriture == -1)
! 1933: {
! 1934: break;
! 1935: }
! 1936: }
! 1937: }
! 1938:
! 1939: if ((*s_etat_processus).pid_erreur_processus_fils == 0)
! 1940: {
! 1941: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1942: (*s_argument_thread).pipe_erreurs[1],
! 1943: &ppid, sizeof(ppid))) != sizeof(ppid))
! 1944: {
! 1945: if (longueur_ecriture == -1)
! 1946: {
! 1947: break;
! 1948: }
! 1949: }
! 1950: }
! 1951: else
! 1952: {
! 1953: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1954: (*s_argument_thread).pipe_erreurs[1],
! 1955: &((*s_etat_processus).pid_erreur_processus_fils),
! 1956: sizeof((*s_etat_processus).pid_erreur_processus_fils))) !=
! 1957: sizeof((*s_etat_processus).pid_erreur_processus_fils))
! 1958: {
! 1959: if (longueur_ecriture == -1)
! 1960: {
! 1961: break;
! 1962: }
! 1963: }
! 1964: }
! 1965:
! 1966: close((*s_argument_thread).pipe_erreurs[1]);
! 1967: close((*s_argument_thread).pipe_interruptions[1]);
! 1968: close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);
! 1969: close((*s_argument_thread).pipe_objets[1]);
! 1970: close((*s_argument_thread).pipe_nombre_objets_attente[1]);
! 1971: close((*s_argument_thread).pipe_injections[0]);
! 1972: close((*s_argument_thread).pipe_nombre_injections[0]);
! 1973: close((*s_argument_thread).pipe_acquittement[0]);
! 1974:
! 1975: l_element_courant = (*s_etat_processus).s_fichiers;
! 1976:
! 1977: while(l_element_courant != NULL)
! 1978: {
! 1979: l_element_suivant = (*l_element_courant).suivant;
! 1980:
! 1981: fclose((*((struct_descripteur_fichier *)
! 1982: (*l_element_courant).donnee)).descripteur);
! 1983:
! 1984: if (((*((struct_descripteur_fichier *) (*l_element_courant)
! 1985: .donnee)).pid == getpid()) &&
! 1986: (pthread_equal((*((struct_descripteur_fichier *)
! 1987: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
! 1988: {
! 1989: if ((*((struct_descripteur_fichier *) (*l_element_courant)
! 1990: .donnee)).effacement == 'Y')
! 1991: {
! 1992: unlink((*((struct_descripteur_fichier *)
! 1993: (*l_element_courant).donnee)).nom);
! 1994: }
! 1995: }
! 1996:
! 1997: free((*((struct_descripteur_fichier *) (*l_element_courant)
! 1998: .donnee)).nom);
! 1999: free((struct_descripteur_fichier *) (*l_element_courant).donnee);
! 2000: free(l_element_courant);
! 2001:
! 2002: l_element_courant = l_element_suivant;
! 2003: }
! 2004:
! 2005: pthread_mutex_lock(&((*s_etat_processus).mutex));
! 2006:
! 2007: l_element_courant = (struct_liste_chainee *)
! 2008: (*s_etat_processus).l_base_pile_processus;
! 2009:
! 2010: while(l_element_courant != NULL)
! 2011: {
! 2012: if ((*(*((struct_processus_fils *) (*(*((struct_liste_chainee *)
! 2013: l_element_courant)).donnee).objet)).thread)
! 2014: .processus_detache == d_vrai)
! 2015: {
! 2016: if ((*s_etat_processus).debug == d_vrai)
! 2017: {
! 2018: if (((*s_etat_processus).type_debug & d_debug_processus)
! 2019: != 0)
! 2020: {
! 2021: if ((*s_etat_processus).langue == 'F')
! 2022: {
! 2023: printf("[%d] Signalement pour arrêt du "
! 2024: "processus %d\n",
! 2025: (int) getpid(),
! 2026: (int) (*(*((struct_processus_fils *)
! 2027: (*(*((struct_liste_chainee *)
! 2028: l_element_courant)).donnee).objet))
! 2029: .thread).pid);
! 2030: }
! 2031: else
! 2032: {
! 2033: printf("[%d] Send stop signal to process %d\n",
! 2034: (int) getpid(),
! 2035: (int) (*(*((struct_processus_fils *)
! 2036: (*(*((struct_liste_chainee *)
! 2037: l_element_courant)).donnee).objet))
! 2038: .thread).pid);
! 2039: }
! 2040: }
! 2041: }
! 2042:
! 2043: if ((*s_etat_processus).var_volatile_alarme != 0)
! 2044: {
! 2045: kill((*(*((struct_processus_fils *)
! 2046: (*(*l_element_courant).donnee).objet)).thread).pid,
! 2047: SIGURG);
! 2048: }
! 2049: else
! 2050: {
! 2051: kill((*(*((struct_processus_fils *)
! 2052: (*(*l_element_courant).donnee).objet)).thread).pid,
! 2053: SIGFSTOP);
! 2054: }
! 2055: }
! 2056: else
! 2057: {
! 2058: if ((*s_etat_processus).debug == d_vrai)
! 2059: {
! 2060: if (((*s_etat_processus).type_debug & d_debug_processus)
! 2061: != 0)
! 2062: {
! 2063: if ((*s_etat_processus).langue == 'F')
! 2064: {
! 2065: printf("[%d] Signalement pour arrêt du "
! 2066: "thread %llu\n",
! 2067: (int) getpid(), (unsigned long long)
! 2068: (*(*((struct_processus_fils *)
! 2069: (*(*((struct_liste_chainee *)
! 2070: l_element_courant)).donnee).objet)).thread)
! 2071: .tid);
! 2072: }
! 2073: else
! 2074: {
! 2075: printf("[%d] Send stop signal to thread %llu\n",
! 2076: (int) getpid(), (unsigned long long)
! 2077: (*(*((struct_processus_fils *)
! 2078: (*(*((struct_liste_chainee *)
! 2079: l_element_courant)).donnee).objet)).thread)
! 2080: .tid);
! 2081: }
! 2082: }
! 2083: }
! 2084:
! 2085: pthread_mutex_lock(&((*(*((struct_processus_fils *)
! 2086: (*(*l_element_courant).donnee).objet)).thread).mutex));
! 2087:
! 2088: if ((*(*((struct_processus_fils *)
! 2089: (*(*l_element_courant).donnee).objet)).thread)
! 2090: .thread_actif == d_vrai)
! 2091: {
! 2092: if ((*s_etat_processus).var_volatile_alarme != 0)
! 2093: {
! 2094: pthread_kill((*(*((struct_processus_fils *)
! 2095: (*(*l_element_courant).donnee).objet)).thread)
! 2096: .tid, SIGURG);
! 2097: }
! 2098: else
! 2099: {
! 2100: pthread_kill((*(*((struct_processus_fils *)
! 2101: (*(*l_element_courant).donnee).objet)).thread)
! 2102: .tid, SIGFSTOP);
! 2103: }
! 2104: }
! 2105:
! 2106: pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 2107: (*(*l_element_courant).donnee).objet)).thread).mutex));
! 2108: }
! 2109:
! 2110: l_element_courant = (*l_element_courant).suivant;
! 2111: }
! 2112:
! 2113: /*
! 2114: * Attente de la fin de tous les processus fils
! 2115: */
! 2116:
! 2117: for(i = 0; i < d_NOMBRE_INTERRUPTIONS;
! 2118: (*s_etat_processus).masque_interruptions[i++] = 'I');
! 2119:
! 2120: attente.tv_sec = 0;
! 2121: attente.tv_nsec = GRANULARITE_us * 1000;
! 2122:
! 2123: while((*s_etat_processus).l_base_pile_processus != NULL)
! 2124: {
! 2125: status = 0;
! 2126:
! 2127: l_element_courant = (struct_liste_chainee *)
! 2128: (*s_etat_processus).l_base_pile_processus;
! 2129:
! 2130: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
! 2131: {
! 2132: affectation_interruptions_logicielles(s_etat_processus);
! 2133: }
! 2134:
! 2135: registre_stop = (*s_etat_processus)
! 2136: .var_volatile_traitement_retarde_stop;
! 2137: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
! 2138:
! 2139: for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *)
! 2140: (*(*l_element_courant)
! 2141: .donnee).objet)).thread).nombre_objets_dans_pipe; i++)
! 2142: {
! 2143: if ((s_objet_temporaire = lecture_pipe(s_etat_processus,
! 2144: (*(*((struct_processus_fils *) (*(*l_element_courant)
! 2145: .donnee).objet)).thread).pipe_objets[0])) != NULL)
! 2146: {
! 2147: liberation(s_etat_processus, s_objet_temporaire);
! 2148:
! 2149: (*(*((struct_processus_fils *) (*(*l_element_courant)
! 2150: .donnee).objet)).thread).nombre_objets_dans_pipe--;
! 2151:
! 2152: action.sa_handler = SIG_IGN;
! 2153: action.sa_flags = SA_ONSTACK;
! 2154:
! 2155: if (sigaction(SIGPIPE, &action, ®istre) != 0)
! 2156: {
! 2157: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2158:
! 2159: if (registre_stop == 0)
! 2160: {
! 2161: if ((*s_etat_processus)
! 2162: .var_volatile_traitement_retarde_stop
! 2163: == -1)
! 2164: {
! 2165: (*s_etat_processus)
! 2166: .var_volatile_requete_arret = -1;
! 2167: }
! 2168:
! 2169: (*s_etat_processus)
! 2170: .var_volatile_traitement_retarde_stop =
! 2171: registre_stop;
! 2172: }
! 2173:
! 2174: (*s_etat_processus).erreur_systeme = d_es_signal;
! 2175: exit(EXIT_FAILURE);
! 2176: }
! 2177:
! 2178: while((longueur_ecriture = write_atomic(
! 2179: s_etat_processus, (*(*((struct_processus_fils *)
! 2180: (*(*l_element_courant).donnee).objet))
! 2181: .thread).pipe_nombre_injections[1], "+",
! 2182: sizeof(unsigned char))) !=
! 2183: sizeof(unsigned char))
! 2184: {
! 2185: if (longueur_ecriture == -1)
! 2186: {
! 2187: // Le processus n'existe plus.
! 2188: break;
! 2189: }
! 2190: }
! 2191:
! 2192: if (registre_stop == 0)
! 2193: {
! 2194: if ((*s_etat_processus)
! 2195: .var_volatile_traitement_retarde_stop == -1)
! 2196: {
! 2197: (*s_etat_processus).var_volatile_requete_arret
! 2198: = -1;
! 2199: }
! 2200:
! 2201: (*s_etat_processus)
! 2202: .var_volatile_traitement_retarde_stop =
! 2203: registre_stop;
! 2204: }
! 2205:
! 2206: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
! 2207: {
! 2208: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2209:
! 2210: (*s_etat_processus).erreur_systeme = d_es_signal;
! 2211: exit(EXIT_FAILURE);
! 2212: }
! 2213: }
! 2214: }
! 2215:
! 2216: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2217: nanosleep(&attente, NULL);
! 2218: pthread_mutex_lock(&((*s_etat_processus).mutex));
! 2219: }
! 2220:
! 2221: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2222:
! 2223: l_element_courant = (*s_etat_processus).s_sockets;
! 2224:
! 2225: while(l_element_courant != NULL)
! 2226: {
! 2227: l_element_suivant = (*l_element_courant).suivant;
! 2228:
! 2229: if ((*((struct_socket *) (*(*l_element_courant).donnee)
! 2230: .objet)).socket_connectee == d_vrai)
! 2231: {
! 2232: shutdown((*((struct_socket *) (*(*l_element_courant).donnee)
! 2233: .objet)).socket, SHUT_RDWR);
! 2234: }
! 2235:
! 2236: close((*((struct_socket *) (*(*l_element_courant).donnee)
! 2237: .objet)).socket);
! 2238:
! 2239: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet))
! 2240: .pid == getpid()) && (pthread_equal((*((struct_socket *)
! 2241: (*(*l_element_courant).donnee).objet)).tid, pthread_self())
! 2242: != 0))
! 2243: {
! 2244: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
! 2245: .effacement == 'Y')
! 2246: {
! 2247: unlink((*((struct_socket *) (*(*l_element_courant).donnee)
! 2248: .objet)).adresse);
! 2249: }
! 2250: }
! 2251:
! 2252: liberation(s_etat_processus,
! 2253: (*((struct_liste_chainee *) l_element_courant)).donnee);
! 2254: free(l_element_courant);
! 2255:
! 2256: l_element_courant = l_element_suivant;
! 2257: }
! 2258:
! 2259: l_element_courant = (*s_etat_processus).s_connecteurs_sql;
! 2260:
! 2261: while(l_element_courant != NULL)
! 2262: {
! 2263: l_element_suivant = (*l_element_courant).suivant;
! 2264:
! 2265: sqlclose((*l_element_courant).donnee);
! 2266:
! 2267: liberation(s_etat_processus,
! 2268: (*((struct_liste_chainee *) l_element_courant)).donnee);
! 2269: free(l_element_courant);
! 2270:
! 2271: l_element_courant = l_element_suivant;
! 2272: }
! 2273:
! 2274: if ((((*s_etat_processus).erreur_execution != d_ex) ||
! 2275: ((*s_etat_processus).exception != d_ep) ||
! 2276: ((*s_etat_processus).erreur_systeme != d_es)) &&
! 2277: ((*s_etat_processus).var_volatile_traitement_sigint == 0))
! 2278: {
! 2279: printf("%s [%d]\n", message =
! 2280: messages(s_etat_processus), (int) getpid());
! 2281: free(message);
! 2282:
! 2283: if ((*s_etat_processus).core == d_vrai)
! 2284: {
! 2285: printf("\n");
! 2286:
! 2287: if ((*s_etat_processus).langue == 'F')
! 2288: {
! 2289: printf("+++Information : Génération du fichier rpl-core "
! 2290: "[%d]\n", (int) getpid());
! 2291: }
! 2292: else
! 2293: {
! 2294: printf("+++Information : Writing rpl-core file [%d]\n",
! 2295: (int) getpid());
! 2296: }
! 2297:
! 2298: rplcore(s_etat_processus);
! 2299:
! 2300: if ((*s_etat_processus).langue == 'F')
! 2301: {
! 2302: printf("+++Information : Processus tracé [%d]\n",
! 2303: (int) getpid());
! 2304: }
! 2305: else
! 2306: {
! 2307: printf("+++Information : Done [%d]\n", (int) getpid());
! 2308: }
! 2309:
! 2310: printf("\n");
! 2311: fflush(stdout);
! 2312: }
! 2313: }
! 2314:
! 2315: liberation_arbre_instructions(s_etat_processus,
! 2316: (*s_etat_processus).arbre_instructions);
! 2317: free((*s_etat_processus).pointeurs_caracteres);
! 2318:
! 2319: if ((*s_etat_processus).entree_standard != NULL)
! 2320: {
! 2321: pclose((*s_etat_processus).entree_standard);
! 2322: (*s_etat_processus).entree_standard = NULL;
! 2323: }
! 2324:
! 2325: liberation(s_etat_processus, (*s_etat_processus).indep);
! 2326: liberation(s_etat_processus, (*s_etat_processus).depend);
! 2327:
! 2328: free((*s_etat_processus).label_x);
! 2329: free((*s_etat_processus).label_y);
! 2330: free((*s_etat_processus).label_z);
! 2331: free((*s_etat_processus).titre);
! 2332: free((*s_etat_processus).legende);
! 2333:
! 2334: liberation(s_etat_processus,
! 2335: (*s_etat_processus).parametres_courbes_de_niveau);
! 2336:
! 2337: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
! 2338: {
! 2339: free((*s_etat_processus).instruction_derniere_erreur);
! 2340: (*s_etat_processus).instruction_derniere_erreur = NULL;
! 2341: }
! 2342:
! 2343: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
! 2344: {
! 2345: liberation(s_etat_processus,
! 2346: (*s_etat_processus).s_liste_variables[i].objet);
! 2347: free((*s_etat_processus).s_liste_variables[i].nom);
! 2348: }
! 2349:
! 2350: free((*s_etat_processus).s_liste_variables);
! 2351:
! 2352: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
! 2353: {
! 2354: liberation(s_etat_processus,
! 2355: (*s_etat_processus).s_liste_variables_statiques[i].objet);
! 2356: free((*s_etat_processus).s_liste_variables_statiques[i].nom);
! 2357: }
! 2358:
! 2359: free((*s_etat_processus).s_liste_variables_statiques);
! 2360:
! 2361: for(i = 0; i < (*(*s_etat_processus).s_liste_variables_partagees)
! 2362: .nombre_variables; i++)
! 2363: {
! 2364: liberation(s_etat_processus,
! 2365: (*(*s_etat_processus).s_liste_variables_partagees)
! 2366: .table[i].objet);
! 2367: free((*(*s_etat_processus).s_liste_variables_partagees)
! 2368: .table[i].nom);
! 2369: }
! 2370:
! 2371: if ((*(*s_etat_processus).s_liste_variables_partagees).table
! 2372: != NULL)
! 2373: {
! 2374: free((struct_variable_partagee *)
! 2375: (*(*s_etat_processus).s_liste_variables_partagees).table);
! 2376: }
! 2377:
! 2378: pthread_mutex_destroy(&((*(*s_etat_processus)
! 2379: .s_liste_variables_partagees).mutex));
! 2380:
! 2381: l_element_courant = (*s_etat_processus).l_base_pile;
! 2382: while(l_element_courant != NULL)
! 2383: {
! 2384: l_element_suivant = (*l_element_courant).suivant;
! 2385:
! 2386: liberation(s_etat_processus, (*l_element_courant).donnee);
! 2387: free(l_element_courant);
! 2388:
! 2389: l_element_courant = l_element_suivant;
! 2390: }
! 2391:
! 2392: l_element_courant = (*s_etat_processus).l_base_pile_last;
! 2393: while(l_element_courant != NULL)
! 2394: {
! 2395: l_element_suivant = (*l_element_courant).suivant;
! 2396:
! 2397: liberation(s_etat_processus, (*l_element_courant).donnee);
! 2398: free(l_element_courant);
! 2399:
! 2400: l_element_courant = l_element_suivant;
! 2401: }
! 2402:
! 2403: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
! 2404: while(l_element_courant != NULL)
! 2405: {
! 2406: l_element_suivant = (*l_element_courant).suivant;
! 2407:
! 2408: liberation(s_etat_processus, (*l_element_courant).donnee);
! 2409: free(l_element_courant);
! 2410:
! 2411: l_element_courant = l_element_suivant;
! 2412: }
! 2413:
! 2414: l_element_courant = (*s_etat_processus).l_base_pile_taille_contextes;
! 2415: while(l_element_courant != NULL)
! 2416: {
! 2417: l_element_suivant = (*l_element_courant).suivant;
! 2418:
! 2419: liberation(s_etat_processus, (*l_element_courant).donnee);
! 2420: free(l_element_courant);
! 2421:
! 2422: l_element_courant = l_element_suivant;
! 2423: }
! 2424:
! 2425: l_element_courant = (struct_liste_chainee *)
! 2426: (*s_etat_processus).l_base_pile_systeme;
! 2427: while(l_element_courant != NULL)
! 2428: {
! 2429: l_element_suivant = (struct_liste_chainee *)
! 2430: (*((struct_liste_pile_systeme *)
! 2431: l_element_courant)).suivant;
! 2432:
! 2433: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
! 2434: l_element_courant)).indice_boucle);
! 2435: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
! 2436: l_element_courant)).limite_indice_boucle);
! 2437: liberation(s_etat_processus, (*((struct_liste_pile_systeme *)
! 2438: l_element_courant)).objet_de_test);
! 2439:
! 2440: if ((*((struct_liste_pile_systeme *)
! 2441: l_element_courant)).nom_variable != NULL)
! 2442: {
! 2443: free((*((struct_liste_pile_systeme *)
! 2444: l_element_courant)).nom_variable);
! 2445: }
! 2446:
! 2447: free((struct_liste_pile_systeme *) l_element_courant);
! 2448:
! 2449: l_element_courant = l_element_suivant;
! 2450: }
! 2451:
! 2452: /*
! 2453: * Destruction des bibliothèques
! 2454: */
! 2455:
! 2456: l_element_courant = (*s_etat_processus).s_bibliotheques;
! 2457:
! 2458: while(l_element_courant != NULL)
! 2459: {
! 2460: l_element_suivant = (*l_element_courant).suivant;
! 2461:
! 2462: free((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom);
! 2463:
! 2464: dlclose((*((struct_bibliotheque *) (*l_element_courant).donnee))
! 2465: .descripteur);
! 2466:
! 2467: free((*l_element_courant).donnee);
! 2468: free(l_element_courant);
! 2469:
! 2470: l_element_courant = l_element_suivant;
! 2471: }
! 2472:
! 2473: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
! 2474: {
! 2475: free((*s_etat_processus).s_instructions_externes[i].nom);
! 2476: free((*s_etat_processus).s_instructions_externes[i]
! 2477: .nom_bibliotheque);
! 2478: }
! 2479:
! 2480: if ((*s_etat_processus).nombre_instructions_externes != 0)
! 2481: {
! 2482: free((*s_etat_processus).s_instructions_externes);
! 2483: }
! 2484:
! 2485: l_element_courant = (struct_liste_chainee *)
! 2486: (*s_etat_processus).s_marques;
! 2487:
! 2488: while(l_element_courant != NULL)
! 2489: {
! 2490: free((*((struct_marque *) l_element_courant)).label);
! 2491: free((*((struct_marque *) l_element_courant)).position);
! 2492: l_element_suivant = (struct_liste_chainee *)
! 2493: (*((struct_marque *) l_element_courant)).suivant;
! 2494: free((struct_marque *) l_element_courant);
! 2495: l_element_courant = l_element_suivant;
! 2496: }
! 2497:
! 2498: free((*s_etat_processus).chemin_fichiers_temporaires);
! 2499:
! 2500: if ((*s_etat_processus).debug == d_vrai)
! 2501: if (((*s_etat_processus).type_debug &
! 2502: d_debug_processus) != 0)
! 2503: {
! 2504: if ((*s_etat_processus).langue == 'F')
! 2505: {
! 2506: printf("[%d] Arrêt du processus\n", (int) getpid());
! 2507: }
! 2508: else
! 2509: {
! 2510: printf("[%d] Stop process\n", (int) getpid());
! 2511: }
! 2512:
! 2513: fflush(stdout);
! 2514: }
! 2515:
! 2516: liberation(s_etat_processus, s_objet);
! 2517:
! 2518: free((*s_etat_processus).pile_signal.ss_sp);
! 2519: free((*s_etat_processus).definitions_chainees);
! 2520:
! 2521: free((*s_etat_processus).nom_fichier_historique);
! 2522:
! 2523: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
! 2524: {
! 2525: liberation(s_etat_processus,
! 2526: (*s_etat_processus).corps_interruptions[i]);
! 2527:
! 2528: l_element_courant = (*s_etat_processus)
! 2529: .pile_origine_interruptions[i];
! 2530:
! 2531: while(l_element_courant != NULL)
! 2532: {
! 2533: l_element_suivant = (*l_element_courant).suivant;
! 2534:
! 2535: liberation(s_etat_processus, (*l_element_courant).donnee);
! 2536: free(l_element_courant);
! 2537:
! 2538: l_element_courant = l_element_suivant;
! 2539: }
! 2540: }
! 2541:
! 2542: if ((*s_etat_processus).generateur_aleatoire != NULL)
! 2543: {
! 2544: liberation_generateur_aleatoire(s_etat_processus);
! 2545: }
! 2546:
! 2547: if ((*s_etat_processus).profilage == d_vrai)
! 2548: {
! 2549: ecriture_profil(s_etat_processus);
! 2550: liberation_profil(s_etat_processus);
! 2551: }
! 2552:
! 2553: closelog();
! 2554:
! 2555: liberation_allocateur(s_etat_processus);
! 2556: retrait_thread(s_etat_processus);
! 2557:
! 2558: pthread_mutex_destroy(&((*s_etat_processus).mutex));
! 2559: pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
! 2560:
! 2561: pthread_key_delete(semaphore_fork_processus_courant);
! 2562:
! 2563: sem_post(&((*s_etat_processus).semaphore_fork));
! 2564: sem_destroy(&((*s_etat_processus).semaphore_fork));
! 2565:
! 2566: free((*s_etat_processus).localisation);
! 2567: free(s_etat_processus);
! 2568: free(s_argument_thread);
! 2569:
! 2570: sem_destroy(&semaphore_liste_threads);
! 2571: sem_post(&semaphore_gestionnaires_signaux);
! 2572: sem_destroy(&semaphore_gestionnaires_signaux);
! 2573: sem_destroy(&semaphore_gestionnaires_signaux_atomique);
! 2574:
! 2575: clear_history();
! 2576: exit(EXIT_SUCCESS);
! 2577: }
! 2578: else
! 2579: {
! 2580: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2581: return;
! 2582: }
! 2583:
! 2584: liberation(s_etat_processus, s_objet);
! 2585:
! 2586: if ((s_objet = allocation(s_etat_processus, PRC)) == NULL)
! 2587: {
! 2588: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2589: return;
! 2590: }
! 2591:
! 2592: (*((struct_processus_fils *) (*s_objet).objet)).thread = s_argument_thread;
! 2593: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
! 2594: .nombre_objets_dans_pipe = 0;
! 2595: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
! 2596: .nombre_interruptions_dans_pipe = 0;
! 2597: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
! 2598: .nombre_references = 1;
! 2599:
! 2600: /*
! 2601: * On copie l'objet plutôt que le pointeur car cet objet peut être
! 2602: * accédé depuis deux threads distincts et aboutir à un blocage lors d'une
! 2603: * copie.
! 2604: */
! 2605:
! 2606: if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
! 2607: {
! 2608: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2609: return;
! 2610: }
! 2611:
! 2612: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 2613: {
! 2614: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2615: return;
! 2616: }
! 2617:
! 2618: // Si le pid existe déjà dans la pile des processus, il s'agit forcement
! 2619: // d'un processus moribond. On attend donc qu'il soit effectivement
! 2620: // libéré.
! 2621:
! 2622: do
! 2623: {
! 2624: l_element_courant = (struct_liste_chainee *)
! 2625: (*s_etat_processus).l_base_pile_processus;
! 2626: drapeau = d_faux;
! 2627:
! 2628: attente.tv_sec = 0;
! 2629: attente.tv_nsec = GRANULARITE_us * 1000;
! 2630:
! 2631: while(l_element_courant != NULL)
! 2632: {
! 2633: if ((*(*((struct_processus_fils *)
! 2634: (*(*l_element_courant).donnee).objet)).thread)
! 2635: .processus_detache == d_vrai)
! 2636: {
! 2637: if ((*(*((struct_processus_fils *)
! 2638: (*(*l_element_courant).donnee).objet)).thread).pid ==
! 2639: (*s_argument_thread).pid)
! 2640: {
! 2641: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 2642: {
! 2643: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2644: return;
! 2645: }
! 2646:
! 2647: nanosleep(&attente, NULL);
! 2648: INCR_GRANULARITE(attente.tv_nsec);
! 2649:
! 2650: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 2651: {
! 2652: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2653: return;
! 2654: }
! 2655:
! 2656: drapeau = d_vrai;
! 2657: break;
! 2658: }
! 2659: }
! 2660:
! 2661: l_element_courant = (*l_element_courant).suivant;
! 2662: }
! 2663: } while(drapeau == d_vrai);
! 2664:
! 2665: if (empilement(s_etat_processus,
! 2666: (struct_liste_chainee **) &((*s_etat_processus)
! 2667: .l_base_pile_processus), s_objet_systeme) == d_erreur)
! 2668: {
! 2669: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2670: return;
! 2671: }
! 2672:
! 2673: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2674: s_objet) == d_erreur)
! 2675: {
! 2676: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2677: return;
! 2678: }
! 2679:
! 2680: // Être sûr que le processus fils soit déjà présent...
! 2681:
! 2682: while(kill((*s_argument_thread).pid, 0) != 0)
! 2683: {
! 2684: //if ((errno != ESRCH) && (errno != EAGAIN))
! 2685: if (errno != ESRCH)
! 2686: {
! 2687: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2688: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2689: return;
! 2690: }
! 2691:
! 2692: nanosleep(&attente, NULL);
! 2693: }
! 2694:
! 2695: // Le fils peut être présent sans être en attente du signal de départ.
! 2696:
! 2697: if (kill((*s_argument_thread).pid, SIGSTART) != 0)
! 2698: {
! 2699: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2700: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2701: return;
! 2702: }
! 2703:
! 2704: if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0)
! 2705: {
! 2706: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2707: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2708: return;
! 2709: }
! 2710:
! 2711: sigpending(&set);
! 2712:
! 2713: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 2714: {
! 2715: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2716: return;
! 2717: }
! 2718:
! 2719: return;
! 2720: }
! 2721:
! 2722: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_d5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src