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