![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël 5: 6: This file is part of RPL/2. 7: 8: RPL/2 is free software; you can redistribute it and/or modify it 9: under the terms of the CeCILL V2 License as published by the french 10: CEA, CNRS and INRIA. 11: 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License 15: for more details. 16: 17: You should have received a copy of the CeCILL License 18: along with RPL/2. If not, write to info@cecill.info. 19: ================================================================================ 20: */ 21: 22: 23: #include "rpl-conv.h" 24: 25: 26: /* 27: ================================================================================ 28: Fonction 'splash' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_splash(struct_processus *s_etat_processus) 40: { 41: real8 attente; 42: 43: struct_objet *s_objet; 44: 45: (*s_etat_processus).erreur_execution = d_ex; 46: 47: if ((*s_etat_processus).affichage_arguments == 'Y') 48: { 49: printf("\n SPLASH "); 50: 51: if ((*s_etat_processus).langue == 'F') 52: { 53: printf("(écran RPL/2)\n\n"); 54: } 55: else 56: { 57: printf("(RPL/2 splash screen)\n\n"); 58: } 59: 60: printf(" 1: %s, %s\n", d_INT, d_REL); 61: 62: return; 63: } 64: else if ((*s_etat_processus).test_instruction == 'Y') 65: { 66: (*s_etat_processus).nombre_arguments = -1; 67: return; 68: } 69: 70: if (test_cfsf(s_etat_processus, 31) == d_vrai) 71: { 72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 73: { 74: return; 75: } 76: } 77: 78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 79: &s_objet) == d_erreur) 80: { 81: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 82: return; 83: } 84: 85: if (((*s_objet).type == INT) || 86: ((*s_objet).type == REL)) 87: { 88: if ((*s_objet).type == INT) 89: { 90: attente = (real8) (*((integer8 *) (*s_objet).objet)); 91: } 92: else 93: { 94: attente = (*((real8 *) (*s_objet).objet)); 95: } 96: 97: if (attente < 0) 98: { 99: liberation(s_etat_processus, s_objet); 100: 101: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 102: return; 103: } 104: 105: encart(s_etat_processus, (unsigned long) (attente * 1E6)); 106: } 107: else 108: { 109: liberation(s_etat_processus, s_objet); 110: 111: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 112: return; 113: } 114: 115: liberation(s_etat_processus, s_objet); 116: 117: return; 118: } 119: 120: 121: /* 122: ================================================================================ 123: Fonction 'send' 124: ================================================================================ 125: Entrées : 126: -------------------------------------------------------------------------------- 127: Sorties : 128: -------------------------------------------------------------------------------- 129: Effets de bord : néant 130: ================================================================================ 131: */ 132: 133: void 134: instruction_send(struct_processus *s_etat_processus) 135: { 136: pid_t pid; 137: 138: pthread_t tid; 139: 140: sig_atomic_t registre; 141: 142: ssize_t longueur_ecriture; 143: 144: struct_objet *s_objet; 145: 146: struct timespec attente; 147: 148: unsigned char tampon; 149: 150: (*s_etat_processus).erreur_execution = d_ex; 151: 152: if ((*s_etat_processus).affichage_arguments == 'Y') 153: { 154: printf("\n SEND "); 155: 156: if ((*s_etat_processus).langue == 'F') 157: { 158: printf("(envoi de données au processus père)\n\n"); 159: } 160: else 161: { 162: printf("(send data to parent process)\n\n"); 163: } 164: 165: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 166: " %s, %s, %s, %s, %s,\n" 167: " %s, %s, %s, %s, %s\n", 168: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 169: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB); 170: 171: return; 172: } 173: else if ((*s_etat_processus).test_instruction == 'Y') 174: { 175: (*s_etat_processus).nombre_arguments = -1; 176: return; 177: } 178: 179: if (test_cfsf(s_etat_processus, 31) == d_vrai) 180: { 181: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 182: { 183: return; 184: } 185: } 186: 187: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 188: &s_objet) == d_erreur) 189: { 190: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 191: return; 192: } 193: 194: if ((*s_etat_processus).presence_pipes == d_faux) 195: { 196: liberation(s_etat_processus, s_objet); 197: 198: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere; 199: return; 200: } 201: 202: if (((*s_objet).type != INT) && 203: ((*s_objet).type != REL) && 204: ((*s_objet).type != CPL) && 205: ((*s_objet).type != VIN) && 206: ((*s_objet).type != VRL) && 207: ((*s_objet).type != VCX) && 208: ((*s_objet).type != MIN) && 209: ((*s_objet).type != MRL) && 210: ((*s_objet).type != MCX) && 211: ((*s_objet).type != BIN) && 212: ((*s_objet).type != NOM) && 213: ((*s_objet).type != CHN) && 214: ((*s_objet).type != LST) && 215: ((*s_objet).type != ALG) && 216: ((*s_objet).type != RPN) && 217: ((*s_objet).type != TBL)) 218: { 219: liberation(s_etat_processus, s_objet); 220: 221: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 222: return; 223: } 224: 225: /* 226: * On signale au processus père qu'il y a un objet de plus 227: * dans le pipe de données. 228: */ 229: 230: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop; 231: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1; 232: 233: if ((*s_etat_processus).processus_detache == d_vrai) 234: { 235: if ((*s_etat_processus).profilage == d_vrai) 236: { 237: profilage(s_etat_processus, "Interprocess communications (SEND)"); 238: 239: if ((*s_etat_processus).erreur_systeme != d_es) 240: { 241: return; 242: } 243: } 244: 245: pid = -3; 246: 247: attente.tv_sec = 0; 248: attente.tv_nsec = GRANULARITE_us * 1000; 249: 250: # ifndef SEMAPHORES_NOMMES 251: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 252: { 253: (*s_etat_processus).erreur_systeme = d_es_processus; 254: return; 255: } 256: # else 257: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 258: { 259: (*s_etat_processus).erreur_systeme = d_es_processus; 260: return; 261: } 262: # endif 263: 264: while((longueur_ecriture = write_atomic(s_etat_processus, 265: (*s_etat_processus).pipe_nombre_objets_attente, 266: &pid, sizeof(pid))) != sizeof(pid)) 267: { 268: # ifndef SEMAPHORES_NOMMES 269: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 270: # else 271: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 272: # endif 273: { 274: if (errno != EINTR) 275: { 276: (*s_etat_processus).erreur_systeme = d_es_processus; 277: return; 278: } 279: } 280: 281: if (longueur_ecriture == -1) 282: { 283: if ((*s_etat_processus).profilage == d_vrai) 284: { 285: profilage(s_etat_processus, NULL); 286: } 287: 288: (*s_etat_processus).erreur_systeme = d_es_processus; 289: return; 290: } 291: 292: nanosleep(&attente, NULL); 293: INCR_GRANULARITE(attente.tv_nsec); 294: 295: # ifndef SEMAPHORES_NOMMES 296: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 297: { 298: (*s_etat_processus).erreur_systeme = d_es_processus; 299: return; 300: } 301: # else 302: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 303: { 304: (*s_etat_processus).erreur_systeme = d_es_processus; 305: return; 306: } 307: # endif 308: } 309: 310: pid = getpid(); 311: 312: attente.tv_sec = 0; 313: attente.tv_nsec = GRANULARITE_us * 1000; 314: 315: while((longueur_ecriture = write_atomic(s_etat_processus, 316: (*s_etat_processus).pipe_nombre_objets_attente, 317: &pid, sizeof(pid))) != sizeof(pid)) 318: { 319: # ifndef SEMAPHORES_NOMMES 320: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 321: # else 322: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 323: # endif 324: { 325: if (errno != EINTR) 326: { 327: (*s_etat_processus).erreur_systeme = d_es_processus; 328: return; 329: } 330: } 331: 332: if (longueur_ecriture == -1) 333: { 334: if ((*s_etat_processus).profilage == d_vrai) 335: { 336: profilage(s_etat_processus, NULL); 337: } 338: 339: (*s_etat_processus).erreur_systeme = d_es_processus; 340: return; 341: } 342: 343: nanosleep(&attente, NULL); 344: INCR_GRANULARITE(attente.tv_nsec); 345: 346: # ifndef SEMAPHORES_NOMMES 347: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 348: # else 349: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 350: # endif 351: { 352: (*s_etat_processus).erreur_systeme = d_es_processus; 353: return; 354: } 355: } 356: 357: # ifndef SEMAPHORES_NOMMES 358: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 359: # else 360: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 361: # endif 362: { 363: if (errno != EINTR) 364: { 365: (*s_etat_processus).erreur_systeme = d_es_processus; 366: return; 367: } 368: } 369: } 370: else 371: { 372: if ((*s_etat_processus).profilage == d_vrai) 373: { 374: profilage(s_etat_processus, "Interthread communications (SEND)"); 375: 376: if ((*s_etat_processus).erreur_systeme != d_es) 377: { 378: return; 379: } 380: } 381: 382: tid = -3; 383: 384: attente.tv_sec = 0; 385: attente.tv_nsec = GRANULARITE_us * 1000; 386: 387: # ifndef SEMAPHORES_NOMMES 388: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 389: { 390: (*s_etat_processus).erreur_systeme = d_es_processus; 391: return; 392: } 393: # else 394: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 395: { 396: (*s_etat_processus).erreur_systeme = d_es_processus; 397: return; 398: } 399: # endif 400: 401: while((longueur_ecriture = write_atomic(s_etat_processus, 402: (*s_etat_processus).pipe_nombre_objets_attente, 403: &tid, sizeof(tid))) != sizeof(tid)) 404: { 405: # ifndef SEMAPHORES_NOMMES 406: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 407: # else 408: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 409: # endif 410: { 411: if (errno != EINTR) 412: { 413: (*s_etat_processus).erreur_systeme = d_es_processus; 414: return; 415: } 416: } 417: 418: if (longueur_ecriture == -1) 419: { 420: if ((*s_etat_processus).profilage == d_vrai) 421: { 422: profilage(s_etat_processus, NULL); 423: } 424: 425: (*s_etat_processus).erreur_systeme = d_es_processus; 426: return; 427: } 428: 429: nanosleep(&attente, NULL); 430: INCR_GRANULARITE(attente.tv_nsec); 431: 432: # ifndef SEMAPHORES_NOMMES 433: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 434: { 435: (*s_etat_processus).erreur_systeme = d_es_processus; 436: return; 437: } 438: # else 439: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 440: { 441: (*s_etat_processus).erreur_systeme = d_es_processus; 442: return; 443: } 444: # endif 445: } 446: 447: tid = pthread_self(); 448: 449: attente.tv_sec = 0; 450: attente.tv_nsec = GRANULARITE_us * 1000; 451: 452: while((longueur_ecriture = write_atomic(s_etat_processus, 453: (*s_etat_processus).pipe_nombre_objets_attente, 454: &tid, sizeof(tid))) != sizeof(tid)) 455: { 456: # ifndef SEMAPHORES_NOMMES 457: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 458: # else 459: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 460: # endif 461: { 462: if (errno != EINTR) 463: { 464: (*s_etat_processus).erreur_systeme = d_es_processus; 465: return; 466: } 467: } 468: 469: if (longueur_ecriture == -1) 470: { 471: if ((*s_etat_processus).profilage == d_vrai) 472: { 473: profilage(s_etat_processus, NULL); 474: } 475: 476: (*s_etat_processus).erreur_systeme = d_es_processus; 477: return; 478: } 479: 480: nanosleep(&attente, NULL); 481: INCR_GRANULARITE(attente.tv_nsec); 482: 483: # ifndef SEMAPHORES_NOMMES 484: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 485: { 486: (*s_etat_processus).erreur_systeme = d_es_processus; 487: return; 488: } 489: # else 490: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 491: { 492: (*s_etat_processus).erreur_systeme = d_es_processus; 493: return; 494: } 495: # endif 496: } 497: 498: # ifndef SEMAPHORES_NOMMES 499: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 500: # else 501: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 502: # endif 503: { 504: if (errno != EINTR) 505: { 506: (*s_etat_processus).erreur_systeme = d_es_processus; 507: return; 508: } 509: } 510: } 511: 512: (*s_etat_processus).nombre_objets_envoyes_non_lus++; 513: 514: attente.tv_sec = 0; 515: attente.tv_nsec = GRANULARITE_us * 1000; 516: 517: # ifndef SEMAPHORES_NOMMES 518: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 519: { 520: (*s_etat_processus).erreur_systeme = d_es_processus; 521: return; 522: } 523: # else 524: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 525: { 526: (*s_etat_processus).erreur_systeme = d_es_processus; 527: return; 528: } 529: # endif 530: 531: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement, 532: &tampon, sizeof(unsigned char)) != sizeof(unsigned char)) 533: { 534: # ifndef SEMAPHORES_NOMMES 535: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 536: # else 537: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 538: # endif 539: { 540: if (errno != EINTR) 541: { 542: (*s_etat_processus).erreur_systeme = d_es_processus; 543: return; 544: } 545: } 546: 547: nanosleep(&attente, NULL); 548: INCR_GRANULARITE(attente.tv_nsec); 549: 550: # ifndef SEMAPHORES_NOMMES 551: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 552: # else 553: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 554: # endif 555: { 556: (*s_etat_processus).erreur_systeme = d_es_processus; 557: return; 558: } 559: } 560: 561: # ifndef SEMAPHORES_NOMMES 562: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 563: # else 564: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 565: # endif 566: { 567: if (errno != EINTR) 568: { 569: (*s_etat_processus).erreur_systeme = d_es_processus; 570: return; 571: } 572: } 573: 574: // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread 575: // de surveillance. 576: 577: if ((*s_etat_processus).processus_detache == d_vrai) 578: { 579: pid = -1; 580: 581: attente.tv_sec = 0; 582: attente.tv_nsec = GRANULARITE_us * 1000; 583: 584: # ifndef SEMAPHORES_NOMMES 585: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 586: # else 587: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 588: # endif 589: { 590: (*s_etat_processus).erreur_systeme = d_es_processus; 591: return; 592: } 593: 594: while((longueur_ecriture = write_atomic(s_etat_processus, 595: (*s_etat_processus).pipe_nombre_interruptions_attente, 596: &pid, sizeof(pid))) != sizeof(pid)) 597: { 598: # ifndef SEMAPHORES_NOMMES 599: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 600: # else 601: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 602: # endif 603: { 604: if (errno != EINTR) 605: { 606: (*s_etat_processus).erreur_systeme = d_es_processus; 607: return; 608: } 609: } 610: 611: if (longueur_ecriture == -1) 612: { 613: if ((*s_etat_processus).profilage == d_vrai) 614: { 615: profilage(s_etat_processus, NULL); 616: } 617: 618: (*s_etat_processus).erreur_systeme = d_es_processus; 619: return; 620: } 621: 622: nanosleep(&attente, NULL); 623: INCR_GRANULARITE(attente.tv_nsec); 624: 625: # ifndef SEMAPHORES_NOMMES 626: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 627: { 628: (*s_etat_processus).erreur_systeme = d_es_processus; 629: return; 630: } 631: # else 632: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 633: { 634: (*s_etat_processus).erreur_systeme = d_es_processus; 635: return; 636: } 637: # endif 638: } 639: 640: # ifndef SEMAPHORES_NOMMES 641: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 642: # else 643: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 644: # endif 645: { 646: if (errno != EINTR) 647: { 648: (*s_etat_processus).erreur_systeme = d_es_processus; 649: return; 650: } 651: } 652: } 653: else 654: { 655: tid = -1; 656: 657: attente.tv_sec = 0; 658: attente.tv_nsec = GRANULARITE_us * 1000; 659: 660: # ifndef SEMAPHORES_NOMMES 661: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 662: # else 663: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 664: # endif 665: { 666: (*s_etat_processus).erreur_systeme = d_es_processus; 667: return; 668: } 669: 670: while((longueur_ecriture = write_atomic(s_etat_processus, 671: (*s_etat_processus).pipe_nombre_interruptions_attente, 672: &tid, sizeof(tid))) != sizeof(tid)) 673: { 674: # ifndef SEMAPHORES_NOMMES 675: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 676: # else 677: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 678: # endif 679: { 680: if (errno != EINTR) 681: { 682: (*s_etat_processus).erreur_systeme = d_es_processus; 683: return; 684: } 685: } 686: 687: if (longueur_ecriture == -1) 688: { 689: if ((*s_etat_processus).profilage == d_vrai) 690: { 691: profilage(s_etat_processus, NULL); 692: } 693: 694: (*s_etat_processus).erreur_systeme = d_es_processus; 695: return; 696: } 697: 698: nanosleep(&attente, NULL); 699: INCR_GRANULARITE(attente.tv_nsec); 700: 701: # ifndef SEMAPHORES_NOMMES 702: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 703: # else 704: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 705: # endif 706: { 707: (*s_etat_processus).erreur_systeme = d_es_processus; 708: return; 709: } 710: } 711: 712: # ifndef SEMAPHORES_NOMMES 713: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 714: # else 715: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 716: # endif 717: { 718: if (errno != EINTR) 719: { 720: (*s_etat_processus).erreur_systeme = d_es_processus; 721: return; 722: } 723: } 724: } 725: 726: // ecriture_pipe() ne peut être interrompu par un signal. 727: 728: # ifndef SEMAPHORES_NOMMES 729: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 730: { 731: (*s_etat_processus).erreur_systeme = d_es_processus; 732: return; 733: } 734: # else 735: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 736: { 737: (*s_etat_processus).erreur_systeme = d_es_processus; 738: return; 739: } 740: # endif 741: 742: if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees, 743: s_objet) == d_erreur) 744: { 745: # ifndef SEMAPHORES_NOMMES 746: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 747: # else 748: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 749: # endif 750: { 751: if (errno != EINTR) 752: { 753: (*s_etat_processus).erreur_systeme = d_es_processus; 754: return; 755: } 756: } 757: 758: if ((*s_etat_processus).profilage == d_vrai) 759: { 760: profilage(s_etat_processus, NULL); 761: } 762: 763: liberation(s_etat_processus, s_objet); 764: return; 765: } 766: 767: # ifndef SEMAPHORES_NOMMES 768: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 769: # else 770: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 771: # endif 772: { 773: if (errno != EINTR) 774: { 775: (*s_etat_processus).erreur_systeme = d_es_processus; 776: return; 777: } 778: } 779: 780: if ((*s_etat_processus).profilage == d_vrai) 781: { 782: profilage(s_etat_processus, NULL); 783: } 784: 785: if (registre == 0) 786: { 787: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1) 788: { 789: (*s_etat_processus).var_volatile_requete_arret = -1; 790: } 791: 792: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre; 793: } 794: 795: liberation(s_etat_processus, s_objet); 796: return; 797: } 798: 799: 800: /* 801: ================================================================================ 802: Fonction 'sqlquery' 803: ================================================================================ 804: Entrées : 805: -------------------------------------------------------------------------------- 806: Sorties : 807: -------------------------------------------------------------------------------- 808: Effets de bord : néant 809: ================================================================================ 810: */ 811: 812: void 813: instruction_sqlquery(struct_processus *s_etat_processus) 814: { 815: # define d_LONGUEUR 1024 816: 817: logical1 connexion_permanente; 818: logical1 presence_resultat; 819: 820: struct_objet *s_copie_1; 821: struct_objet *s_objet_1; 822: struct_objet *s_copie_2; 823: struct_objet *s_objet_2; 824: struct_objet *s_objet_resultat; 825: 826: struct_liste_chainee *l_element_courant; 827: struct_liste_chainee *l_element_courant_ligne; 828: 829: unsigned char *tampon; 830: 831: unsigned int i; 832: unsigned int j; 833: unsigned int nombre_colonnes; 834: unsigned int nombre_lignes; 835: 836: (*s_etat_processus).erreur_execution = d_ex; 837: 838: if ((*s_etat_processus).affichage_arguments == 'Y') 839: { 840: printf("\n SQLQUERY "); 841: 842: if ((*s_etat_processus).langue == 'F') 843: { 844: printf("(requête SQL)\n\n"); 845: } 846: else 847: { 848: printf("(SQL query)\n\n"); 849: } 850: 851: printf(" 2: %s\n", d_CHN); 852: printf(" 1: %s\n", d_LST); 853: printf("-> 1: %s\n\n", d_LST); 854: 855: printf(" 2: %s\n", d_CHN); 856: printf(" 1: %s\n", d_SQL); 857: printf("-> 1: %s\n\n", d_LST); 858: 859: if ((*s_etat_processus).langue == 'F') 860: { 861: printf(" Utilisation :\n\n"); 862: } 863: else 864: { 865: printf(" Usage:\n\n"); 866: } 867: 868: printf(" \"select * from table\"\n"); 869: printf(" { \"mysql\" \"server\" \"database\" " 870: "\"user\" \"password\" } SQLQUERY\n"); 871: printf(" \"select field from table\"\n"); 872: printf(" { \"postgresql:iso-8859-1\" \"server\" " 873: "\"database\" \"user\" \"password\" port }\n"); 874: printf(" SQLQUERY\n"); 875: 876: return; 877: } 878: else if ((*s_etat_processus).test_instruction == 'Y') 879: { 880: (*s_etat_processus).nombre_arguments = -1; 881: return; 882: } 883: 884: if (test_cfsf(s_etat_processus, 31) == d_vrai) 885: { 886: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 887: { 888: return; 889: } 890: } 891: 892: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 893: &s_objet_1) == d_erreur) 894: { 895: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 896: return; 897: } 898: 899: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 900: &s_objet_2) == d_erreur) 901: { 902: liberation(s_etat_processus, s_objet_1); 903: 904: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 905: return; 906: } 907: 908: if ((*s_objet_1).type == LST) 909: { 910: connexion_permanente = d_faux; 911: 912: s_copie_1 = s_objet_1; 913: 914: if ((s_objet_1 = parametres_sql(s_etat_processus, s_copie_1)) == NULL) 915: { 916: liberation(s_etat_processus, s_copie_1); 917: liberation(s_etat_processus, s_objet_2); 918: return; 919: } 920: 921: liberation(s_etat_processus, s_copie_1); 922: } 923: else 924: { 925: if ((*s_objet_1).type == SQL) 926: { 927: if (((*((struct_connecteur_sql *) (*s_objet_1).objet)).pid != 928: getpid()) || (pthread_equal((*((struct_connecteur_sql *) 929: (*s_objet_1).objet)).tid, pthread_self()) == 0)) 930: { 931: (*s_etat_processus).erreur_execution = 932: d_ex_fichier_hors_contexte; 933: 934: liberation(s_etat_processus, s_objet_1); 935: liberation(s_etat_processus, s_objet_2); 936: return; 937: } 938: } 939: 940: connexion_permanente = d_vrai; 941: } 942: 943: if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN)) 944: { 945: if ((*((struct_connecteur_sql *) (*s_objet_1).objet)).locale != NULL) 946: { 947: /* 948: * Transcodage de la commande SQL 949: */ 950: 951: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O')) 952: == NULL) 953: { 954: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 955: return; 956: } 957: 958: liberation(s_etat_processus, s_objet_2); 959: s_objet_2 = s_copie_2; 960: 961: tampon = (*s_objet_2).objet; 962: 963: if (((*s_objet_2).objet = transliteration(s_etat_processus, tampon, 964: (*((struct_connecteur_sql *) (*s_objet_1).objet)).locale, 965: d_locale)) == NULL) 966: { 967: return; 968: } 969: 970: free(tampon); 971: } 972: 973: /* 974: * Pilote MySQL 975: */ 976: 977: if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type, 978: "MYSQL") == 0) 979: { 980: # ifdef MYSQL_SUPPORT 981: 982: MYSQL_RES *resultat_mysql; 983: MYSQL_ROW ligne; 984: 985: if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1) 986: .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2) 987: .objet, strlen((unsigned char *) (*s_objet_2).objet)) != 0) 988: { 989: if (connexion_permanente == d_faux) 990: { 991: mysql_close((*((struct_connecteur_sql *) (*s_objet_1) 992: .objet)).descripteur.mysql); 993: } 994: 995: liberation(s_etat_processus, s_objet_1); 996: liberation(s_etat_processus, s_objet_2); 997: 998: (*s_etat_processus).erreur_execution = d_ex_erreur_sql; 999: return; 1000: } 1001: 1002: if ((resultat_mysql = mysql_store_result( 1003: (*((struct_connecteur_sql *) (*s_objet_1).objet)) 1004: .descripteur.mysql)) == NULL) 1005: { 1006: // La requête ne renvoie rien (exemple : INSERT) 1007: presence_resultat = d_faux; 1008: nombre_colonnes = 0; 1009: } 1010: else 1011: { 1012: // La requête renvoie une ou plusieurs valeurs. 1013: presence_resultat = d_vrai; 1014: nombre_colonnes = mysql_field_count((*((struct_connecteur_sql *) 1015: (*s_objet_1).objet)).descripteur.mysql); 1016: } 1017: 1018: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1019: == NULL) 1020: { 1021: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1022: return; 1023: } 1024: 1025: (*s_objet_resultat).objet = NULL; 1026: l_element_courant = (*s_objet_resultat).objet; 1027: 1028: while(((presence_resultat == d_vrai) ? 1029: (ligne = mysql_fetch_row(resultat_mysql)) : NULL) != NULL) 1030: { 1031: unsigned long *longueurs; 1032: 1033: longueurs = mysql_fetch_lengths(resultat_mysql); 1034: 1035: if (l_element_courant == NULL) 1036: { 1037: if (((*s_objet_resultat).objet = 1038: allocation_maillon(s_etat_processus)) == NULL) 1039: { 1040: (*s_etat_processus).erreur_systeme = 1041: d_es_allocation_memoire; 1042: return; 1043: } 1044: 1045: l_element_courant = (struct_liste_chainee *) 1046: (*s_objet_resultat).objet; 1047: } 1048: else 1049: { 1050: if (((*l_element_courant).suivant = 1051: allocation_maillon(s_etat_processus)) == NULL) 1052: { 1053: (*s_etat_processus).erreur_systeme = 1054: d_es_allocation_memoire; 1055: return; 1056: } 1057: 1058: l_element_courant = (*l_element_courant).suivant; 1059: } 1060: 1061: (*l_element_courant).suivant = NULL; 1062: 1063: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1064: LST)) == NULL) 1065: { 1066: (*s_etat_processus).erreur_systeme = 1067: d_es_allocation_memoire; 1068: return; 1069: } 1070: 1071: (*(*l_element_courant).donnee).objet = NULL; 1072: l_element_courant_ligne = NULL; 1073: 1074: for(i = 0; i < nombre_colonnes; i++) 1075: { 1076: if (l_element_courant_ligne == NULL) 1077: { 1078: if (((*(*l_element_courant).donnee).objet = 1079: allocation_maillon(s_etat_processus)) == NULL) 1080: { 1081: (*s_etat_processus).erreur_systeme = 1082: d_es_allocation_memoire; 1083: return; 1084: } 1085: 1086: l_element_courant_ligne = (struct_liste_chainee *) 1087: (*(*l_element_courant).donnee).objet; 1088: } 1089: else 1090: { 1091: if (((*l_element_courant_ligne).suivant = 1092: allocation_maillon(s_etat_processus)) == NULL) 1093: { 1094: (*s_etat_processus).erreur_systeme = 1095: d_es_allocation_memoire; 1096: return; 1097: } 1098: 1099: l_element_courant_ligne = 1100: (*l_element_courant_ligne).suivant; 1101: } 1102: 1103: (*l_element_courant_ligne).suivant = NULL; 1104: 1105: if (((*l_element_courant_ligne).donnee = 1106: allocation(s_etat_processus, CHN)) == NULL) 1107: { 1108: (*s_etat_processus).erreur_systeme = 1109: d_es_allocation_memoire; 1110: return; 1111: } 1112: 1113: if (ligne[i] == NULL) 1114: { 1115: if (((*(*l_element_courant_ligne).donnee).objet = 1116: malloc(5 * sizeof(unsigned char))) == NULL) 1117: { 1118: (*s_etat_processus).erreur_systeme = 1119: d_es_allocation_memoire; 1120: return; 1121: } 1122: 1123: strcpy((unsigned char *) (*(*l_element_courant_ligne) 1124: .donnee).objet, "NULL"); 1125: } 1126: else 1127: { 1128: if (((*(*l_element_courant_ligne).donnee).objet = 1129: malloc((longueurs[i] + 1) * 1130: sizeof(unsigned char))) == NULL) 1131: { 1132: (*s_etat_processus).erreur_systeme = 1133: d_es_allocation_memoire; 1134: return; 1135: } 1136: 1137: strcpy((unsigned char *) (*(*l_element_courant_ligne) 1138: .donnee).objet, ligne[i]); 1139: } 1140: } 1141: } 1142: 1143: mysql_free_result(resultat_mysql); 1144: 1145: if (connexion_permanente == d_faux) 1146: { 1147: mysql_close((*((struct_connecteur_sql *) (*s_objet_1).objet)) 1148: .descripteur.mysql); 1149: } 1150: 1151: if (presence_resultat == d_vrai) 1152: { 1153: if (empilement(s_etat_processus, 1154: &((*s_etat_processus).l_base_pile), 1155: s_objet_resultat) == d_erreur) 1156: { 1157: return; 1158: } 1159: } 1160: 1161: # else 1162: 1163: if ((*s_etat_processus).langue == 'F') 1164: { 1165: printf("+++Attention : Support de MySQL non compilé !\n"); 1166: } 1167: else 1168: { 1169: printf("+++Warning : MySQL support not available !\n"); 1170: } 1171: 1172: fflush(stdout); 1173: # endif 1174: } 1175: 1176: /* 1177: * Pilote PostgreSQL 1178: */ 1179: 1180: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type, 1181: "POSTGRESQL") == 0) 1182: { 1183: # ifdef POSTGRESQL_SUPPORT 1184: 1185: PGresult *resultat_postgresql; 1186: 1187: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet)) 1188: .descripteur.postgresql) != CONNECTION_OK) 1189: { 1190: if (connexion_permanente == d_faux) 1191: { 1192: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet)) 1193: .descripteur.postgresql); 1194: } 1195: 1196: liberation(s_etat_processus, s_objet_1); 1197: liberation(s_etat_processus, s_objet_2); 1198: 1199: (*s_etat_processus).erreur_execution = d_ex_erreur_sql; 1200: return; 1201: } 1202: 1203: resultat_postgresql = PQexec((*((struct_connecteur_sql *) 1204: (*s_objet_1).objet)).descripteur.postgresql, 1205: (unsigned char *) (*s_objet_2).objet); 1206: presence_resultat = d_faux; 1207: 1208: switch(PQresultStatus(resultat_postgresql)) 1209: { 1210: case PGRES_COMMAND_OK : 1211: { // Commande qui ne renvoit rien 1212: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1213: == NULL) 1214: { 1215: (*s_etat_processus).erreur_systeme = 1216: d_es_allocation_memoire; 1217: return; 1218: } 1219: 1220: (*s_objet_resultat).objet = NULL; 1221: l_element_courant = (*s_objet_resultat).objet; 1222: presence_resultat = d_vrai; 1223: 1224: break; 1225: } 1226: 1227: case PGRES_TUPLES_OK : 1228: { // Commande renvoyant des données 1229: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1230: == NULL) 1231: { 1232: (*s_etat_processus).erreur_systeme = 1233: d_es_allocation_memoire; 1234: return; 1235: } 1236: 1237: (*s_objet_resultat).objet = NULL; 1238: l_element_courant = (*s_objet_resultat).objet; 1239: presence_resultat = d_vrai; 1240: 1241: nombre_colonnes = PQnfields(resultat_postgresql); 1242: nombre_lignes = PQntuples(resultat_postgresql); 1243: 1244: for(i = 0; i < nombre_lignes; i++) 1245: { 1246: // Chaînage d'un nouveau maillon de la liste résultat 1247: 1248: if (l_element_courant == NULL) 1249: { 1250: if (((*s_objet_resultat).objet = 1251: allocation_maillon(s_etat_processus)) 1252: == NULL) 1253: { 1254: (*s_etat_processus).erreur_systeme = 1255: d_es_allocation_memoire; 1256: return; 1257: } 1258: 1259: l_element_courant = (struct_liste_chainee *) 1260: (*s_objet_resultat).objet; 1261: } 1262: else 1263: { 1264: if (((*l_element_courant).suivant = 1265: allocation_maillon(s_etat_processus)) 1266: == NULL) 1267: { 1268: (*s_etat_processus).erreur_systeme = 1269: d_es_allocation_memoire; 1270: return; 1271: } 1272: 1273: l_element_courant = (*l_element_courant).suivant; 1274: } 1275: 1276: (*l_element_courant).suivant = NULL; 1277: 1278: // Création de la liste fille 1279: 1280: if (((*l_element_courant).donnee = 1281: allocation(s_etat_processus, LST)) == NULL) 1282: { 1283: (*s_etat_processus).erreur_systeme = 1284: d_es_allocation_memoire; 1285: return; 1286: } 1287: 1288: (*(*l_element_courant).donnee).objet = NULL; 1289: l_element_courant_ligne = NULL; 1290: 1291: for(j = 0; j < nombre_colonnes; j++) 1292: { 1293: if (l_element_courant_ligne == NULL) 1294: { 1295: if (((*(*l_element_courant).donnee).objet = 1296: allocation_maillon(s_etat_processus)) 1297: == NULL) 1298: { 1299: (*s_etat_processus).erreur_systeme = 1300: d_es_allocation_memoire; 1301: return; 1302: } 1303: 1304: l_element_courant_ligne = 1305: (struct_liste_chainee *) 1306: (*(*l_element_courant).donnee).objet; 1307: } 1308: else 1309: { 1310: if (((*l_element_courant_ligne).suivant = 1311: allocation_maillon(s_etat_processus)) 1312: == NULL) 1313: { 1314: l_element_courant_ligne = 1315: (*l_element_courant_ligne).suivant; 1316: } 1317: 1318: l_element_courant_ligne = 1319: (*l_element_courant_ligne).suivant; 1320: } 1321: 1322: (*l_element_courant_ligne).suivant = NULL; 1323: 1324: if (((*l_element_courant_ligne).donnee = 1325: allocation(s_etat_processus, CHN)) 1326: == NULL) 1327: { 1328: (*s_etat_processus).erreur_systeme = 1329: d_es_allocation_memoire; 1330: return; 1331: } 1332: 1333: if (PQgetisnull(resultat_postgresql, i, j) != 0) 1334: { 1335: if (((*(*l_element_courant_ligne).donnee).objet 1336: = malloc(5 * sizeof(unsigned char))) 1337: == NULL) 1338: { 1339: (*s_etat_processus).erreur_systeme = 1340: d_es_allocation_memoire; 1341: return; 1342: } 1343: 1344: strcpy((unsigned char *) 1345: (*(*l_element_courant_ligne).donnee) 1346: .objet, "NULL"); 1347: } 1348: else 1349: { 1350: if (((*(*l_element_courant_ligne).donnee).objet 1351: = malloc((PQgetlength( 1352: resultat_postgresql, i, j) + 1) * 1353: sizeof(unsigned char))) == NULL) 1354: { 1355: (*s_etat_processus).erreur_systeme = 1356: d_es_allocation_memoire; 1357: return; 1358: } 1359: 1360: strcpy((unsigned char *) 1361: (*(*l_element_courant_ligne).donnee) 1362: .objet, PQgetvalue(resultat_postgresql, 1363: i, j)); 1364: } 1365: } 1366: } 1367: 1368: break; 1369: } 1370: 1371: case PGRES_EMPTY_QUERY : 1372: case PGRES_COPY_OUT : 1373: case PGRES_COPY_IN : 1374: case PGRES_BAD_RESPONSE : 1375: case PGRES_NONFATAL_ERROR : 1376: case PGRES_FATAL_ERROR : 1377: default : 1378: { 1379: printf("%s\n", PQresultErrorMessage(resultat_postgresql)); 1380: PQclear(resultat_postgresql); 1381: 1382: if (connexion_permanente == d_faux) 1383: { 1384: PQfinish((*((struct_connecteur_sql *) (*s_objet_1) 1385: .objet)).descripteur.postgresql); 1386: } 1387: 1388: liberation(s_etat_processus, s_objet_1); 1389: liberation(s_etat_processus, s_objet_2); 1390: 1391: (*s_etat_processus).erreur_execution = d_ex_erreur_sql; 1392: 1393: return; 1394: break; 1395: } 1396: } 1397: 1398: PQclear(resultat_postgresql); 1399: 1400: if (connexion_permanente == d_faux) 1401: { 1402: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet)) 1403: .descripteur.postgresql); 1404: } 1405: 1406: if (presence_resultat == d_vrai) 1407: { 1408: if (empilement(s_etat_processus, &((*s_etat_processus) 1409: .l_base_pile), s_objet_resultat) == d_erreur) 1410: { 1411: return; 1412: } 1413: } 1414: 1415: # else 1416: 1417: if ((*s_etat_processus).langue == 'F') 1418: { 1419: printf("+++Attention : Support de PostgreSQL non compilé !\n"); 1420: } 1421: else 1422: { 1423: printf("+++Warning : PostgreSQL support not available !\n"); 1424: } 1425: 1426: fflush(stdout); 1427: # endif 1428: } 1429: else 1430: { 1431: liberation(s_etat_processus, s_objet_1); 1432: liberation(s_etat_processus, s_objet_2); 1433: 1434: (*s_etat_processus).erreur_execution = d_ex_erreur_sql; 1435: return; 1436: } 1437: } 1438: else 1439: { 1440: liberation(s_etat_processus, s_objet_1); 1441: liberation(s_etat_processus, s_objet_2); 1442: 1443: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1444: return; 1445: } 1446: 1447: liberation(s_etat_processus, s_objet_1); 1448: liberation(s_etat_processus, s_objet_2); 1449: 1450: return; 1451: } 1452: 1453: 1454: /* 1455: ================================================================================ 1456: Fonction 'stop' 1457: ================================================================================ 1458: Entrées : 1459: -------------------------------------------------------------------------------- 1460: Sorties : 1461: -------------------------------------------------------------------------------- 1462: Effets de bord : néant 1463: ================================================================================ 1464: */ 1465: 1466: void 1467: instruction_stop(struct_processus *s_etat_processus) 1468: { 1469: struct_liste_chainee *l_element_courant; 1470: 1471: struct_objet *s_objet; 1472: 1473: struct timespec attente; 1474: 1475: attente.tv_sec = 0; 1476: attente.tv_nsec = GRANULARITE_us * 1000; 1477: 1478: (*s_etat_processus).erreur_execution = d_ex; 1479: 1480: if ((*s_etat_processus).affichage_arguments == 'Y') 1481: { 1482: printf("\n STOP "); 1483: 1484: if ((*s_etat_processus).langue == 'F') 1485: { 1486: printf("(arrêt d'un processus)\n\n"); 1487: } 1488: else 1489: { 1490: printf("(kill process)\n\n"); 1491: } 1492: 1493: printf(" 1: %s\n", d_PRC); 1494: 1495: return; 1496: } 1497: else if ((*s_etat_processus).test_instruction == 'Y') 1498: { 1499: (*s_etat_processus).nombre_arguments = -1; 1500: return; 1501: } 1502: 1503: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1504: { 1505: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1506: { 1507: return; 1508: } 1509: } 1510: 1511: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1512: &s_objet) == d_erreur) 1513: { 1514: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1515: return; 1516: } 1517: 1518: if ((*s_objet).type == PRC) 1519: { 1520: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1521: .processus_detache == d_vrai) 1522: { 1523: kill((*(*((struct_processus_fils *) (*s_objet).objet)).thread).pid, 1524: SIGFSTOP); 1525: } 1526: else 1527: { 1528: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) 1529: { 1530: (*s_etat_processus).erreur_systeme = d_es_processus; 1531: return; 1532: } 1533: 1534: l_element_courant = (struct_liste_chainee *) 1535: (*s_etat_processus).l_base_pile_processus; 1536: 1537: while(l_element_courant != NULL) 1538: { 1539: if ((*(*((struct_processus_fils *) (*(*l_element_courant) 1540: .donnee).objet)).thread).processus_detache == d_faux) 1541: { 1542: if ((pthread_equal((*(*((struct_processus_fils *) 1543: (*(*l_element_courant).donnee).objet)).thread).tid, 1544: (*(*((struct_processus_fils *) 1545: (*s_objet).objet)).thread).tid) != 0) && 1546: ((*(*((struct_processus_fils *) 1547: (*(*l_element_courant).donnee).objet)).thread).pid 1548: == (*(*((struct_processus_fils *) 1549: (*s_objet).objet)).thread).pid)) 1550: { 1551: break; 1552: } 1553: } 1554: 1555: l_element_courant = (*l_element_courant).suivant; 1556: } 1557: 1558: if (l_element_courant != NULL) 1559: { 1560: // Le champ thread_actif est un pointeur sur un champ de la 1561: // structure s_argument_thread libéré par la fonction 1562: // retrait_thread_surveillance(). 1563: 1564: if ((*(*((struct_processus_fils *) 1565: (*s_objet).objet)).thread).thread_actif == d_vrai) 1566: { 1567: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 1568: (*s_objet).objet)).thread).mutex)) != 0) 1569: { 1570: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) 1571: != 0) 1572: { 1573: (*s_etat_processus).erreur_systeme = d_es_processus; 1574: return; 1575: } 1576: 1577: (*s_etat_processus).erreur_systeme = d_es_processus; 1578: return; 1579: } 1580: 1581: if ((*(*((struct_processus_fils *) 1582: (*s_objet).objet)).thread).thread_actif == d_vrai) 1583: { 1584: pthread_kill((*(*((struct_processus_fils *) 1585: (*s_objet).objet)).thread).tid, SIGFSTOP); 1586: } 1587: 1588: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 1589: (*s_objet).objet)).thread).mutex)) != 0) 1590: { 1591: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) 1592: != 0) 1593: { 1594: (*s_etat_processus).erreur_systeme = d_es_processus; 1595: return; 1596: } 1597: 1598: (*s_etat_processus).erreur_systeme = d_es_processus; 1599: return; 1600: } 1601: } 1602: } 1603: 1604: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 1605: { 1606: (*s_etat_processus).erreur_systeme = d_es_processus; 1607: return; 1608: } 1609: } 1610: } 1611: else 1612: { 1613: liberation(s_etat_processus, s_objet); 1614: 1615: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1616: return; 1617: } 1618: 1619: liberation(s_etat_processus, s_objet); 1620: 1621: return; 1622: } 1623: 1624: // vim: ts=4