![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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: Routines de gestion du nombre d'occurrences comme grandeur atomique 29: ================================================================================ 30: entrées : structure sur l'état du processus et objet à afficher 31: -------------------------------------------------------------------------------- 32: sorties : chaine de caractères 33: -------------------------------------------------------------------------------- 34: effets de bord : néant 35: ================================================================================ 36: */ 37: 38: static inline void 39: incrementation_atomique(struct_objet *s_objet) 40: { 41: // Le mutex est sur l'objet. 42: 43: (*s_objet).nombre_occurrences++; 44: 45: BUG((*s_objet).nombre_occurrences <= 0, 46: uprintf("Capacity exceeded %ld\n", (*s_objet).nombre_occurrences)); 47: 48: return; 49: } 50: 51: static inline long 52: decrementation_atomique(struct_objet *s_objet) 53: { 54: // Le mutex est sur l'objet. 55: 56: (*s_objet).nombre_occurrences--; 57: return((*s_objet).nombre_occurrences); 58: } 59: 60: void 61: initialisation_objet(struct_objet *s_objet) 62: { 63: pthread_mutexattr_t attributs_mutex; 64: 65: pthread_mutexattr_init(&attributs_mutex); 66: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); 67: pthread_mutex_init(&((*s_objet).mutex), &attributs_mutex); 68: pthread_mutexattr_destroy(&attributs_mutex); 69: 70: (*s_objet).nombre_occurrences = 1; 71: 72: return; 73: } 74: 75: 76: /* 77: ================================================================================ 78: Routines d'initialisation et de purge de l'allocateur 79: ================================================================================ 80: Entrées : structure sur l'état du processus et objet à afficher 81: -------------------------------------------------------------------------------- 82: Sorties : chaine de caractères 83: -------------------------------------------------------------------------------- 84: Effets de bord : néant 85: ================================================================================ 86: */ 87: 88: void 89: initialisation_allocateur(struct_processus *s_etat_processus) 90: { 91: (*s_etat_processus).estimation_taille_pile_tampon = 0; 92: (*s_etat_processus).taille_pile_tampon = 0; 93: (*s_etat_processus).pile_tampon = NULL; 94: 95: (*s_etat_processus).estimation_taille_pile_systeme_tampon = 0; 96: (*s_etat_processus).taille_pile_systeme_tampon = 0; 97: (*s_etat_processus).pile_systeme_tampon = NULL; 98: 99: (*s_etat_processus).taille_pile_objets = 0; 100: (*s_etat_processus).pile_objets = NULL; 101: 102: (*s_etat_processus).pointeur_adr = 0; 103: (*s_etat_processus).pointeur_bin = 0; 104: (*s_etat_processus).pointeur_cpl = 0; 105: (*s_etat_processus).pointeur_fct = 0; 106: (*s_etat_processus).pointeur_int = 0; 107: (*s_etat_processus).pointeur_mat = 0; 108: (*s_etat_processus).pointeur_nom = 0; 109: (*s_etat_processus).pointeur_rel = 0; 110: (*s_etat_processus).pointeur_tab = 0; 111: (*s_etat_processus).pointeur_vec = 0; 112: (*s_etat_processus).pointeur_maillons = 0; 113: 114: (*s_etat_processus).pointeur_variables_noeud = 0; 115: (*s_etat_processus).pointeur_variables_feuille = 0; 116: (*s_etat_processus).pointeur_variables_variable = 0; 117: (*s_etat_processus).pointeur_variables_tableau_noeuds = 0; 118: 119: return; 120: } 121: 122: 123: void 124: liberation_allocateur(struct_processus *s_etat_processus) 125: { 126: int i; 127: 128: for(i = 0; i < (*s_etat_processus).pointeur_adr; 129: free((*s_etat_processus).objets_adr[i++])); 130: for(i = 0; i < (*s_etat_processus).pointeur_bin; 131: free((*s_etat_processus).objets_bin[i++])); 132: for(i = 0; i < (*s_etat_processus).pointeur_cpl; 133: free((*s_etat_processus).objets_cpl[i++])); 134: for(i = 0; i < (*s_etat_processus).pointeur_fct; 135: free((*s_etat_processus).objets_fct[i++])); 136: for(i = 0; i < (*s_etat_processus).pointeur_int; 137: free((*s_etat_processus).objets_int[i++])); 138: for(i = 0; i < (*s_etat_processus).pointeur_mat; 139: free((*s_etat_processus).objets_mat[i++])); 140: for(i = 0; i < (*s_etat_processus).pointeur_nom; 141: free((*s_etat_processus).objets_nom[i++])); 142: for(i = 0; i < (*s_etat_processus).pointeur_rel; 143: free((*s_etat_processus).objets_rel[i++])); 144: for(i = 0; i < (*s_etat_processus).pointeur_tab; 145: free((*s_etat_processus).objets_tab[i++])); 146: for(i = 0; i < (*s_etat_processus).pointeur_vec; 147: free((*s_etat_processus).objets_vec[i++])); 148: for(i = 0; i < (*s_etat_processus).pointeur_maillons; 149: free((*s_etat_processus).maillons[i++])); 150: 151: for(i = 0; i < (*s_etat_processus).pointeur_variables_noeud; 152: free((*s_etat_processus).variables_noeud[i++])); 153: for(i = 0; i < (*s_etat_processus).pointeur_variables_feuille; 154: free((*s_etat_processus).variables_feuille[i++])); 155: for(i = 0; i < (*s_etat_processus).pointeur_variables_variable; 156: free((*s_etat_processus).variables_variable[i++])); 157: for(i = 0; i < (*s_etat_processus).pointeur_variables_tableau_noeuds; 158: free((*s_etat_processus).variables_tableau_noeuds[i++])); 159: 160: { 161: struct_liste_chainee *l_element_courant; 162: struct_liste_chainee *l_element_suivant; 163: 164: l_element_courant = (*s_etat_processus).pile_tampon; 165: 166: while(l_element_courant != NULL) 167: { 168: l_element_suivant = (*l_element_courant).suivant; 169: liberation(s_etat_processus, (*l_element_courant).donnee); 170: free(l_element_courant); 171: l_element_courant = l_element_suivant; 172: } 173: } 174: 175: { 176: struct_liste_pile_systeme *l_element_courant; 177: struct_liste_pile_systeme *l_element_suivant; 178: 179: l_element_courant = (*s_etat_processus).pile_systeme_tampon; 180: 181: while(l_element_courant != NULL) 182: { 183: l_element_suivant = (*l_element_courant).suivant; 184: free(l_element_courant); 185: l_element_courant = l_element_suivant; 186: } 187: } 188: 189: { 190: struct_objet *l_element_courant; 191: struct_objet *l_element_suivant; 192: 193: l_element_courant = (*s_etat_processus).pile_objets; 194: 195: while(l_element_courant != NULL) 196: { 197: l_element_suivant = (*l_element_courant).objet; 198: 199: if (pthread_mutex_destroy(&((*l_element_courant).mutex)) != 0) 200: { 201: (*s_etat_processus).erreur_systeme = d_es_processus; 202: BUG(1, printf("Mutex error\n")); 203: return; 204: } 205: 206: free(l_element_courant); 207: l_element_courant = l_element_suivant; 208: } 209: } 210: 211: return; 212: } 213: 214: 215: /* 216: ================================================================================ 217: Routine d'allocation d'un maillon d'un objet (liste, expression...) 218: ================================================================================ 219: Entrées : structure sur l'état du processus et objet à afficher 220: -------------------------------------------------------------------------------- 221: Sorties : chaine de caractères 222: -------------------------------------------------------------------------------- 223: Effets de bord : néant 224: ================================================================================ 225: */ 226: 227: void * 228: allocation_maillon(struct_processus *s_etat_processus) 229: { 230: struct_liste_chainee *s_maillon; 231: 232: if ((*s_etat_processus).pointeur_maillons > 0) 233: { 234: s_maillon = (*s_etat_processus).maillons 235: [--(*s_etat_processus).pointeur_maillons]; 236: } 237: else 238: { 239: if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL) 240: { 241: return(NULL); 242: } 243: } 244: 245: return(s_maillon); 246: } 247: 248: 249: /* 250: ================================================================================ 251: Routine de libération d'un maillon d'un objet (liste, expression...) 252: ================================================================================ 253: Entrées : structure sur l'état du processus et objet à afficher 254: -------------------------------------------------------------------------------- 255: Sorties : chaine de caractères 256: -------------------------------------------------------------------------------- 257: Effets de bord : néant 258: ================================================================================ 259: */ 260: 261: void 262: liberation_maillon(struct_processus *s_etat_processus, 263: struct_liste_chainee *maillon) 264: { 265: if ((*s_etat_processus).pointeur_maillons < TAILLE_CACHE) 266: { 267: (*s_etat_processus).maillons 268: [(*s_etat_processus).pointeur_maillons++] = maillon; 269: } 270: else 271: { 272: free(maillon); 273: } 274: 275: return; 276: } 277: 278: 279: /* 280: ================================================================================ 281: Routine d'allocation d'une structure *s_objet 282: ================================================================================ 283: Entrées : structure sur l'état du processus et objet à allouer 284: -------------------------------------------------------------------------------- 285: Sorties : chaine de caractères 286: -------------------------------------------------------------------------------- 287: Effets de bord : néant 288: ================================================================================ 289: */ 290: 291: struct_objet * 292: allocation(struct_processus *s_etat_processus, enum t_type type) 293: { 294: struct_objet *s_objet; 295: 296: if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0) 297: { 298: (*s_etat_processus).erreur_systeme = d_es_processus; 299: return(NULL); 300: } 301: 302: if ((*s_etat_processus).pile_objets == NULL) 303: { 304: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0) 305: { 306: (*s_etat_processus).erreur_systeme = d_es_processus; 307: return(NULL); 308: } 309: 310: // Il n'existe aucune structure struct_objet disponible dans le cache. 311: 312: if ((s_objet = malloc(sizeof(struct_objet))) == NULL) 313: { 314: return(NULL); 315: } 316: 317: initialisation_objet(s_objet); 318: } 319: else 320: { 321: // Récupération d'une structure dans le cache. 322: 323: s_objet = (*s_etat_processus).pile_objets; 324: (*s_etat_processus).pile_objets = (*s_objet).objet; 325: (*s_etat_processus).taille_pile_objets--; 326: 327: (*s_objet).nombre_occurrences = 1; 328: 329: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0) 330: { 331: (*s_etat_processus).erreur_systeme = d_es_processus; 332: return(NULL); 333: } 334: } 335: 336: (*s_objet).type = type; 337: 338: switch(type) 339: { 340: case ADR : 341: { 342: if ((*s_etat_processus).pointeur_adr > 0) 343: { 344: (*s_objet).objet = (*s_etat_processus).objets_adr 345: [--(*s_etat_processus).pointeur_adr]; 346: } 347: else 348: { 349: if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL) 350: { 351: free(s_objet); 352: return(NULL); 353: } 354: } 355: 356: break; 357: } 358: 359: case ALG : 360: { 361: (*s_objet).objet = NULL; 362: break; 363: } 364: 365: case BIN : 366: { 367: if ((*s_etat_processus).pointeur_bin > 0) 368: { 369: (*s_objet).objet = (*s_etat_processus).objets_bin 370: [--(*s_etat_processus).pointeur_bin]; 371: } 372: else 373: { 374: if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL) 375: { 376: free(s_objet); 377: return(NULL); 378: } 379: } 380: 381: break; 382: } 383: 384: case CHN : 385: { 386: (*s_objet).objet = NULL; 387: break; 388: } 389: 390: case CPL : 391: { 392: if ((*s_etat_processus).pointeur_cpl > 0) 393: { 394: (*s_objet).objet = (*s_etat_processus).objets_cpl 395: [--(*s_etat_processus).pointeur_cpl]; 396: } 397: else 398: { 399: if (((*s_objet).objet = malloc(sizeof(struct_complexe16))) 400: == NULL) 401: { 402: free(s_objet); 403: return(NULL); 404: } 405: } 406: 407: break; 408: } 409: 410: case FCH : 411: { 412: if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL) 413: { 414: free(s_objet); 415: return(NULL); 416: } 417: 418: break; 419: } 420: 421: case FCT : 422: { 423: if ((*s_etat_processus).pointeur_fct > 0) 424: { 425: (*s_objet).objet = (*s_etat_processus).objets_fct 426: [--(*s_etat_processus).pointeur_fct]; 427: } 428: else 429: { 430: if (((*s_objet).objet = malloc(sizeof(struct_fonction))) 431: == NULL) 432: { 433: free(s_objet); 434: return(NULL); 435: } 436: } 437: 438: (*((struct_fonction *) (*s_objet).objet)).fonction = NULL; 439: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL; 440: (*((struct_fonction *) (*s_objet).objet)).prediction_execution 441: = d_faux; 442: break; 443: } 444: 445: case INT : 446: { 447: if ((*s_etat_processus).pointeur_int > 0) 448: { 449: (*s_objet).objet = (*s_etat_processus).objets_int 450: [--(*s_etat_processus).pointeur_int]; 451: } 452: else 453: { 454: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL) 455: { 456: free(s_objet); 457: return(NULL); 458: } 459: } 460: 461: break; 462: } 463: 464: case LST : 465: { 466: (*s_objet).objet = NULL; 467: break; 468: } 469: 470: case MCX : 471: { 472: if ((*s_etat_processus).pointeur_mat > 0) 473: { 474: (*s_objet).objet = (*s_etat_processus).objets_mat 475: [--(*s_etat_processus).pointeur_mat]; 476: } 477: else 478: { 479: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) 480: { 481: free(s_objet); 482: return(NULL); 483: } 484: } 485: 486: (*((struct_matrice *) (*s_objet).objet)).type = 'C'; 487: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0; 488: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0; 489: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL; 490: break; 491: } 492: 493: case MIN : 494: { 495: if ((*s_etat_processus).pointeur_mat > 0) 496: { 497: (*s_objet).objet = (*s_etat_processus).objets_mat 498: [--(*s_etat_processus).pointeur_mat]; 499: } 500: else 501: { 502: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) 503: { 504: free(s_objet); 505: return(NULL); 506: } 507: } 508: 509: (*((struct_matrice *) (*s_objet).objet)).type = 'I'; 510: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0; 511: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0; 512: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL; 513: break; 514: } 515: 516: case MRL : 517: { 518: if ((*s_etat_processus).pointeur_mat > 0) 519: { 520: (*s_objet).objet = (*s_etat_processus).objets_mat 521: [--(*s_etat_processus).pointeur_mat]; 522: } 523: else 524: { 525: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) 526: { 527: free(s_objet); 528: return(NULL); 529: } 530: } 531: 532: (*((struct_matrice *) (*s_objet).objet)).type = 'R'; 533: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0; 534: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0; 535: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL; 536: break; 537: } 538: 539: case MTX : 540: { 541: if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL) 542: { 543: free(s_objet); 544: return(NULL); 545: } 546: 547: break; 548: } 549: 550: case NOM : 551: { 552: if ((*s_etat_processus).pointeur_nom > 0) 553: { 554: (*s_objet).objet = (*s_etat_processus).objets_nom 555: [--(*s_etat_processus).pointeur_nom]; 556: } 557: else 558: { 559: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL) 560: { 561: free(s_objet); 562: return(NULL); 563: } 564: } 565: 566: break; 567: } 568: 569: case NON : 570: { 571: (*s_objet).objet = NULL; 572: break; 573: } 574: 575: case PRC : 576: { 577: if (((*s_objet).objet = malloc(sizeof(struct_processus_fils))) 578: == NULL) 579: { 580: free(s_objet); 581: return(NULL); 582: } 583: 584: break; 585: } 586: 587: case REL : 588: { 589: if ((*s_etat_processus).pointeur_rel > 0) 590: { 591: (*s_objet).objet = (*s_etat_processus).objets_rel 592: [--(*s_etat_processus).pointeur_rel]; 593: } 594: else 595: { 596: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL) 597: { 598: free(s_objet); 599: return(NULL); 600: } 601: } 602: 603: break; 604: } 605: 606: case RPN : 607: { 608: (*s_objet).objet = NULL; 609: break; 610: } 611: 612: case SCK : 613: { 614: if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL) 615: { 616: free(s_objet); 617: return(NULL); 618: } 619: 620: break; 621: } 622: 623: case SLB : 624: { 625: if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque))) 626: == NULL) 627: { 628: free(s_objet); 629: return(NULL); 630: } 631: 632: break; 633: } 634: 635: case SPH : 636: { 637: if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL) 638: { 639: free(s_objet); 640: return(NULL); 641: } 642: 643: break; 644: } 645: 646: case SQL : 647: { 648: if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql))) 649: == NULL) 650: { 651: free(s_objet); 652: return(NULL); 653: } 654: 655: break; 656: } 657: 658: case TBL : 659: { 660: if ((*s_etat_processus).pointeur_tab > 0) 661: { 662: (*s_objet).objet = (*s_etat_processus).objets_tab 663: [--(*s_etat_processus).pointeur_tab]; 664: } 665: else 666: { 667: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL) 668: { 669: free(s_objet); 670: return(NULL); 671: } 672: } 673: 674: (*((struct_tableau *) (*s_objet).objet)).nombre_elements = 0; 675: (*((struct_tableau *) (*s_objet).objet)).elements = NULL; 676: break; 677: } 678: 679: case VCX : 680: { 681: if ((*s_etat_processus).pointeur_vec > 0) 682: { 683: (*s_objet).objet = (*s_etat_processus).objets_vec 684: [--(*s_etat_processus).pointeur_vec]; 685: } 686: else 687: { 688: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) 689: { 690: free(s_objet); 691: return(NULL); 692: } 693: } 694: 695: (*((struct_vecteur *) (*s_objet).objet)).type = 'C'; 696: (*((struct_vecteur *) (*s_objet).objet)).taille = 0; 697: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL; 698: break; 699: } 700: 701: case VIN : 702: { 703: if ((*s_etat_processus).pointeur_vec > 0) 704: { 705: (*s_objet).objet = (*s_etat_processus).objets_vec 706: [--(*s_etat_processus).pointeur_vec]; 707: } 708: else 709: { 710: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) 711: { 712: free(s_objet); 713: return(NULL); 714: } 715: } 716: 717: (*((struct_vecteur *) (*s_objet).objet)).type = 'I'; 718: (*((struct_vecteur *) (*s_objet).objet)).taille = 0; 719: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL; 720: break; 721: } 722: 723: case VRL : 724: { 725: if ((*s_etat_processus).pointeur_vec > 0) 726: { 727: (*s_objet).objet = (*s_etat_processus).objets_vec 728: [--(*s_etat_processus).pointeur_vec]; 729: } 730: else 731: { 732: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) 733: { 734: free(s_objet); 735: return(NULL); 736: } 737: } 738: 739: (*((struct_vecteur *) (*s_objet).objet)).type = 'R'; 740: (*((struct_vecteur *) (*s_objet).objet)).taille = 0; 741: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL; 742: break; 743: } 744: 745: default : 746: { 747: free(s_objet); 748: BUG(1, printf("Allocation failure (type %d)\n", type)); 749: 750: return(NULL); 751: } 752: } 753: 754: return(s_objet); 755: } 756: 757: 758: /* 759: ================================================================================ 760: Routine de libération d'une structure *s_objet 761: ================================================================================ 762: Entrées : structure sur l'état du processus et objet à afficher 763: -------------------------------------------------------------------------------- 764: Sorties : chaine de caractères 765: -------------------------------------------------------------------------------- 766: Effets de bord : néant 767: ================================================================================ 768: */ 769: 770: void 771: liberation(struct_processus *s_etat_processus, struct_objet *s_objet) 772: { 773: logical1 drapeau; 774: 775: sigset_t oldset; 776: sigset_t set; 777: 778: struct_liste_chainee *l_element_courant; 779: struct_liste_chainee *l_element_suivant; 780: 781: unsigned long i; 782: 783: if (s_objet == NULL) 784: { 785: return; 786: } 787: 788: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0) 789: { 790: (*s_etat_processus).erreur_systeme = d_es_processus; 791: return; 792: } 793: 794: #define return \ 795: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0) \ 796: { (*s_etat_processus).erreur_systeme = d_es_processus; return; } \ 797: return 798: 799: BUG((*s_objet).nombre_occurrences <= 0, 800: pthread_mutex_unlock(&((*s_objet).mutex)), 801: printf("(*s_objet).nombre_occurrences=%ld\n", 802: (*s_objet).nombre_occurrences)); 803: 804: switch((*s_objet).type) 805: { 806: case ADR : 807: { 808: if (decrementation_atomique(s_objet) > 0) 809: { 810: return; 811: } 812: 813: if ((*s_etat_processus).pointeur_adr < TAILLE_CACHE) 814: { 815: (*s_etat_processus).objets_adr 816: [(*s_etat_processus).pointeur_adr++] = (*s_objet).objet; 817: } 818: else 819: { 820: free((unsigned long *) ((*s_objet).objet)); 821: } 822: 823: break; 824: } 825: 826: case ALG : 827: { 828: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 829: 830: if (decrementation_atomique(s_objet) > 0) 831: { // Il reste un pointeur sur l'objet. 832: while(l_element_courant != NULL) 833: { 834: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1, 835: pthread_mutex_unlock(&((*s_objet).mutex)), 836: printf("(*(*l_element_courant).donnee)" 837: ".nombre_occurrences=%ld\n", 838: (*(*l_element_courant).donnee).nombre_occurrences)); 839: 840: liberation(s_etat_processus, (*l_element_courant).donnee); 841: l_element_courant = (*l_element_courant).suivant; 842: } 843: 844: return; 845: } 846: else 847: { // Il ne reste plus aucun pointeur sur l'objet. 848: while(l_element_courant != NULL) 849: { 850: l_element_suivant = (*l_element_courant).suivant; 851: liberation(s_etat_processus, (*l_element_courant).donnee); 852: liberation_maillon(s_etat_processus, l_element_courant); 853: l_element_courant = l_element_suivant; 854: } 855: } 856: 857: break; 858: } 859: 860: case BIN : 861: { 862: if (decrementation_atomique(s_objet) > 0) 863: { 864: return; 865: } 866: 867: if ((*s_etat_processus).pointeur_bin < TAILLE_CACHE) 868: { 869: (*s_etat_processus).objets_bin 870: [(*s_etat_processus).pointeur_bin++] = (*s_objet).objet; 871: } 872: else 873: { 874: free((logical8 *) ((*s_objet).objet)); 875: } 876: 877: break; 878: } 879: 880: case CHN : 881: { 882: if (decrementation_atomique(s_objet) > 0) 883: { 884: return; 885: } 886: 887: free((unsigned char *) ((*s_objet).objet)); 888: break; 889: } 890: 891: case CPL : 892: { 893: if (decrementation_atomique(s_objet) > 0) 894: { 895: return; 896: } 897: 898: if ((*s_etat_processus).pointeur_cpl < TAILLE_CACHE) 899: { 900: (*s_etat_processus).objets_cpl 901: [(*s_etat_processus).pointeur_cpl++] = (*s_objet).objet; 902: } 903: else 904: { 905: free((struct_complexe16 *) ((*s_objet).objet)); 906: } 907: 908: break; 909: } 910: 911: case FCH : 912: { 913: if (decrementation_atomique(s_objet) > 0) 914: { 915: BUG((*(*((struct_fichier *) (*s_objet).objet)).format) 916: .nombre_occurrences <= 1, 917: pthread_mutex_unlock(&((*s_objet).mutex)), 918: printf("(*(*((struct_fichier *) (*s_objet).objet))" 919: ".format).nombre_occurrences=%ld\n", 920: (*(*((struct_fichier *) (*s_objet).objet)).format) 921: .nombre_occurrences)); 922: 923: liberation(s_etat_processus, 924: (*((struct_fichier *) (*s_objet).objet)).format); 925: return; 926: } 927: 928: liberation(s_etat_processus, 929: (*((struct_fichier *) (*s_objet).objet)).format); 930: free((unsigned char *) (*((struct_fichier *) 931: (*s_objet).objet)).nom); 932: free((struct_fichier *) ((*s_objet).objet)); 933: break; 934: } 935: 936: case FCT : 937: { 938: if (decrementation_atomique(s_objet) > 0) 939: { 940: return; 941: } 942: 943: free((unsigned char *) (*((struct_fonction *) 944: (*s_objet).objet)).nom_fonction); 945: 946: if ((*s_etat_processus).pointeur_fct < TAILLE_CACHE) 947: { 948: (*s_etat_processus).objets_fct 949: [(*s_etat_processus).pointeur_fct++] = (*s_objet).objet; 950: } 951: else 952: { 953: free((struct_fonction *) (*s_objet).objet); 954: } 955: 956: break; 957: } 958: 959: case INT : 960: { 961: if (decrementation_atomique(s_objet) > 0) 962: { 963: return; 964: } 965: 966: if ((*s_etat_processus).pointeur_int < TAILLE_CACHE) 967: { 968: (*s_etat_processus).objets_int 969: [(*s_etat_processus).pointeur_int++] = (*s_objet).objet; 970: } 971: else 972: { 973: free((integer8 *) ((*s_objet).objet)); 974: } 975: 976: break; 977: } 978: 979: case LST : 980: { 981: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 982: 983: if (decrementation_atomique(s_objet) > 0) 984: { // Il reste un pointeur sur l'objet. 985: while(l_element_courant != NULL) 986: { 987: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1, 988: pthread_mutex_unlock(&((*s_objet).mutex)), 989: printf("(*(*l_element_courant).donnee)" 990: ".nombre_occurrences=%ld\n", 991: (*(*l_element_courant).donnee).nombre_occurrences)); 992: 993: liberation(s_etat_processus, (*l_element_courant).donnee); 994: l_element_courant = (*l_element_courant).suivant; 995: } 996: 997: return; 998: } 999: else 1000: { // Il ne reste plus aucun pointeur sur l'objet. 1001: while(l_element_courant != NULL) 1002: { 1003: l_element_suivant = (*l_element_courant).suivant; 1004: liberation(s_etat_processus, (*l_element_courant).donnee); 1005: liberation_maillon(s_etat_processus, l_element_courant); 1006: l_element_courant = l_element_suivant; 1007: } 1008: } 1009: 1010: break; 1011: } 1012: 1013: case MIN : 1014: { 1015: if (decrementation_atomique(s_objet) > 0) 1016: { 1017: return; 1018: } 1019: 1020: for(i = 0; i < (*((struct_matrice *) 1021: ((*s_objet).objet))).nombre_lignes; i++) 1022: { 1023: free(((integer8 **) (*((struct_matrice *) 1024: (*s_objet).objet)).tableau)[i]); 1025: } 1026: 1027: free((integer8 **) (*((struct_matrice *) 1028: (*s_objet).objet)).tableau); 1029: 1030: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE) 1031: { 1032: (*s_etat_processus).objets_mat 1033: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet; 1034: } 1035: else 1036: { 1037: free((struct_matrice *) (*s_objet).objet); 1038: } 1039: 1040: break; 1041: } 1042: 1043: case MCX : 1044: { 1045: if (decrementation_atomique(s_objet) > 0) 1046: { 1047: return; 1048: } 1049: 1050: for(i = 0; i < (*((struct_matrice *) 1051: ((*s_objet).objet))).nombre_lignes; i++) 1052: { 1053: free(((struct_complexe16 **) (*((struct_matrice *) 1054: (*s_objet).objet)).tableau)[i]); 1055: } 1056: 1057: free((struct_complexe16 **) (*((struct_matrice *) 1058: (*s_objet).objet)).tableau); 1059: 1060: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE) 1061: { 1062: (*s_etat_processus).objets_mat 1063: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet; 1064: } 1065: else 1066: { 1067: free((struct_matrice *) (*s_objet).objet); 1068: } 1069: 1070: break; 1071: } 1072: 1073: case MRL : 1074: { 1075: if (decrementation_atomique(s_objet) > 0) 1076: { 1077: return; 1078: } 1079: 1080: for(i = 0; i < (*((struct_matrice *) 1081: ((*s_objet).objet))).nombre_lignes; i++) 1082: { 1083: free(((real8 **) (*((struct_matrice *) 1084: (*s_objet).objet)).tableau)[i]); 1085: } 1086: 1087: free((real8 **) (*((struct_matrice *) (*s_objet).objet)).tableau); 1088: 1089: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE) 1090: { 1091: (*s_etat_processus).objets_mat 1092: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet; 1093: } 1094: else 1095: { 1096: free((struct_matrice *) (*s_objet).objet); 1097: } 1098: 1099: break; 1100: } 1101: 1102: case MTX : 1103: { 1104: if (decrementation_atomique(s_objet) > 0) 1105: { 1106: return; 1107: } 1108: 1109: free((struct_mutex *) (*s_objet).objet); 1110: break; 1111: } 1112: 1113: case NOM : 1114: { 1115: if (decrementation_atomique(s_objet) > 0) 1116: { 1117: return; 1118: } 1119: 1120: free((*((struct_nom *) (*s_objet).objet)).nom); 1121: 1122: if ((*s_etat_processus).pointeur_nom < TAILLE_CACHE) 1123: { 1124: (*s_etat_processus).objets_nom 1125: [(*s_etat_processus).pointeur_nom++] = (*s_objet).objet; 1126: } 1127: else 1128: { 1129: free((struct_nom *) (*s_objet).objet); 1130: } 1131: 1132: break; 1133: } 1134: 1135: case NON : 1136: { 1137: if (decrementation_atomique(s_objet) > 0) 1138: { 1139: return; 1140: } 1141: 1142: break; 1143: } 1144: 1145: case PRC : 1146: { 1147: sigfillset(&set); 1148: pthread_sigmask(SIG_BLOCK, &set, &oldset); 1149: 1150: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 1151: (*s_objet).objet)).thread).mutex_nombre_references)) != 0) 1152: { 1153: pthread_sigmask(SIG_SETMASK, &oldset, NULL); 1154: sigpending(&set); 1155: 1156: (*s_etat_processus).erreur_systeme = d_es_processus; 1157: return; 1158: } 1159: 1160: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1161: .nombre_references--; 1162: 1163: BUG((*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1164: .nombre_references < 0, uprintf( 1165: "(*(*((struct_processus_fils" 1166: " *) (*s_objet).objet)).thread).nombre_references = %d\n", 1167: (int) (*(*((struct_processus_fils *) (*s_objet).objet)) 1168: .thread).nombre_references)); 1169: 1170: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1171: .nombre_references == 0) 1172: { 1173: drapeau = d_vrai; 1174: } 1175: else 1176: { 1177: drapeau = d_faux; 1178: } 1179: 1180: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 1181: (*s_objet).objet)).thread).mutex_nombre_references)) != 0) 1182: { 1183: pthread_sigmask(SIG_SETMASK, &oldset, NULL); 1184: sigpending(&set); 1185: 1186: (*s_etat_processus).erreur_systeme = d_es_processus; 1187: return; 1188: } 1189: 1190: pthread_sigmask(SIG_SETMASK, &oldset, NULL); 1191: sigpending(&set); 1192: 1193: if (drapeau == d_vrai) 1194: { 1195: pthread_mutex_destroy(&((*(*((struct_processus_fils *) 1196: (*s_objet).objet)).thread).mutex)); 1197: pthread_mutex_destroy(&((*(*((struct_processus_fils *) 1198: (*s_objet).objet)).thread).mutex_nombre_references)); 1199: free((*((struct_processus_fils *) (*s_objet).objet)).thread); 1200: } 1201: 1202: if (decrementation_atomique(s_objet) > 0) 1203: { 1204: BUG(drapeau == d_vrai, uprintf("(*(*((struct_processus_fils" 1205: " *) (*s_objet).objet)).thread).nombre_references " 1206: "= 0 with nombre_occurrences > 0\n")); 1207: return; 1208: } 1209: 1210: free((struct_processus_fils *) ((*s_objet).objet)); 1211: break; 1212: } 1213: 1214: case REL : 1215: { 1216: if (decrementation_atomique(s_objet) > 0) 1217: { 1218: return; 1219: } 1220: 1221: if ((*s_etat_processus).pointeur_rel < TAILLE_CACHE) 1222: { 1223: (*s_etat_processus).objets_rel 1224: [(*s_etat_processus).pointeur_rel++] = (*s_objet).objet; 1225: } 1226: else 1227: { 1228: free((real8 *) ((*s_objet).objet)); 1229: } 1230: 1231: break; 1232: } 1233: 1234: case RPN : 1235: { 1236: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 1237: 1238: if (decrementation_atomique(s_objet) > 0) 1239: { // Il reste un pointeur sur l'objet. 1240: while(l_element_courant != NULL) 1241: { 1242: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1, 1243: pthread_mutex_unlock(&((*s_objet).mutex)), 1244: printf("(*(*l_element_courant).donnee)" 1245: ".nombre_occurrences=%ld\n", 1246: (*(*l_element_courant).donnee).nombre_occurrences)); 1247: 1248: liberation(s_etat_processus, (*l_element_courant).donnee); 1249: l_element_courant = (*l_element_courant).suivant; 1250: } 1251: 1252: return; 1253: } 1254: else 1255: { // Il ne reste plus aucun pointeur sur l'objet. 1256: while(l_element_courant != NULL) 1257: { 1258: l_element_suivant = (*l_element_courant).suivant; 1259: liberation(s_etat_processus, (*l_element_courant).donnee); 1260: liberation_maillon(s_etat_processus, l_element_courant); 1261: l_element_courant = l_element_suivant; 1262: } 1263: } 1264: 1265: break; 1266: } 1267: 1268: case SCK : 1269: { 1270: if (decrementation_atomique(s_objet) > 0) 1271: { 1272: BUG((*(*((struct_socket *) (*s_objet).objet)).format) 1273: .nombre_occurrences <= 1, 1274: pthread_mutex_unlock(&((*s_objet).mutex)), 1275: printf("(*(*((struct_socket *) (*s_objet).objet))" 1276: ".format).nombre_occurrences=%ld\n", 1277: (*(*((struct_socket *) (*s_objet).objet)).format) 1278: .nombre_occurrences)); 1279: 1280: liberation(s_etat_processus, (*((struct_socket *) 1281: (*s_objet).objet)).format); 1282: return; 1283: } 1284: 1285: liberation(s_etat_processus, (*((struct_socket *) 1286: (*s_objet).objet)).format); 1287: 1288: free((unsigned char *) (*((struct_socket *) (*s_objet).objet)) 1289: .adresse); 1290: free((unsigned char *) (*((struct_socket *) (*s_objet).objet)) 1291: .adresse_distante); 1292: free((struct_socket *) ((*s_objet).objet)); 1293: break; 1294: } 1295: 1296: case SLB : 1297: { 1298: if (decrementation_atomique(s_objet) > 0) 1299: { 1300: return; 1301: } 1302: 1303: free((*((struct_bibliotheque *) (*s_objet).objet)).nom); 1304: free((struct_bibliotheque *) (*s_objet).objet); 1305: break; 1306: } 1307: 1308: case SPH : 1309: { 1310: if (decrementation_atomique(s_objet) > 0) 1311: { 1312: return; 1313: } 1314: 1315: free((*((struct_semaphore *) (*s_objet).objet)).nom); 1316: free((struct_bibliotheque *) (*s_objet).objet); 1317: break; 1318: } 1319: 1320: case SQL : 1321: { 1322: if (decrementation_atomique(s_objet) > 0) 1323: { 1324: return; 1325: } 1326: 1327: free((*((struct_connecteur_sql *) (*s_objet).objet)).type); 1328: free((*((struct_connecteur_sql *) (*s_objet).objet)).locale); 1329: free((struct_connecteur_sql *) (*s_objet).objet); 1330: break; 1331: } 1332: 1333: case TBL : 1334: { 1335: if (decrementation_atomique(s_objet) > 0) 1336: { 1337: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 1338: .nombre_elements; i++) 1339: { 1340: BUG((*((*((struct_tableau *) 1341: (*s_objet).objet)).elements[i])) 1342: .nombre_occurrences <= 1, 1343: pthread_mutex_unlock(&((*s_objet).mutex)), 1344: printf("(*((*((struct_tableau *) (*s_objet).objet))" 1345: ".element[%lu])).nombre_occurrences=%ld\n", i, 1346: (*((*((struct_tableau *) (*s_objet).objet)) 1347: .elements[i])).nombre_occurrences)); 1348: liberation(s_etat_processus, (*((struct_tableau *) 1349: (*s_objet).objet)).elements[i]); 1350: } 1351: 1352: return; 1353: } 1354: 1355: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 1356: .nombre_elements; i++) 1357: { 1358: liberation(s_etat_processus, (*((struct_tableau *) 1359: (*s_objet).objet)).elements[i]); 1360: } 1361: 1362: free((*((struct_tableau *) (*s_objet).objet)).elements); 1363: 1364: if ((*s_etat_processus).pointeur_tab < TAILLE_CACHE) 1365: { 1366: (*s_etat_processus).objets_tab 1367: [(*s_etat_processus).pointeur_tab++] = (*s_objet).objet; 1368: } 1369: else 1370: { 1371: free((struct_tableau *) (*s_objet).objet); 1372: } 1373: 1374: break; 1375: } 1376: 1377: case VIN : 1378: { 1379: if (decrementation_atomique(s_objet) > 0) 1380: { 1381: return; 1382: } 1383: 1384: free((integer8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau); 1385: 1386: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE) 1387: { 1388: (*s_etat_processus).objets_vec 1389: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet; 1390: } 1391: else 1392: { 1393: free((struct_vecteur *) (*s_objet).objet); 1394: } 1395: 1396: break; 1397: } 1398: 1399: case VCX : 1400: { 1401: if (decrementation_atomique(s_objet) > 0) 1402: { 1403: return; 1404: } 1405: 1406: free((struct_complexe16 *) (*((struct_vecteur *) 1407: (*s_objet).objet)).tableau); 1408: 1409: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE) 1410: { 1411: (*s_etat_processus).objets_vec 1412: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet; 1413: } 1414: else 1415: { 1416: free((struct_vecteur *) (*s_objet).objet); 1417: } 1418: 1419: break; 1420: } 1421: 1422: case VRL : 1423: { 1424: if (decrementation_atomique(s_objet) > 0) 1425: { 1426: return; 1427: } 1428: 1429: free((real8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau); 1430: 1431: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE) 1432: { 1433: (*s_etat_processus).objets_vec 1434: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet; 1435: } 1436: else 1437: { 1438: free((struct_vecteur *) (*s_objet).objet); 1439: } 1440: 1441: break; 1442: } 1443: 1444: default : 1445: { 1446: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0) 1447: { 1448: (*s_etat_processus).erreur_systeme = d_es_processus; 1449: return; 1450: } 1451: 1452: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0) 1453: { 1454: (*s_etat_processus).erreur_systeme = d_es_processus; 1455: return; 1456: } 1457: 1458: BUG(1, printf("Free failure (type %d)\n", (*s_objet).type)); 1459: return; 1460: } 1461: } 1462: 1463: #undef return 1464: 1465: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0) 1466: { 1467: (*s_etat_processus).erreur_systeme = d_es_processus; 1468: return; 1469: } 1470: 1471: if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0) 1472: { 1473: (*s_etat_processus).erreur_systeme = d_es_processus; 1474: return; 1475: } 1476: 1477: if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE) 1478: { 1479: (*s_objet).objet = (*s_etat_processus).pile_objets; 1480: (*s_etat_processus).pile_objets = s_objet; 1481: (*s_etat_processus).taille_pile_objets++; 1482: } 1483: else 1484: { 1485: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0) 1486: { 1487: pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)); 1488: (*s_etat_processus).erreur_systeme = d_es_processus; 1489: return; 1490: } 1491: 1492: free(s_objet); 1493: } 1494: 1495: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0) 1496: { 1497: (*s_etat_processus).erreur_systeme = d_es_processus; 1498: return; 1499: } 1500: 1501: return; 1502: } 1503: 1504: 1505: /* 1506: ================================================================================ 1507: Routine de copie d'une structure *s_objet 1508: ================================================================================ 1509: Entrées : structure *s_objet à copier 1510: type : 1511: 'P' : renvoie le même objet en incrémentant le nombre 1512: d'occurrence de chaque objet élémentaire ; 1513: 'O' : crée un nouvel objet en copiant chaque objet élémentaire ; 1514: 'N' : crée un nouvel objet mais les objets élémentaires 1515: sont réutilisés (voir 'P'). Dans le cas d'un objet 1516: élémentaire, 'N' et 'P' sont identiques. 1517: 'Q' : 'P' si nombre_occurrences vaut 1, 'O' sinon. 1518: 'R' : 'P' si nombre_occurrences vaut 1, 'N' sinon. 1519: -------------------------------------------------------------------------------- 1520: Sorties : structure identique (tous les objets sont copiés) 1521: -------------------------------------------------------------------------------- 1522: Effets de bord : néant 1523: ================================================================================ 1524: */ 1525: 1526: struct_objet * 1527: copie_objet(struct_processus *s_etat_processus, 1528: struct_objet *s_objet, unsigned char type) 1529: { 1530: sigset_t oldset; 1531: sigset_t set; 1532: 1533: struct_liste_chainee *l_element_base; 1534: struct_liste_chainee *l_element_courant; 1535: struct_liste_chainee *l_element_courant_ecriture; 1536: struct_liste_chainee *l_element_courant_lecture; 1537: struct_liste_chainee *l_element_suivant_ecriture; 1538: struct_liste_chainee *l_element_suivant_lecture; 1539: 1540: struct_objet *s_nouvel_objet; 1541: struct_objet *s_objet_tampon; 1542: 1543: unsigned long i; 1544: unsigned long j; 1545: 1546: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0) 1547: { 1548: (*s_etat_processus).erreur_systeme = d_es_processus; 1549: return(NULL); 1550: } 1551: 1552: if (type == 'Q') 1553: { 1554: if ((*s_objet).nombre_occurrences == 1) 1555: { 1556: type = 'P'; 1557: } 1558: else 1559: { 1560: type = 'O'; 1561: } 1562: } 1563: else if (type == 'R') 1564: { 1565: if ((*s_objet).nombre_occurrences == 1) 1566: { 1567: type = 'P'; 1568: } 1569: else 1570: { 1571: type = 'N'; 1572: } 1573: } 1574: 1575: #define return(pointeur) \ 1576: if (pthread_mutex_unlock(&((*s_objet).mutex))) \ 1577: { (*s_etat_processus).erreur_systeme = d_es_processus; return(NULL); } \ 1578: return(pointeur) 1579: 1580: switch((*s_objet).type) 1581: { 1582: case ADR : 1583: { 1584: if (type != 'O') 1585: { 1586: incrementation_atomique(s_objet); 1587: return(s_objet); 1588: } 1589: 1590: if ((s_nouvel_objet = allocation(s_etat_processus, ADR)) == NULL) 1591: { 1592: return(NULL); 1593: } 1594: 1595: (*((unsigned long *) ((*s_nouvel_objet).objet))) = 1596: (*((unsigned long *) ((*s_objet).objet))); 1597: break; 1598: } 1599: 1600: case ALG : 1601: { 1602: if (type != 'P') 1603: { 1604: if ((s_nouvel_objet = allocation(s_etat_processus, ALG)) 1605: == NULL) 1606: { 1607: return(NULL); 1608: } 1609: 1610: l_element_courant_lecture = (struct_liste_chainee *) 1611: ((*s_objet).objet); 1612: 1613: l_element_base = NULL; 1614: l_element_courant_ecriture = l_element_base; 1615: 1616: while(l_element_courant_lecture != NULL) 1617: { 1618: s_objet_tampon = copie_objet(s_etat_processus, 1619: (*l_element_courant_lecture).donnee, type); 1620: l_element_suivant_ecriture = (struct_liste_chainee *) 1621: malloc(sizeof(struct_liste_chainee)); 1622: 1623: if ((s_objet_tampon == NULL) || 1624: (l_element_suivant_ecriture == NULL)) 1625: { 1626: l_element_courant_lecture = (struct_liste_chainee *) 1627: ((*s_nouvel_objet).objet); 1628: 1629: while(l_element_courant_lecture != NULL) 1630: { 1631: l_element_suivant_lecture = 1632: (*l_element_courant_lecture).suivant; 1633: liberation(s_etat_processus, 1634: (*l_element_courant_lecture).donnee); 1635: free(l_element_courant_lecture); 1636: l_element_courant_lecture = 1637: l_element_suivant_lecture; 1638: } 1639: 1640: return(NULL); 1641: } 1642: 1643: if (l_element_courant_ecriture == NULL) 1644: { 1645: l_element_base = l_element_suivant_ecriture; 1646: } 1647: else 1648: { 1649: (*l_element_courant_ecriture).suivant = 1650: l_element_suivant_ecriture; 1651: } 1652: 1653: l_element_courant_ecriture = l_element_suivant_ecriture; 1654: 1655: (*l_element_courant_ecriture).donnee = s_objet_tampon; 1656: (*l_element_courant_ecriture).suivant = NULL; 1657: l_element_courant_lecture = 1658: (*l_element_courant_lecture).suivant; 1659: } 1660: 1661: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *) 1662: l_element_base); 1663: } 1664: else // type == 'P' 1665: { 1666: incrementation_atomique(s_objet); 1667: l_element_courant = (*s_objet).objet; 1668: 1669: while(l_element_courant != NULL) 1670: { 1671: (*l_element_courant).donnee = copie_objet(s_etat_processus, 1672: (*l_element_courant).donnee, 'P'); 1673: l_element_courant = (*l_element_courant).suivant; 1674: } 1675: 1676: return(s_objet); 1677: } 1678: 1679: break; 1680: } 1681: 1682: case BIN : 1683: { 1684: if (type != 'O') 1685: { 1686: incrementation_atomique(s_objet); 1687: return(s_objet); 1688: } 1689: 1690: if ((s_nouvel_objet = allocation(s_etat_processus, BIN)) == NULL) 1691: { 1692: return(NULL); 1693: } 1694: 1695: (*((logical8 *) ((*s_nouvel_objet).objet))) = 1696: (*((logical8 *) ((*s_objet).objet))); 1697: break; 1698: } 1699: 1700: case CHN : 1701: { 1702: if (type != 'O') 1703: { 1704: incrementation_atomique(s_objet); 1705: return(s_objet); 1706: } 1707: 1708: if ((s_nouvel_objet = allocation(s_etat_processus, CHN)) == NULL) 1709: { 1710: return(NULL); 1711: } 1712: 1713: (*s_nouvel_objet).objet = (void *) ((unsigned char *) 1714: malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1) 1715: * sizeof(unsigned char))); 1716: 1717: if ((*s_nouvel_objet).objet == NULL) 1718: { 1719: free(s_nouvel_objet); 1720: return(NULL); 1721: } 1722: 1723: strcpy((unsigned char *) ((*s_nouvel_objet).objet), 1724: (unsigned char *) ((*s_objet).objet)); 1725: break; 1726: } 1727: 1728: case CPL : 1729: { 1730: if (type != 'O') 1731: { 1732: incrementation_atomique(s_objet); 1733: return(s_objet); 1734: } 1735: 1736: if ((s_nouvel_objet = allocation(s_etat_processus, CPL)) == NULL) 1737: { 1738: return(NULL); 1739: } 1740: 1741: (*((struct_complexe16 *) ((*s_nouvel_objet).objet))) = 1742: (*((struct_complexe16 *) ((*s_objet).objet))); 1743: break; 1744: } 1745: 1746: case RPN : 1747: { 1748: if (type != 'P') 1749: { 1750: if ((s_nouvel_objet = allocation(s_etat_processus, RPN)) 1751: == NULL) 1752: { 1753: return(NULL); 1754: } 1755: 1756: l_element_courant_lecture = (struct_liste_chainee *) 1757: ((*s_objet).objet); 1758: 1759: l_element_base = NULL; 1760: l_element_courant_ecriture = l_element_base; 1761: 1762: while(l_element_courant_lecture != NULL) 1763: { 1764: s_objet_tampon = copie_objet(s_etat_processus, 1765: (*l_element_courant_lecture).donnee, type); 1766: l_element_suivant_ecriture = (struct_liste_chainee *) 1767: malloc(sizeof(struct_liste_chainee)); 1768: 1769: if ((s_objet_tampon == NULL) || 1770: (l_element_suivant_ecriture == NULL)) 1771: { 1772: l_element_courant_lecture = (struct_liste_chainee *) 1773: ((*s_nouvel_objet).objet); 1774: 1775: while(l_element_courant_lecture != NULL) 1776: { 1777: l_element_suivant_lecture = 1778: (*l_element_courant_lecture).suivant; 1779: liberation(s_etat_processus, 1780: (*l_element_courant_lecture).donnee); 1781: free(l_element_courant_lecture); 1782: l_element_courant_lecture = 1783: l_element_suivant_lecture; 1784: } 1785: 1786: return(NULL); 1787: } 1788: 1789: if (l_element_courant_ecriture == NULL) 1790: { 1791: l_element_base = l_element_suivant_ecriture; 1792: } 1793: else 1794: { 1795: (*l_element_courant_ecriture).suivant = 1796: l_element_suivant_ecriture; 1797: } 1798: 1799: l_element_courant_ecriture = l_element_suivant_ecriture; 1800: 1801: (*l_element_courant_ecriture).donnee = s_objet_tampon; 1802: (*l_element_courant_ecriture).suivant = NULL; 1803: l_element_courant_lecture = 1804: (*l_element_courant_lecture).suivant; 1805: } 1806: 1807: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *) 1808: l_element_base); 1809: } 1810: else // type == 'P' 1811: { 1812: incrementation_atomique(s_objet); 1813: l_element_courant = (*s_objet).objet; 1814: 1815: while(l_element_courant != NULL) 1816: { 1817: (*l_element_courant).donnee = copie_objet(s_etat_processus, 1818: (*l_element_courant).donnee, 'P'); 1819: l_element_courant = (*l_element_courant).suivant; 1820: } 1821: 1822: return(s_objet); 1823: } 1824: 1825: break; 1826: } 1827: 1828: case FCH : 1829: { 1830: if (type == 'P') 1831: { 1832: incrementation_atomique(s_objet); 1833: 1834: if (((*((struct_fichier *) ((*s_objet).objet))).format = 1835: copie_objet(s_etat_processus, (*((struct_fichier *) 1836: ((*s_objet).objet))).format, 'P')) == NULL) 1837: { 1838: return(NULL); 1839: } 1840: 1841: return(s_objet); 1842: } 1843: 1844: if ((s_nouvel_objet = allocation(s_etat_processus, FCH)) == NULL) 1845: { 1846: return(NULL); 1847: } 1848: 1849: (*((struct_fichier *) ((*s_nouvel_objet).objet))).descripteur = 1850: (*((struct_fichier *) ((*s_objet).objet))).descripteur; 1851: (*((struct_fichier *) ((*s_nouvel_objet).objet))).acces = 1852: (*((struct_fichier *) ((*s_objet).objet))).acces; 1853: (*((struct_fichier *) ((*s_nouvel_objet).objet))).binaire = 1854: (*((struct_fichier *) ((*s_objet).objet))).binaire; 1855: (*((struct_fichier *) ((*s_nouvel_objet).objet))).ouverture = 1856: (*((struct_fichier *) ((*s_objet).objet))).ouverture; 1857: (*((struct_fichier *) ((*s_nouvel_objet).objet))).protection = 1858: (*((struct_fichier *) ((*s_objet).objet))).protection; 1859: (*((struct_fichier *) ((*s_nouvel_objet).objet))) 1860: .position_clef = (*((struct_fichier *) 1861: ((*s_objet).objet))).position_clef; 1862: (*((struct_fichier *) ((*s_nouvel_objet).objet))).pid = 1863: (*((struct_fichier *) ((*s_objet).objet))).pid; 1864: (*((struct_fichier *) ((*s_nouvel_objet).objet))).tid = 1865: (*((struct_fichier *) ((*s_objet).objet))).tid; 1866: 1867: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).format = 1868: copie_objet(s_etat_processus, (*((struct_fichier *) 1869: ((*s_objet).objet))).format, type)) == NULL) 1870: { 1871: free((*s_nouvel_objet).objet); 1872: free(s_nouvel_objet); 1873: return(NULL); 1874: } 1875: 1876: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom = 1877: (unsigned char *) malloc((strlen((*((struct_fichier *) 1878: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char))) 1879: == NULL) 1880: { 1881: liberation(s_etat_processus, (*((struct_fichier *) 1882: (*s_nouvel_objet).objet)).format); 1883: free((*s_nouvel_objet).objet); 1884: free(s_nouvel_objet); 1885: return(NULL); 1886: } 1887: 1888: strcpy((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom, 1889: (*((struct_fichier *) ((*s_objet).objet))).nom); 1890: break; 1891: } 1892: 1893: case FCT : 1894: { 1895: if (type != 'O') 1896: { 1897: /* 1898: * Remise à zéro de la prédiction pour respecter la cohérence 1899: * du saut dans les cas EXSUB et OBSUB. 1900: */ 1901: 1902: (*((struct_fonction *) ((*s_objet).objet))) 1903: .prediction_saut = NULL; 1904: incrementation_atomique(s_objet); 1905: return(s_objet); 1906: } 1907: 1908: if ((s_nouvel_objet = allocation(s_etat_processus, FCT)) == NULL) 1909: { 1910: return(NULL); 1911: } 1912: 1913: if (((*((struct_fonction *) ((*s_nouvel_objet).objet))) 1914: .nom_fonction = (unsigned char *) 1915: malloc((strlen((*((struct_fonction *) 1916: ((*s_objet).objet))).nom_fonction) + 1) * 1917: sizeof(unsigned char))) == NULL) 1918: { 1919: free(s_nouvel_objet); 1920: return(NULL); 1921: } 1922: 1923: strcpy((unsigned char *) (*((struct_fonction *) 1924: ((*s_nouvel_objet).objet))).nom_fonction, 1925: (unsigned char *) (*((struct_fonction *) 1926: ((*s_objet).objet))).nom_fonction); 1927: (*((struct_fonction *) ((*s_nouvel_objet).objet))) 1928: .nombre_arguments = (*((struct_fonction *) 1929: ((*s_objet).objet))).nombre_arguments; 1930: (*((struct_fonction *) ((*s_nouvel_objet).objet))).fonction = 1931: (*((struct_fonction *) ((*s_objet).objet))).fonction; 1932: break; 1933: } 1934: 1935: case INT : 1936: { 1937: if (type != 'O') 1938: { 1939: incrementation_atomique(s_objet); 1940: return(s_objet); 1941: } 1942: 1943: if ((s_nouvel_objet = allocation(s_etat_processus, INT)) == NULL) 1944: { 1945: return(NULL); 1946: } 1947: 1948: (*((integer8 *) ((*s_nouvel_objet).objet))) = 1949: (*((integer8 *) ((*s_objet).objet))); 1950: break; 1951: } 1952: 1953: case LST : 1954: { 1955: if (type != 'P') 1956: { 1957: if ((s_nouvel_objet = allocation(s_etat_processus, LST)) 1958: == NULL) 1959: { 1960: return(NULL); 1961: } 1962: 1963: l_element_courant_lecture = (struct_liste_chainee *) 1964: ((*s_objet).objet); 1965: 1966: l_element_base = NULL; 1967: l_element_courant_ecriture = l_element_base; 1968: 1969: while(l_element_courant_lecture != NULL) 1970: { 1971: s_objet_tampon = copie_objet(s_etat_processus, 1972: (*l_element_courant_lecture).donnee, type); 1973: l_element_suivant_ecriture = (struct_liste_chainee *) 1974: malloc(sizeof(struct_liste_chainee)); 1975: 1976: if ((s_objet_tampon == NULL) || 1977: (l_element_suivant_ecriture == NULL)) 1978: { 1979: l_element_courant_lecture = (struct_liste_chainee *) 1980: ((*s_nouvel_objet).objet); 1981: 1982: while(l_element_courant_lecture != NULL) 1983: { 1984: l_element_suivant_lecture = 1985: (*l_element_courant_lecture).suivant; 1986: liberation(s_etat_processus, 1987: (*l_element_courant_lecture).donnee); 1988: free(l_element_courant_lecture); 1989: l_element_courant_lecture = 1990: l_element_suivant_lecture; 1991: } 1992: 1993: return(NULL); 1994: } 1995: 1996: if (l_element_courant_ecriture == NULL) 1997: { 1998: l_element_base = l_element_suivant_ecriture; 1999: } 2000: else 2001: { 2002: (*l_element_courant_ecriture).suivant = 2003: l_element_suivant_ecriture; 2004: } 2005: 2006: l_element_courant_ecriture = l_element_suivant_ecriture; 2007: 2008: (*l_element_courant_ecriture).donnee = s_objet_tampon; 2009: (*l_element_courant_ecriture).suivant = NULL; 2010: l_element_courant_lecture = 2011: (*l_element_courant_lecture).suivant; 2012: } 2013: 2014: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *) 2015: l_element_base); 2016: } 2017: else 2018: { 2019: incrementation_atomique(s_objet); 2020: l_element_courant = (*s_objet).objet; 2021: 2022: while(l_element_courant != NULL) 2023: { 2024: (*l_element_courant).donnee = copie_objet(s_etat_processus, 2025: (*l_element_courant).donnee, 'P'); 2026: l_element_courant = (*l_element_courant).suivant; 2027: } 2028: 2029: return(s_objet); 2030: } 2031: 2032: break; 2033: } 2034: 2035: case MIN : 2036: { 2037: if (type != 'O') 2038: { 2039: incrementation_atomique(s_objet); 2040: return(s_objet); 2041: } 2042: 2043: if ((s_nouvel_objet = allocation(s_etat_processus, MIN)) == NULL) 2044: { 2045: return(NULL); 2046: } 2047: 2048: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = 2049: (void **) ((integer8 **) malloc( 2050: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes) 2051: * sizeof(integer8 *))); 2052: 2053: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau 2054: == NULL) 2055: { 2056: free((*s_nouvel_objet).objet); 2057: free(s_nouvel_objet); 2058: return(NULL); 2059: } 2060: 2061: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes = 2062: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes; 2063: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes = 2064: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes; 2065: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type = 2066: (*((struct_matrice *) ((*s_objet).objet))).type; 2067: 2068: for(i = 0; i < (*((struct_matrice *) 2069: ((*s_objet).objet))).nombre_lignes; i++) 2070: { 2071: if ((((integer8 **) ((*((struct_matrice *) 2072: ((*s_nouvel_objet).objet))).tableau))[i] = 2073: (void *) ((integer8 *) malloc( 2074: ((*((struct_matrice *) ((*s_objet).objet))) 2075: .nombre_colonnes) * sizeof(integer8)))) == NULL) 2076: { 2077: for(j = 0; j < i; j++) 2078: { 2079: free(((integer8 **) ((*((struct_matrice *) 2080: ((*s_nouvel_objet).objet))).tableau))[j]); 2081: } 2082: 2083: free((*s_nouvel_objet).objet); 2084: free(s_nouvel_objet); 2085: return(NULL); 2086: } 2087: 2088: for(j = 0; j < (*((struct_matrice *) 2089: ((*s_objet).objet))).nombre_colonnes; j++) 2090: { 2091: ((integer8 **) ((*((struct_matrice *) 2092: ((*s_nouvel_objet).objet))).tableau))[i][j] = 2093: ((integer8 **) ((*((struct_matrice *) 2094: ((*s_objet).objet))).tableau))[i][j]; 2095: } 2096: } 2097: 2098: break; 2099: } 2100: 2101: case MCX : 2102: { 2103: if (type != 'O') 2104: { 2105: incrementation_atomique(s_objet); 2106: return(s_objet); 2107: } 2108: 2109: if ((s_nouvel_objet = allocation(s_etat_processus, MCX)) 2110: == NULL) 2111: { 2112: return(NULL); 2113: } 2114: 2115: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = 2116: (void **) ((struct_complexe16 **) malloc( 2117: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes) 2118: * sizeof(struct_complexe16 *))); 2119: 2120: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau 2121: == NULL) 2122: { 2123: free((*s_nouvel_objet).objet); 2124: free(s_nouvel_objet); 2125: return(NULL); 2126: } 2127: 2128: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes = 2129: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes; 2130: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes = 2131: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes; 2132: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type = 2133: (*((struct_matrice *) ((*s_objet).objet))).type; 2134: 2135: for(i = 0; i < (*((struct_matrice *) 2136: ((*s_objet).objet))).nombre_lignes; i++) 2137: { 2138: if ((((struct_complexe16 **) ((*((struct_matrice *) 2139: ((*s_nouvel_objet).objet))).tableau))[i] = 2140: (void *) ((struct_complexe16 *) malloc( 2141: ((*((struct_matrice *) ((*s_objet).objet))) 2142: .nombre_colonnes) * sizeof(struct_complexe16)))) 2143: == NULL) 2144: { 2145: for(j = 0; j < i; j++) 2146: { 2147: free(((struct_complexe16 **) ((*((struct_matrice *) 2148: ((*s_nouvel_objet).objet))).tableau))[j]); 2149: } 2150: 2151: free((*s_nouvel_objet).objet); 2152: free(s_nouvel_objet); 2153: return(NULL); 2154: } 2155: 2156: for(j = 0; j < (*((struct_matrice *) 2157: ((*s_objet).objet))).nombre_colonnes; j++) 2158: { 2159: ((struct_complexe16 **) ((*((struct_matrice *) 2160: ((*s_nouvel_objet).objet))).tableau))[i][j] = 2161: ((struct_complexe16 **) ((*((struct_matrice *) 2162: ((*s_objet).objet))).tableau))[i][j]; 2163: } 2164: } 2165: 2166: break; 2167: } 2168: 2169: case MRL : 2170: { 2171: if (type != 'O') 2172: { 2173: incrementation_atomique(s_objet); 2174: return(s_objet); 2175: } 2176: 2177: if ((s_nouvel_objet = allocation(s_etat_processus, MRL)) == NULL) 2178: { 2179: return(NULL); 2180: } 2181: 2182: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = 2183: (void **) ((real8 **) malloc( 2184: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes) 2185: * sizeof(real8 *))); 2186: 2187: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau 2188: == NULL) 2189: { 2190: free((*s_nouvel_objet).objet); 2191: free(s_nouvel_objet); 2192: return(NULL); 2193: } 2194: 2195: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes = 2196: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes; 2197: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes = 2198: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes; 2199: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type = 2200: (*((struct_matrice *) ((*s_objet).objet))).type; 2201: 2202: for(i = 0; i < (*((struct_matrice *) 2203: ((*s_objet).objet))).nombre_lignes; i++) 2204: { 2205: if ((((real8 **) ((*((struct_matrice *) 2206: ((*s_nouvel_objet).objet))).tableau))[i] = 2207: (void *) ((real8 *) malloc( 2208: ((*((struct_matrice *) ((*s_objet).objet))) 2209: .nombre_colonnes) * sizeof(real8)))) == NULL) 2210: { 2211: for(j = 0; j < i; j++) 2212: { 2213: free(((real8 **) ((*((struct_matrice *) 2214: ((*s_nouvel_objet).objet))).tableau))[j]); 2215: } 2216: 2217: free((*s_nouvel_objet).objet); 2218: free(s_nouvel_objet); 2219: return(NULL); 2220: } 2221: 2222: for(j = 0; j < (*((struct_matrice *) 2223: ((*s_objet).objet))).nombre_colonnes; j++) 2224: { 2225: ((real8 **) ((*((struct_matrice *) 2226: ((*s_nouvel_objet).objet))).tableau))[i][j] = 2227: ((real8 **) ((*((struct_matrice *) 2228: ((*s_objet).objet))).tableau))[i][j]; 2229: } 2230: } 2231: 2232: break; 2233: } 2234: 2235: case MTX : 2236: { 2237: if (type != 'O') 2238: { 2239: incrementation_atomique(s_objet); 2240: return(s_objet); 2241: } 2242: 2243: if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL) 2244: { 2245: return(NULL); 2246: } 2247: 2248: (*((struct_mutex *) ((*s_nouvel_objet).objet))).mutex = 2249: (*((struct_mutex *) ((*s_objet).objet))).mutex; 2250: break; 2251: } 2252: 2253: case NOM : 2254: { 2255: if (type != 'O') 2256: { 2257: incrementation_atomique(s_objet); 2258: return(s_objet); 2259: } 2260: 2261: if ((s_nouvel_objet = allocation(s_etat_processus, NOM)) == NULL) 2262: { 2263: return(NULL); 2264: } 2265: 2266: (*((struct_nom *) (*s_nouvel_objet).objet)).nom = malloc(( 2267: strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1) * 2268: sizeof(unsigned char)); 2269: 2270: if ((*((struct_nom *) (*s_nouvel_objet).objet)).nom == NULL) 2271: { 2272: free((*s_nouvel_objet).objet); 2273: free(s_nouvel_objet); 2274: return(NULL); 2275: } 2276: 2277: strcpy((*((struct_nom *) (*s_nouvel_objet).objet)).nom, 2278: (*((struct_nom *) (*s_objet).objet)).nom); 2279: (*((struct_nom *) (*s_nouvel_objet).objet)).symbole = 2280: (*((struct_nom *) (*s_objet).objet)).symbole; 2281: break; 2282: } 2283: 2284: case NON : 2285: { 2286: if (type != 'O') 2287: { 2288: incrementation_atomique(s_objet); 2289: return(s_objet); 2290: } 2291: 2292: if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL) 2293: { 2294: return(NULL); 2295: } 2296: 2297: (*s_nouvel_objet).objet = NULL; 2298: break; 2299: } 2300: 2301: case PRC : 2302: { 2303: sigfillset(&set); 2304: pthread_sigmask(SIG_BLOCK, &set, &oldset); 2305: 2306: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 2307: (*s_objet).objet)).thread).mutex_nombre_references)) != 0) 2308: { 2309: pthread_sigmask(SIG_SETMASK, &oldset, NULL); 2310: sigpending(&set); 2311: 2312: return(NULL); 2313: } 2314: 2315: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 2316: .nombre_references++; 2317: 2318: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 2319: (*s_objet).objet)).thread).mutex_nombre_references)) != 0) 2320: { 2321: pthread_sigmask(SIG_SETMASK, &oldset, NULL); 2322: sigpending(&set); 2323: 2324: return(NULL); 2325: } 2326: 2327: pthread_sigmask(SIG_SETMASK, &oldset, NULL); 2328: sigpending(&set); 2329: 2330: if (type != 'O') 2331: { 2332: incrementation_atomique(s_objet); 2333: return(s_objet); 2334: } 2335: 2336: if ((s_nouvel_objet = allocation(s_etat_processus, PRC)) == NULL) 2337: { 2338: return(NULL); 2339: } 2340: 2341: (*((struct_processus_fils *) (*s_nouvel_objet).objet)) = 2342: (*((struct_processus_fils *) (*s_objet).objet)); 2343: break; 2344: } 2345: 2346: case REL : 2347: { 2348: if (type != 'O') 2349: { 2350: incrementation_atomique(s_objet); 2351: return(s_objet); 2352: } 2353: 2354: if ((s_nouvel_objet = allocation(s_etat_processus, REL)) == NULL) 2355: { 2356: return(NULL); 2357: } 2358: 2359: (*((real8 *) ((*s_nouvel_objet).objet))) = 2360: (*((real8 *) ((*s_objet).objet))); 2361: break; 2362: } 2363: 2364: case SCK : 2365: { 2366: if (type == 'P') 2367: { 2368: incrementation_atomique(s_objet); 2369: 2370: if (((*((struct_socket *) ((*s_objet).objet))) 2371: .format = copie_objet(s_etat_processus, 2372: (*((struct_socket *) ((*s_objet).objet))).format, 'P')) 2373: == NULL) 2374: { 2375: return(NULL); 2376: } 2377: 2378: return(s_objet); 2379: } 2380: 2381: if ((s_nouvel_objet = allocation(s_etat_processus, SCK)) == NULL) 2382: { 2383: return(NULL); 2384: } 2385: 2386: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket = 2387: (*((struct_socket *) ((*s_objet).objet))).socket; 2388: (*((struct_socket *) ((*s_nouvel_objet).objet))).domaine = 2389: (*((struct_socket *) ((*s_objet).objet))).domaine; 2390: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_en_ecoute = 2391: (*((struct_socket *) ((*s_objet).objet))).socket_en_ecoute; 2392: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_connectee = 2393: (*((struct_socket *) ((*s_objet).objet))).socket_connectee; 2394: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid = 2395: (*((struct_socket *) ((*s_objet).objet))).pid; 2396: (*((struct_socket *) ((*s_nouvel_objet).objet))).binaire = 2397: (*((struct_socket *) ((*s_objet).objet))).binaire; 2398: (*((struct_socket *) ((*s_nouvel_objet).objet))).effacement = 2399: (*((struct_socket *) ((*s_objet).objet))).effacement; 2400: (*((struct_socket *) ((*s_nouvel_objet).objet))).protection = 2401: (*((struct_socket *) ((*s_objet).objet))).protection; 2402: (*((struct_socket *) ((*s_nouvel_objet).objet))).localisation = 2403: (*((struct_socket *) ((*s_objet).objet))).localisation; 2404: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid = 2405: (*((struct_socket *) ((*s_objet).objet))).pid; 2406: (*((struct_socket *) ((*s_nouvel_objet).objet))).tid = 2407: (*((struct_socket *) ((*s_objet).objet))).tid; 2408: 2409: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format = 2410: copie_objet(s_etat_processus, (*((struct_socket *) 2411: ((*s_objet).objet))).format, type)) == NULL) 2412: { 2413: free((*s_nouvel_objet).objet); 2414: free(s_nouvel_objet); 2415: return(NULL); 2416: } 2417: 2418: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).adresse = 2419: (unsigned char *) malloc((strlen((*((struct_socket *) 2420: ((*s_objet).objet))).adresse) + 1) * sizeof(unsigned char))) 2421: == NULL) 2422: { 2423: liberation(s_etat_processus, (*((struct_fichier *) 2424: (*s_nouvel_objet).objet)).format); 2425: free((*s_nouvel_objet).objet); 2426: free(s_nouvel_objet); 2427: return(NULL); 2428: } 2429: 2430: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet))) 2431: .adresse, (*((struct_socket *) ((*s_objet).objet))) 2432: .adresse); 2433: 2434: if (((*((struct_socket *) ((*s_nouvel_objet).objet))) 2435: .adresse_distante = malloc((strlen((*((struct_socket *) 2436: ((*s_objet).objet))).adresse_distante) + 1) * 2437: sizeof(unsigned char))) == NULL) 2438: { 2439: liberation(s_etat_processus, (*((struct_fichier *) 2440: (*s_nouvel_objet).objet)).format); 2441: free((*s_nouvel_objet).objet); 2442: free(s_nouvel_objet); 2443: return(NULL); 2444: } 2445: 2446: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet))) 2447: .adresse_distante, (*((struct_socket *) ((*s_objet).objet))) 2448: .adresse_distante); 2449: 2450: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet))).type, 2451: (*((struct_socket *) ((*s_objet).objet))).type); 2452: break; 2453: } 2454: 2455: case SLB : 2456: { 2457: if (type != 'O') 2458: { 2459: incrementation_atomique(s_objet); 2460: return(s_objet); 2461: } 2462: 2463: if ((s_nouvel_objet = allocation(s_etat_processus, SLB)) == NULL) 2464: { 2465: return(NULL); 2466: } 2467: 2468: if (((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom = 2469: (unsigned char *) malloc((strlen((*((struct_bibliotheque *) 2470: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char))) 2471: == NULL) 2472: { 2473: free((*s_nouvel_objet).objet); 2474: free(s_nouvel_objet); 2475: return(NULL); 2476: } 2477: 2478: strcpy((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom, 2479: (*((struct_bibliotheque *) ((*s_objet).objet))).nom); 2480: 2481: /* 2482: * C'est objet est non modifiable et est un pointeur 2483: * sur un objet système. Seul la référence est copiée. 2484: */ 2485: 2486: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).descripteur = 2487: (*((struct_bibliotheque *) (*s_objet).objet)).descripteur; 2488: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).pid = 2489: (*((struct_bibliotheque *) (*s_objet).objet)).pid; 2490: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).tid = 2491: (*((struct_bibliotheque *) (*s_objet).objet)).tid; 2492: break; 2493: } 2494: 2495: case SPH : 2496: { 2497: if (type != 'O') 2498: { 2499: incrementation_atomique(s_objet); 2500: return(s_objet); 2501: } 2502: 2503: if ((s_nouvel_objet = allocation(s_etat_processus, SPH)) == NULL) 2504: { 2505: return(NULL); 2506: } 2507: 2508: if (((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom = 2509: malloc((strlen((*((struct_semaphore *) (*s_objet).objet)) 2510: .nom) + 1) * sizeof(unsigned char))) == NULL) 2511: { 2512: free((*s_nouvel_objet).objet); 2513: free(s_nouvel_objet); 2514: return(NULL); 2515: } 2516: 2517: strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom, 2518: (*((struct_semaphore *) (*s_objet).objet)).nom); 2519: break; 2520: } 2521: 2522: case SQL : 2523: { 2524: if (type != 'O') 2525: { 2526: incrementation_atomique(s_objet); 2527: return(s_objet); 2528: } 2529: 2530: if ((s_nouvel_objet = allocation(s_etat_processus, SQL)) == NULL) 2531: { 2532: return(NULL); 2533: } 2534: 2535: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).pid = 2536: (*((struct_connecteur_sql *) (*s_objet).objet)).pid; 2537: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).tid = 2538: (*((struct_connecteur_sql *) (*s_objet).objet)).tid; 2539: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).descripteur = 2540: (*((struct_connecteur_sql *) (*s_objet).objet)).descripteur; 2541: 2542: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type = 2543: malloc((strlen((*((struct_connecteur_sql *) 2544: (*s_objet).objet)).type) + 1) * sizeof(unsigned char))) 2545: == NULL) 2546: { 2547: free(s_nouvel_objet); 2548: return(NULL); 2549: } 2550: 2551: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type, 2552: (*((struct_connecteur_sql *) (*s_objet).objet)).type); 2553: 2554: if ((*((struct_connecteur_sql *) (*s_objet).objet)).locale != NULL) 2555: { 2556: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)) 2557: .locale = malloc((strlen((*((struct_connecteur_sql *) 2558: (*s_objet).objet)).locale) + 1) * 2559: sizeof(unsigned char))) == NULL) 2560: { 2561: free((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)) 2562: .locale); 2563: free(s_nouvel_objet); 2564: return(NULL); 2565: } 2566: 2567: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)) 2568: .locale, (*((struct_connecteur_sql *) 2569: (*s_objet).objet)).locale); 2570: } 2571: else 2572: { 2573: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).locale 2574: = NULL; 2575: } 2576: 2577: break; 2578: } 2579: 2580: case TBL : 2581: { 2582: if (type != 'P') 2583: { 2584: if ((s_nouvel_objet = allocation(s_etat_processus, TBL)) 2585: == NULL) 2586: { 2587: return(NULL); 2588: } 2589: 2590: (*((struct_tableau *) (*s_nouvel_objet).objet)) 2591: .nombre_elements = (*((struct_tableau *) 2592: (*s_objet).objet)).nombre_elements; 2593: 2594: if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements = 2595: malloc((*((struct_tableau *) (*s_objet).objet)) 2596: .nombre_elements * sizeof(struct_objet *))) == NULL) 2597: { 2598: return(NULL); 2599: } 2600: 2601: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 2602: .nombre_elements; i++) 2603: { 2604: if (((*((struct_tableau *) (*s_nouvel_objet).objet)) 2605: .elements[i] = copie_objet(s_etat_processus, 2606: (*((struct_tableau *) (*s_objet).objet)) 2607: .elements[i], type)) == NULL) 2608: { 2609: for(j = 0; j < i; j++) 2610: { 2611: liberation(s_etat_processus, (*((struct_tableau *) 2612: (*s_nouvel_objet).objet)).elements[j]); 2613: } 2614: 2615: free((*((struct_tableau *) (*s_nouvel_objet).objet)) 2616: .elements); 2617: free((*s_nouvel_objet).objet); 2618: free(s_nouvel_objet); 2619: 2620: return(NULL); 2621: } 2622: } 2623: } 2624: else 2625: { 2626: incrementation_atomique(s_objet); 2627: 2628: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 2629: .nombre_elements; i++) 2630: { 2631: (*((struct_tableau *) (*s_objet).objet)).elements[i] = 2632: copie_objet(s_etat_processus, (*((struct_tableau *) 2633: (*s_objet).objet)).elements[i], 'P'); 2634: } 2635: 2636: return(s_objet); 2637: } 2638: 2639: break; 2640: } 2641: 2642: case VIN : 2643: { 2644: if (type != 'O') 2645: { 2646: incrementation_atomique(s_objet); 2647: return(s_objet); 2648: } 2649: 2650: if ((s_nouvel_objet = allocation(s_etat_processus, VIN)) == NULL) 2651: { 2652: return(NULL); 2653: } 2654: 2655: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 2656: (void *) ((integer8 *) malloc( 2657: ((*((struct_vecteur *) ((*s_objet).objet))).taille) 2658: * sizeof(integer8))); 2659: 2660: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau 2661: == NULL) 2662: { 2663: free((*s_nouvel_objet).objet); 2664: free(s_nouvel_objet); 2665: return(NULL); 2666: } 2667: 2668: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille = 2669: (*((struct_vecteur *) ((*s_objet).objet))).taille; 2670: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type = 2671: (*((struct_vecteur *) ((*s_objet).objet))).type; 2672: 2673: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille; 2674: i++) 2675: { 2676: ((integer8 *) ((*((struct_vecteur *) 2677: ((*s_nouvel_objet).objet))).tableau))[i] = 2678: ((integer8 *) ((*((struct_vecteur *) 2679: ((*s_objet).objet))).tableau))[i]; 2680: } 2681: 2682: break; 2683: } 2684: 2685: case VCX : 2686: { 2687: if (type != 'O') 2688: { 2689: incrementation_atomique(s_objet); 2690: return(s_objet); 2691: } 2692: 2693: if ((s_nouvel_objet = allocation(s_etat_processus, VCX)) == NULL) 2694: { 2695: return(NULL); 2696: } 2697: 2698: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 2699: (void *) ((struct_complexe16 *) malloc( 2700: ((*((struct_vecteur *) ((*s_objet).objet))).taille) 2701: * sizeof(struct_complexe16))); 2702: 2703: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau 2704: == NULL) 2705: { 2706: free((*s_nouvel_objet).objet); 2707: free(s_nouvel_objet); 2708: return(NULL); 2709: } 2710: 2711: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille = 2712: (*((struct_vecteur *) ((*s_objet).objet))).taille; 2713: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type = 2714: (*((struct_vecteur *) ((*s_objet).objet))).type; 2715: 2716: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille; 2717: i++) 2718: { 2719: ((struct_complexe16 *) ((*((struct_vecteur *) 2720: ((*s_nouvel_objet).objet))).tableau))[i] = 2721: ((struct_complexe16 *) ((*((struct_vecteur *) 2722: ((*s_objet).objet))).tableau))[i]; 2723: } 2724: 2725: break; 2726: } 2727: 2728: case VRL : 2729: { 2730: if (type != 'O') 2731: { 2732: incrementation_atomique(s_objet); 2733: return(s_objet); 2734: } 2735: 2736: if ((s_nouvel_objet = allocation(s_etat_processus, VRL)) == NULL) 2737: { 2738: return(NULL); 2739: } 2740: 2741: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 2742: (void *) ((real8 *) malloc( 2743: ((*((struct_vecteur *) ((*s_objet).objet))).taille) 2744: * sizeof(real8))); 2745: 2746: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau 2747: == NULL) 2748: { 2749: free((*s_nouvel_objet).objet); 2750: free(s_nouvel_objet); 2751: return(NULL); 2752: } 2753: 2754: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille = 2755: (*((struct_vecteur *) ((*s_objet).objet))).taille; 2756: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type = 2757: (*((struct_vecteur *) ((*s_objet).objet))).type; 2758: 2759: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille; 2760: i++) 2761: { 2762: ((real8 *) ((*((struct_vecteur *) 2763: ((*s_nouvel_objet).objet))).tableau))[i] = 2764: ((real8 *) ((*((struct_vecteur *) 2765: ((*s_objet).objet))).tableau))[i]; 2766: } 2767: 2768: break; 2769: } 2770: 2771: default : 2772: { 2773: return(NULL); 2774: } 2775: } 2776: 2777: return(s_nouvel_objet); 2778: 2779: #undef return 2780: } 2781: 2782: 2783: /* 2784: ================================================================================ 2785: Routine de copie d'une structure de description d'un processus 2786: ================================================================================ 2787: Entrées : pointeur sur la structure de description d'un processus 2788: -------------------------------------------------------------------------------- 2789: Sorties : structure identique (tous les objets sont copiés) 2790: -------------------------------------------------------------------------------- 2791: Effets de bord : néant 2792: ================================================================================ 2793: */ 2794: 2795: struct_processus * 2796: copie_etat_processus(struct_processus *s_etat_processus) 2797: { 2798: pthread_mutexattr_t attributs_mutex; 2799: 2800: struct_liste_chainee *l_element_lecture; 2801: struct_liste_chainee *l_element_precedent; 2802: struct_liste_chainee *l_element_suivant; 2803: 2804: struct_processus *s_nouvel_etat_processus; 2805: 2806: unsigned long i; 2807: 2808: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) 2809: { 2810: (*s_etat_processus).erreur_systeme = d_es_processus; 2811: return(NULL); 2812: } 2813: 2814: if ((s_nouvel_etat_processus = malloc(sizeof(struct_processus))) == NULL) 2815: { 2816: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2817: return(NULL); 2818: } 2819: 2820: (*s_nouvel_etat_processus) = (*s_etat_processus); 2821: 2822: // On réinitialise l'allocateur. 2823: 2824: initialisation_allocateur(s_nouvel_etat_processus); 2825: 2826: /* 2827: * (*s_etat_processus).definition_chainee, 2828: * (*s_etat_processus).nom_fichier_source, 2829: * (*s_etat_processus).nom_fichier_historique et 2830: * (*s_etat_processus).chemin_fichier_temporaires 2831: * n'ont aucune raison de changer. 2832: */ 2833: 2834: # ifndef SEMAPHORES_NOMMES 2835: sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0); 2836: # else 2837: if (((*s_nouvel_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) 2838: == SEM_FAILED) 2839: { 2840: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2841: return(NULL); 2842: } 2843: # endif 2844: 2845: (*s_nouvel_etat_processus).var_volatile_processus_pere = 0; 2846: (*s_nouvel_etat_processus).var_volatile_processus_racine = 0; 2847: (*s_nouvel_etat_processus).fichiers_graphiques = NULL; 2848: (*s_nouvel_etat_processus).entree_standard = NULL; 2849: (*s_nouvel_etat_processus).s_marques = NULL; 2850: (*s_nouvel_etat_processus).requete_nouveau_plan = d_vrai; 2851: (*s_nouvel_etat_processus).mise_a_jour_trace_requise = d_faux; 2852: (*s_nouvel_etat_processus).nom_fichier_impression = NULL; 2853: (*s_nouvel_etat_processus).expression_courante = NULL; 2854: (*s_nouvel_etat_processus).objet_courant = NULL; 2855: (*s_nouvel_etat_processus).processus_detache = d_faux; 2856: (*s_nouvel_etat_processus).evaluation_forcee = 'N'; 2857: 2858: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0; 2859: (*s_nouvel_etat_processus).nombre_objets_injectes = 0; 2860: (*s_nouvel_etat_processus).presence_fusible = d_faux; 2861: (*s_nouvel_etat_processus).thread_fusible = 0; 2862: (*s_nouvel_etat_processus).niveau_initial = 2863: (*s_etat_processus).niveau_courant; 2864: (*s_nouvel_etat_processus).presence_pipes = d_faux; 2865: (*s_nouvel_etat_processus).debug_programme = d_faux; 2866: (*s_nouvel_etat_processus).s_fichiers = NULL; 2867: (*s_nouvel_etat_processus).s_connecteurs_sql = NULL; 2868: 2869: // On réinitialise toutes les interruptions. 2870: 2871: (*s_nouvel_etat_processus).traitement_interruption = 'N'; 2872: (*s_nouvel_etat_processus).traitement_interruptible = 'Y'; 2873: (*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0; 2874: (*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0; 2875: 2876: (*s_nouvel_etat_processus).at_exit = NULL; 2877: (*s_nouvel_etat_processus).at_poke = NULL; 2878: (*s_nouvel_etat_processus).traitement_at_poke = 'N'; 2879: 2880: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++) 2881: { 2882: (*s_nouvel_etat_processus).corps_interruptions[i] = NULL; 2883: (*s_nouvel_etat_processus).masque_interruptions[i] = 'N'; 2884: (*s_nouvel_etat_processus).queue_interruptions[i] = 0; 2885: (*s_nouvel_etat_processus).pile_origine_interruptions[i] = NULL; 2886: } 2887: 2888: if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL) 2889: { 2890: if (((*s_nouvel_etat_processus).generateur_aleatoire = 2891: gsl_rng_clone((*s_etat_processus).generateur_aleatoire)) 2892: == NULL) 2893: { 2894: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2895: return(NULL); 2896: } 2897: 2898: gsl_rng_set((*s_nouvel_etat_processus).generateur_aleatoire, 2899: gsl_rng_get((*s_etat_processus).generateur_aleatoire)); 2900: } 2901: 2902: // Copie de la localisation 2903: 2904: if (((*s_nouvel_etat_processus).localisation = malloc((strlen( 2905: (*s_etat_processus).localisation) + 1) * sizeof(unsigned char))) 2906: == NULL) 2907: { 2908: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2909: return(NULL); 2910: } 2911: 2912: strcpy((*s_nouvel_etat_processus).localisation, 2913: (*s_etat_processus).localisation); 2914: 2915: if ((*s_etat_processus).indep != NULL) 2916: { 2917: if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus, 2918: (*s_etat_processus).indep, 'P')) == NULL) 2919: { 2920: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 2921: { 2922: (*s_etat_processus).erreur_systeme = d_es_processus; 2923: return(NULL); 2924: } 2925: 2926: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2927: return(NULL); 2928: } 2929: } 2930: else 2931: { 2932: (*s_nouvel_etat_processus).indep = NULL; 2933: } 2934: 2935: if ((*s_etat_processus).depend != NULL) 2936: { 2937: if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus, 2938: (*s_etat_processus).depend, 'P')) == NULL) 2939: { 2940: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 2941: { 2942: (*s_etat_processus).erreur_systeme = d_es_processus; 2943: return(NULL); 2944: } 2945: 2946: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2947: return(NULL); 2948: } 2949: } 2950: else 2951: { 2952: (*s_nouvel_etat_processus).depend = NULL; 2953: } 2954: 2955: if ((*s_etat_processus).parametres_courbes_de_niveau != NULL) 2956: { 2957: if (((*s_nouvel_etat_processus).parametres_courbes_de_niveau = 2958: copie_objet(s_etat_processus, (*s_etat_processus) 2959: .parametres_courbes_de_niveau, 'P')) == NULL) 2960: { 2961: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 2962: { 2963: (*s_etat_processus).erreur_systeme = d_es_processus; 2964: return(NULL); 2965: } 2966: 2967: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2968: return(NULL); 2969: } 2970: } 2971: else 2972: { 2973: (*s_nouvel_etat_processus).parametres_courbes_de_niveau = NULL; 2974: } 2975: 2976: (*s_nouvel_etat_processus).instruction_derniere_erreur = NULL; 2977: 2978: if (((*s_etat_processus).instruction_courante != NULL) && 2979: (*s_etat_processus).evaluation_expression_compilee == 'N') 2980: { 2981: if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen( 2982: (*s_etat_processus).instruction_courante) + 1) * 2983: sizeof(unsigned char))) == NULL) 2984: { 2985: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 2986: { 2987: (*s_etat_processus).erreur_systeme = d_es_processus; 2988: return(NULL); 2989: } 2990: 2991: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2992: return(NULL); 2993: } 2994: 2995: strcpy((*s_nouvel_etat_processus).instruction_courante, 2996: (*s_etat_processus).instruction_courante); 2997: } 2998: else 2999: { 3000: (*s_nouvel_etat_processus).instruction_courante = NULL; 3001: } 3002: 3003: if ((*s_etat_processus).label_x != NULL) 3004: { 3005: if (((*s_nouvel_etat_processus).label_x = malloc((strlen( 3006: (*s_etat_processus).label_x) + 1) * 3007: sizeof(unsigned char))) == NULL) 3008: { 3009: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3010: { 3011: (*s_etat_processus).erreur_systeme = d_es_processus; 3012: return(NULL); 3013: } 3014: 3015: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3016: return(NULL); 3017: } 3018: 3019: strcpy((*s_nouvel_etat_processus).label_x, 3020: (*s_etat_processus).label_x); 3021: } 3022: else 3023: { 3024: (*s_nouvel_etat_processus).label_x = NULL; 3025: } 3026: 3027: if ((*s_etat_processus).label_y != NULL) 3028: { 3029: if (((*s_nouvel_etat_processus).label_y = malloc((strlen( 3030: (*s_etat_processus).label_y) + 1) * 3031: sizeof(unsigned char))) == NULL) 3032: { 3033: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3034: { 3035: (*s_etat_processus).erreur_systeme = d_es_processus; 3036: return(NULL); 3037: } 3038: 3039: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3040: return(NULL); 3041: } 3042: 3043: strcpy((*s_nouvel_etat_processus).label_y, 3044: (*s_etat_processus).label_y); 3045: } 3046: else 3047: { 3048: (*s_nouvel_etat_processus).label_y = NULL; 3049: } 3050: 3051: if ((*s_etat_processus).label_z != NULL) 3052: { 3053: if (((*s_nouvel_etat_processus).label_z = malloc((strlen( 3054: (*s_etat_processus).label_z) + 1) * 3055: sizeof(unsigned char))) == NULL) 3056: { 3057: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3058: { 3059: (*s_etat_processus).erreur_systeme = d_es_processus; 3060: return(NULL); 3061: } 3062: 3063: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3064: return(NULL); 3065: } 3066: 3067: strcpy((*s_nouvel_etat_processus).label_z, 3068: (*s_etat_processus).label_z); 3069: } 3070: else 3071: { 3072: (*s_nouvel_etat_processus).label_z = NULL; 3073: } 3074: 3075: if ((*s_etat_processus).titre != NULL) 3076: { 3077: if (((*s_nouvel_etat_processus).titre = malloc((strlen( 3078: (*s_etat_processus).titre) + 1) * 3079: sizeof(unsigned char))) == NULL) 3080: { 3081: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3082: { 3083: (*s_etat_processus).erreur_systeme = d_es_processus; 3084: return(NULL); 3085: } 3086: 3087: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3088: return(NULL); 3089: } 3090: 3091: strcpy((*s_nouvel_etat_processus).titre, 3092: (*s_etat_processus).titre); 3093: } 3094: else 3095: { 3096: (*s_nouvel_etat_processus).titre = NULL; 3097: } 3098: 3099: if ((*s_etat_processus).legende != NULL) 3100: { 3101: if (((*s_nouvel_etat_processus).legende = malloc((strlen( 3102: (*s_etat_processus).legende) + 1) * 3103: sizeof(unsigned char))) == NULL) 3104: { 3105: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3106: { 3107: (*s_etat_processus).erreur_systeme = d_es_processus; 3108: return(NULL); 3109: } 3110: 3111: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3112: return(NULL); 3113: } 3114: 3115: strcpy((*s_nouvel_etat_processus).legende, 3116: (*s_etat_processus).legende); 3117: } 3118: else 3119: { 3120: (*s_nouvel_etat_processus).legende = NULL; 3121: } 3122: 3123: /* 3124: * Copie de la table des variables 3125: */ 3126: 3127: copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus); 3128: 3129: if ((*s_nouvel_etat_processus).erreur_systeme != d_es) 3130: { 3131: return(NULL); 3132: } 3133: 3134: /* 3135: * Copie de la table des variables statiques 3136: */ 3137: 3138: if (((*s_nouvel_etat_processus).s_liste_variables_statiques = 3139: malloc((*s_etat_processus).nombre_variables_statiques_allouees * 3140: sizeof(struct_variable_statique))) == NULL) 3141: { 3142: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3143: { 3144: (*s_etat_processus).erreur_systeme = d_es_processus; 3145: return(NULL); 3146: } 3147: 3148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3149: return(NULL); 3150: } 3151: 3152: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) 3153: { 3154: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom = 3155: malloc((strlen((*s_etat_processus).s_liste_variables_statiques 3156: [i].nom) + 1) * sizeof(unsigned char))) == NULL) 3157: { 3158: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3159: { 3160: (*s_etat_processus).erreur_systeme = d_es_processus; 3161: return(NULL); 3162: } 3163: 3164: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3165: return(NULL); 3166: } 3167: 3168: strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom, 3169: (*s_etat_processus).s_liste_variables_statiques[i].nom); 3170: 3171: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine = 3172: (*s_etat_processus).s_liste_variables_statiques[i].origine; 3173: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau = 3174: (*s_etat_processus).s_liste_variables_statiques[i].niveau; 3175: (*s_nouvel_etat_processus).s_liste_variables_statiques[i] 3176: .variable_statique = (*s_etat_processus) 3177: .s_liste_variables_statiques[i].variable_statique; 3178: 3179: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet = 3180: copie_objet(s_etat_processus, (*s_etat_processus) 3181: .s_liste_variables_statiques[i].objet, 'P')) == NULL) 3182: { 3183: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3184: { 3185: (*s_etat_processus).erreur_systeme = d_es_processus; 3186: return(NULL); 3187: } 3188: 3189: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3190: return(NULL); 3191: } 3192: } 3193: 3194: /* 3195: * Copie de la pile opérationnelle 3196: */ 3197: 3198: (*s_nouvel_etat_processus).l_base_pile = NULL; 3199: l_element_lecture = (*s_etat_processus).l_base_pile; 3200: l_element_precedent = NULL; 3201: 3202: while(l_element_lecture != NULL) 3203: { 3204: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL) 3205: { 3206: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3207: { 3208: (*s_etat_processus).erreur_systeme = d_es_processus; 3209: return(NULL); 3210: } 3211: 3212: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3213: return(NULL); 3214: } 3215: 3216: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus, 3217: (*l_element_lecture).donnee, 'P')) == NULL) 3218: { 3219: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3220: { 3221: (*s_etat_processus).erreur_systeme = d_es_processus; 3222: return(NULL); 3223: } 3224: 3225: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3226: return(NULL); 3227: } 3228: 3229: (*l_element_suivant).suivant = NULL; 3230: 3231: if ((*s_nouvel_etat_processus).l_base_pile == NULL) 3232: { 3233: (*s_nouvel_etat_processus).l_base_pile = l_element_suivant; 3234: } 3235: else 3236: { 3237: (*l_element_precedent).suivant = l_element_suivant; 3238: } 3239: 3240: l_element_precedent = l_element_suivant; 3241: l_element_lecture = (*l_element_lecture).suivant; 3242: } 3243: 3244: /* 3245: * Copie de la pile système 3246: */ 3247: 3248: (*s_nouvel_etat_processus).l_base_pile_systeme = NULL; 3249: (*s_nouvel_etat_processus).hauteur_pile_systeme = 0; 3250: 3251: empilement_pile_systeme(s_nouvel_etat_processus); 3252: 3253: if ((*s_nouvel_etat_processus).erreur_systeme != d_es) 3254: { 3255: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3256: { 3257: (*s_etat_processus).erreur_systeme = d_es_processus; 3258: return(NULL); 3259: } 3260: 3261: (*s_etat_processus).erreur_systeme = 3262: (*s_nouvel_etat_processus).erreur_systeme; 3263: return(NULL); 3264: } 3265: 3266: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y'; 3267: 3268: /* 3269: * On empile deux valeurs retour_definition pour pouvoir récupérer 3270: * les variables dans le cas d'un programme compilé. 3271: */ 3272: 3273: empilement_pile_systeme(s_nouvel_etat_processus); 3274: 3275: if ((*s_nouvel_etat_processus).erreur_systeme != d_es) 3276: { 3277: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3278: { 3279: (*s_etat_processus).erreur_systeme = d_es_processus; 3280: return(NULL); 3281: } 3282: 3283: (*s_etat_processus).erreur_systeme = 3284: (*s_nouvel_etat_processus).erreur_systeme; 3285: return(NULL); 3286: } 3287: 3288: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y'; 3289: 3290: /* 3291: * Destruction de la pile last pour le thread en cours. 3292: */ 3293: 3294: (*s_nouvel_etat_processus).l_base_pile_last = NULL; 3295: (*s_nouvel_etat_processus).l_base_pile_processus = NULL; 3296: 3297: /* 3298: * Copie des différents contextes 3299: */ 3300: 3301: (*s_nouvel_etat_processus).l_base_pile_contextes = NULL; 3302: l_element_lecture = (*s_etat_processus).l_base_pile_contextes; 3303: 3304: while(l_element_lecture != NULL) 3305: { 3306: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL) 3307: { 3308: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3309: { 3310: (*s_etat_processus).erreur_systeme = d_es_processus; 3311: return(NULL); 3312: } 3313: 3314: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3315: return(NULL); 3316: } 3317: 3318: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus, 3319: (*l_element_lecture).donnee, 'P')) == NULL) 3320: { 3321: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3322: { 3323: (*s_etat_processus).erreur_systeme = d_es_processus; 3324: return(NULL); 3325: } 3326: 3327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3328: return(NULL); 3329: } 3330: 3331: (*l_element_suivant).suivant = NULL; 3332: 3333: if ((*s_nouvel_etat_processus).l_base_pile_contextes == NULL) 3334: { 3335: (*s_nouvel_etat_processus).l_base_pile_contextes = 3336: l_element_suivant; 3337: } 3338: else 3339: { 3340: (*l_element_precedent).suivant = l_element_suivant; 3341: } 3342: 3343: l_element_precedent = l_element_suivant; 3344: l_element_lecture = (*l_element_lecture).suivant; 3345: } 3346: 3347: (*s_nouvel_etat_processus).l_base_pile_taille_contextes = NULL; 3348: l_element_lecture = (*s_etat_processus).l_base_pile_taille_contextes; 3349: 3350: while(l_element_lecture != NULL) 3351: { 3352: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL) 3353: { 3354: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3355: { 3356: (*s_etat_processus).erreur_systeme = d_es_processus; 3357: return(NULL); 3358: } 3359: 3360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3361: return(NULL); 3362: } 3363: 3364: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus, 3365: (*l_element_lecture).donnee, 'P')) == NULL) 3366: { 3367: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3368: { 3369: (*s_etat_processus).erreur_systeme = d_es_processus; 3370: return(NULL); 3371: } 3372: 3373: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3374: return(NULL); 3375: } 3376: 3377: (*l_element_suivant).suivant = NULL; 3378: 3379: if ((*s_nouvel_etat_processus).l_base_pile_taille_contextes == NULL) 3380: { 3381: (*s_nouvel_etat_processus).l_base_pile_taille_contextes = 3382: l_element_suivant; 3383: } 3384: else 3385: { 3386: (*l_element_precedent).suivant = l_element_suivant; 3387: } 3388: 3389: l_element_precedent = l_element_suivant; 3390: l_element_lecture = (*l_element_lecture).suivant; 3391: } 3392: 3393: /* 3394: * Copies des piles s_sockets, s_bibliotheques et 3395: * s_instructions_externes. 3396: */ 3397: 3398: (*s_nouvel_etat_processus).s_sockets = NULL; 3399: l_element_lecture = (*s_etat_processus).s_sockets; 3400: 3401: while(l_element_lecture != NULL) 3402: { 3403: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL) 3404: { 3405: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3406: { 3407: (*s_etat_processus).erreur_systeme = d_es_processus; 3408: return(NULL); 3409: } 3410: 3411: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3412: return(NULL); 3413: } 3414: 3415: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus, 3416: (*l_element_lecture).donnee, 'P')) == NULL) 3417: { 3418: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3419: { 3420: (*s_etat_processus).erreur_systeme = d_es_processus; 3421: return(NULL); 3422: } 3423: 3424: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3425: return(NULL); 3426: } 3427: 3428: (*l_element_suivant).suivant = NULL; 3429: 3430: if ((*s_nouvel_etat_processus).s_sockets == NULL) 3431: { 3432: (*s_nouvel_etat_processus).s_sockets = l_element_suivant; 3433: } 3434: else 3435: { 3436: (*l_element_precedent).suivant = l_element_suivant; 3437: } 3438: 3439: l_element_precedent = l_element_suivant; 3440: l_element_lecture = (*l_element_lecture).suivant; 3441: } 3442: 3443: (*s_nouvel_etat_processus).s_bibliotheques = NULL; 3444: l_element_precedent = NULL; 3445: l_element_lecture = (*s_etat_processus).s_bibliotheques; 3446: 3447: while(l_element_lecture != NULL) 3448: { 3449: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL) 3450: { 3451: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3452: { 3453: (*s_etat_processus).erreur_systeme = d_es_processus; 3454: return(NULL); 3455: } 3456: 3457: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3458: return(NULL); 3459: } 3460: 3461: if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque))) 3462: == NULL) 3463: { 3464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3465: return(NULL); 3466: } 3467: 3468: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).descripteur 3469: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)) 3470: .descripteur; 3471: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).pid 3472: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).pid; 3473: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).tid 3474: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid; 3475: 3476: if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom = 3477: malloc((strlen((*((struct_bibliotheque *) (*l_element_lecture) 3478: .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL) 3479: { 3480: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3481: { 3482: (*s_etat_processus).erreur_systeme = d_es_processus; 3483: return(NULL); 3484: } 3485: 3486: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3487: return(NULL); 3488: } 3489: 3490: strcpy((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom, 3491: (*((struct_bibliotheque *) (*l_element_lecture).donnee)).nom); 3492: 3493: (*l_element_suivant).suivant = NULL; 3494: 3495: if ((*s_nouvel_etat_processus).s_bibliotheques == NULL) 3496: { 3497: (*s_nouvel_etat_processus).s_bibliotheques = l_element_suivant; 3498: } 3499: else 3500: { 3501: (*l_element_precedent).suivant = l_element_suivant; 3502: } 3503: 3504: l_element_precedent = l_element_suivant; 3505: l_element_lecture = (*l_element_lecture).suivant; 3506: } 3507: 3508: if ((*s_etat_processus).nombre_instructions_externes != 0) 3509: { 3510: if (((*s_nouvel_etat_processus).s_instructions_externes = 3511: malloc((*s_etat_processus).nombre_instructions_externes * 3512: sizeof(struct_instruction_externe))) == NULL) 3513: { 3514: (*s_etat_processus).erreur_systeme = d_es_processus; 3515: return(NULL); 3516: } 3517: 3518: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++) 3519: { 3520: if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom = 3521: malloc((strlen((*s_etat_processus).s_instructions_externes 3522: [i].nom) + 1) * sizeof(unsigned char))) == NULL) 3523: { 3524: (*s_etat_processus).erreur_systeme = d_es_processus; 3525: return(NULL); 3526: } 3527: 3528: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i].nom, 3529: (*s_etat_processus).s_instructions_externes[i].nom); 3530: 3531: if (((*s_nouvel_etat_processus).s_instructions_externes[i] 3532: .nom_bibliotheque = malloc((strlen((*s_etat_processus) 3533: .s_instructions_externes[i].nom_bibliotheque) + 1) * 3534: sizeof(unsigned char))) == NULL) 3535: { 3536: (*s_etat_processus).erreur_systeme = d_es_processus; 3537: return(NULL); 3538: } 3539: 3540: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i] 3541: .nom_bibliotheque, (*s_etat_processus) 3542: .s_instructions_externes[i].nom_bibliotheque); 3543: 3544: (*s_nouvel_etat_processus).s_instructions_externes[i] 3545: .descripteur_bibliotheque = (*s_etat_processus) 3546: .s_instructions_externes[i].descripteur_bibliotheque; 3547: } 3548: } 3549: else 3550: { 3551: (*s_nouvel_etat_processus).s_instructions_externes = NULL; 3552: } 3553: 3554: pthread_mutexattr_init(&attributs_mutex); 3555: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); 3556: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex); 3557: pthread_mutexattr_destroy(&attributs_mutex); 3558: 3559: pthread_mutexattr_init(&attributs_mutex); 3560: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); 3561: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation), 3562: &attributs_mutex); 3563: pthread_mutexattr_destroy(&attributs_mutex); 3564: 3565: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 3566: { 3567: (*s_etat_processus).erreur_systeme = d_es_processus; 3568: return(NULL); 3569: } 3570: 3571: return(s_nouvel_etat_processus); 3572: 3573: #undef return 3574: } 3575: 3576: 3577: /* 3578: ================================================================================ 3579: Routines de debug 3580: ================================================================================ 3581: entrées : 3582: -------------------------------------------------------------------------------- 3583: sorties : 3584: -------------------------------------------------------------------------------- 3585: effets de bord : néant 3586: ================================================================================ 3587: */ 3588: 3589: #ifdef DEBUG_MEMOIRE 3590: 3591: #undef malloc 3592: #undef realloc 3593: #undef free 3594: #undef fork 3595: 3596: #ifdef return 3597: # undef return 3598: #endif 3599: 3600: #ifdef __BACKTRACE 3601: #define PROFONDEUR_PILE 64 3602: #define return(a) { if (a == NULL) \ 3603: { BACKTRACE(PROFONDEUR_PILE); \ 3604: fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \ 3605: return(a); } while(0) 3606: #endif 3607: 3608: #undef fprintf 3609: #define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b)) 3610: #undef CORE_DUMP 3611: 3612: typedef struct memoire 3613: { 3614: void *pointeur; 3615: unsigned char *fonction; 3616: unsigned char *argument; 3617: unsigned long ligne; 3618: size_t taille; 3619: unsigned long long ordre; 3620: # ifdef __BACKTRACE 3621: void *pile[PROFONDEUR_PILE]; 3622: int profondeur; 3623: # endif 3624: struct memoire *suivant; 3625: } struct_memoire; 3626: 3627: static struct_memoire *debug = NULL; 3628: static unsigned long long ordre = 0; 3629: static pthread_mutex_t mutex_allocation; 3630: 3631: void 3632: debug_memoire_initialisation() 3633: { 3634: pthread_mutexattr_t attributs_mutex; 3635: 3636: pthread_mutexattr_init(&attributs_mutex); 3637: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); 3638: pthread_mutex_init(&mutex_allocation, &attributs_mutex); 3639: pthread_mutexattr_destroy(&attributs_mutex); 3640: 3641: return; 3642: } 3643: 3644: void * 3645: debug_memoire_ajout(size_t taille, const unsigned char *fonction, 3646: unsigned long ligne, const unsigned char *argument) 3647: { 3648: struct_memoire *ancienne_base; 3649: 3650: void *pointeur; 3651: 3652: pthread_mutex_lock(&mutex_allocation); 3653: 3654: ancienne_base = debug; 3655: 3656: if ((debug = malloc(sizeof(struct_memoire))) == NULL) 3657: { 3658: pthread_mutex_unlock(&mutex_allocation); 3659: return(NULL); 3660: } 3661: 3662: if (((*debug).pointeur = malloc(taille)) == NULL) 3663: { 3664: pthread_mutex_unlock(&mutex_allocation); 3665: return(NULL); 3666: } 3667: 3668: (*debug).suivant = ancienne_base; 3669: (*debug).ligne = ligne; 3670: (*debug).taille = taille; 3671: (*debug).ordre = ordre; 3672: 3673: pointeur = (*debug).pointeur; 3674: 3675: # ifdef __BACKTRACE 3676: (*debug).profondeur = backtrace((*debug).pile, PROFONDEUR_PILE); 3677: # endif 3678: 3679: if (((*debug).fonction = malloc((strlen(fonction) + 1) * 3680: sizeof(unsigned char))) == NULL) 3681: { 3682: pthread_mutex_unlock(&mutex_allocation); 3683: return(NULL); 3684: } 3685: 3686: if (((*debug).argument = malloc((strlen(argument) + 1) * 3687: sizeof(unsigned char))) == NULL) 3688: { 3689: pthread_mutex_unlock(&mutex_allocation); 3690: return(NULL); 3691: } 3692: 3693: strcpy((*debug).fonction, fonction); 3694: strcpy((*debug).argument, argument); 3695: 3696: memset((*debug).pointeur, 0, (*debug).taille); 3697: 3698: pthread_mutex_unlock(&mutex_allocation); 3699: ordre++; 3700: 3701: return(pointeur); 3702: } 3703: 3704: void * 3705: debug_memoire_modification(void *pointeur, size_t taille, 3706: const unsigned char *fonction, unsigned long ligne, 3707: const unsigned char *argument) 3708: { 3709: struct_memoire *element_courant; 3710: 3711: if (pointeur != NULL) 3712: { 3713: if (taille == 0) 3714: { 3715: // Revient à free(). Il n'y a pas de parenthèses car on ne veut 3716: // pas utiliser la macro return(). 3717: 3718: debug_memoire_retrait(pointeur); 3719: return NULL ; 3720: } 3721: else 3722: { 3723: // Réallocation réelle 3724: 3725: pthread_mutex_lock(&mutex_allocation); 3726: 3727: element_courant = debug; 3728: 3729: while(element_courant != NULL) 3730: { 3731: if ((*element_courant).pointeur == pointeur) 3732: { 3733: break; 3734: } 3735: 3736: element_courant = (*element_courant).suivant; 3737: } 3738: 3739: if (element_courant == NULL) 3740: { 3741: pthread_mutex_unlock(&mutex_allocation); 3742: 3743: uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n", 3744: getpid(), (unsigned long long) pthread_self()); 3745: # ifdef __BACKTRACE 3746: BACKTRACE(PROFONDEUR_PILE); 3747: # endif 3748: 3749: return(realloc(pointeur, taille)); 3750: } 3751: else 3752: { 3753: if (((*element_courant).pointeur = realloc(pointeur, taille)) 3754: == NULL) 3755: { 3756: pthread_mutex_unlock(&mutex_allocation); 3757: return(NULL); 3758: } 3759: 3760: (*element_courant).ligne = ligne; 3761: (*element_courant).taille = taille; 3762: free((*element_courant).fonction); 3763: free((*element_courant).argument); 3764: 3765: if (((*element_courant).fonction = malloc((strlen(fonction) 3766: + 1) * sizeof(unsigned char))) == NULL) 3767: { 3768: pthread_mutex_unlock(&mutex_allocation); 3769: return(NULL); 3770: } 3771: 3772: if (((*element_courant).argument = malloc((strlen(argument) 3773: + 1) * sizeof(unsigned char))) == NULL) 3774: { 3775: pthread_mutex_unlock(&mutex_allocation); 3776: return(NULL); 3777: } 3778: 3779: strcpy((*element_courant).fonction, fonction); 3780: strcpy((*element_courant).argument, argument); 3781: 3782: pthread_mutex_unlock(&mutex_allocation); 3783: 3784: return((*element_courant).pointeur); 3785: } 3786: } 3787: } 3788: else 3789: { 3790: // Revient à malloc() 3791: pointeur = debug_memoire_ajout(taille, fonction, ligne, argument); 3792: return(pointeur); 3793: } 3794: } 3795: 3796: void 3797: debug_memoire_retrait(void *pointeur) 3798: { 3799: struct_memoire *element_courant; 3800: struct_memoire *element_precedent; 3801: 3802: pthread_mutex_lock(&mutex_allocation); 3803: 3804: element_courant = debug; 3805: element_precedent = NULL; 3806: 3807: while(element_courant != NULL) 3808: { 3809: if ((*element_courant).pointeur == pointeur) 3810: { 3811: if (element_precedent == NULL) 3812: { 3813: debug = (*debug).suivant; 3814: } 3815: else 3816: { 3817: (*element_precedent).suivant = (*element_courant).suivant; 3818: } 3819: 3820: if (pointeur != NULL) 3821: { 3822: memset(pointeur, 0, (*element_courant).taille); 3823: } 3824: 3825: free((*element_courant).fonction); 3826: free((*element_courant).argument); 3827: free(element_courant); 3828: 3829: break; 3830: } 3831: 3832: element_precedent = element_courant; 3833: element_courant = (*element_courant).suivant; 3834: } 3835: 3836: pthread_mutex_unlock(&mutex_allocation); 3837: 3838: if (element_courant == NULL) 3839: { 3840: uprintf("[%d-%llu] ILLEGAL POINTER (free)\n", 3841: getpid(), (unsigned long long) pthread_self()); 3842: # ifdef __BACKTRACE 3843: BACKTRACE(PROFONDEUR_PILE); 3844: # endif 3845: } 3846: 3847: free(pointeur); 3848: return; 3849: } 3850: 3851: void 3852: debug_memoire_verification() 3853: { 3854: # ifdef __BACKTRACE 3855: char **appels; 3856: 3857: int j; 3858: # endif 3859: 3860: integer8 i; 3861: 3862: struct_memoire *element_courant; 3863: struct_memoire *element_suivant; 3864: 3865: fprintf(stderr, "[%d-%llu] LIST OF MEMORY LEAKS\n", 3866: getpid(), (unsigned long long) pthread_self()); 3867: 3868: pthread_mutex_lock(&mutex_allocation); 3869: 3870: element_courant = debug; 3871: i = 1; 3872: 3873: while(element_courant != NULL) 3874: { 3875: fprintf(stderr, "[%d-%llu] MEDITATION %lld (%llu)\n", getpid(), 3876: (unsigned long long) pthread_self(), i, 3877: (*element_courant).ordre); 3878: fprintf(stderr, "[%d-%llu] P: %p, F: %s(), L: %lu, S: %d\n", 3879: getpid(), (unsigned long long) pthread_self(), 3880: (*element_courant).pointeur, 3881: (*element_courant).fonction, (*element_courant).ligne, 3882: (int) (*element_courant).taille); 3883: fprintf(stderr, "[%d-%llu] A: %s\n", getpid(), 3884: (unsigned long long) pthread_self(), 3885: (*element_courant).argument); 3886: 3887: if (strstr((*element_courant).argument, "sizeof(unsigned char)") 3888: != NULL) 3889: { 3890: fprintf(stderr, "[%d-%llu] ", getpid(), 3891: (unsigned long long) pthread_self()); 3892: fprintf(stderr, "O: %s\n", (unsigned char *) 3893: (*element_courant).pointeur); 3894: } 3895: else if (strcmp((*element_courant).argument, "sizeof(struct_objet)") 3896: == 0) 3897: { 3898: fprintf(stderr, "[%d-%llu] ", getpid(), 3899: (unsigned long long) pthread_self()); 3900: fprintf(stderr, "O: %d\n", (*((struct_objet *) 3901: (*element_courant).pointeur)).type); 3902: } 3903: else if (strcmp((*element_courant).argument, 3904: "sizeof(struct_liste_chainee)") == 0) 3905: { 3906: fprintf(stderr, "[%d-%llu] ", getpid(), 3907: (unsigned long long) pthread_self()); 3908: fprintf(stderr, "O: data=%p next=%p\n", (*((struct_liste_chainee *) 3909: (*element_courant).pointeur)).donnee, 3910: (*((struct_liste_chainee *) (*element_courant).pointeur)) 3911: .suivant); 3912: } 3913: 3914: # ifdef __BACKTRACE 3915: appels = backtrace_symbols((*element_courant).pile, 3916: (*element_courant).profondeur); 3917: 3918: fprintf(stderr, "[%d-%llu] BACKTRACE\n", 3919: getpid(), (unsigned long long) pthread_self()); 3920: 3921: if (appels != NULL) 3922: { 3923: for(j = 0; j < (*element_courant).profondeur; j++) 3924: { 3925: fprintf(stderr, "[%d-%llu] %s\n", getpid(), 3926: (unsigned long long) pthread_self(), appels[j]); 3927: } 3928: 3929: free(appels); 3930: } 3931: # endif 3932: 3933: fprintf(stderr, "\n"); 3934: 3935: i++; 3936: 3937: element_suivant = (*element_courant).suivant; 3938: 3939: # ifndef CORE_DUMP 3940: free((*element_courant).fonction); 3941: free((*element_courant).argument); 3942: free(element_courant); 3943: # endif 3944: 3945: element_courant = element_suivant; 3946: } 3947: 3948: pthread_mutex_unlock(&mutex_allocation); 3949: pthread_mutex_destroy(&mutex_allocation); 3950: 3951: fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(), 3952: (unsigned long long) pthread_self()); 3953: 3954: return; 3955: } 3956: 3957: pid_t 3958: debug_fork() 3959: { 3960: pid_t pid; 3961: 3962: pthread_mutex_lock(&mutex_allocation); 3963: pid = fork(); 3964: 3965: # ifdef OS2 3966: if (pid == 0) 3967: { 3968: sem_init(&semaphore_liste_threads, 0, 1); 3969: sem_init(&semaphore_gestionnaires_signaux, 0, 0); 3970: sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1); 3971: sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); 3972: } 3973: # endif 3974: 3975: if (pid == 0) 3976: { 3977: # ifdef _BROKEN_SIGINFO 3978: liberation_fifos_signaux(s_etat_processus); 3979: creation_fifos_signaux(s_etat_processus); 3980: # endif 3981: 3982: pthread_mutex_destroy(&mutex_allocation); 3983: debug_memoire_initialisation(); 3984: } 3985: else 3986: { 3987: pthread_mutex_unlock(&mutex_allocation); 3988: } 3989: 3990: // Pas de parenthèses pour ne pas remplacer return par sa macro. 3991: return pid; 3992: } 3993: 3994: void 3995: analyse_post_mortem() 3996: { 3997: # ifdef CORE_DUMP 3998: BUG(debug != NULL, uprintf("[%d-%llu] CREATE CORE DUMP FILE FOR " 3999: "POST MORTEM ANALYZE\n", getpid(), 4000: (unsigned long long) pthread_self())); 4001: # endif 4002: 4003: return; 4004: } 4005: 4006: #endif 4007: 4008: // vim: ts=4