![]() ![]() | ![]() |
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 'protect' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_protect(struct_processus *s_etat_processus) 40: { 41: struct_liste_chainee *l_element_courant; 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 PROTECT "); 50: 51: if ((*s_etat_processus).langue == 'F') 52: { 53: printf("(verrouille une variable)\n\n"); 54: } 55: else 56: { 57: printf("(lock a variable)\n\n"); 58: } 59: 60: printf(" 1: %s, %s\n", d_NOM, d_LST); 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 == NOM) 86: { 87: if (recherche_variable(s_etat_processus, ((*((struct_nom *) 88: (*s_objet).objet)).nom)) == d_faux) 89: { 90: liberation(s_etat_processus, s_objet); 91: 92: (*s_etat_processus).erreur_systeme = d_es; 93: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 94: return; 95: } 96: 97: (*(*s_etat_processus).pointeur_variable_courante) 98: .variable_verrouillee = d_vrai; 99: } 100: else if ((*s_objet).type == LST) 101: { 102: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 103: 104: while(l_element_courant != NULL) 105: { 106: if ((*(*l_element_courant).donnee).type != NOM) 107: { 108: liberation(s_etat_processus, s_objet); 109: 110: (*s_etat_processus).erreur_execution = d_ex_nom_invalide; 111: return; 112: } 113: 114: if (recherche_variable(s_etat_processus, (*((struct_nom *) 115: (*(*l_element_courant).donnee).objet)).nom) == d_faux) 116: { 117: liberation(s_etat_processus, s_objet); 118: 119: (*s_etat_processus).erreur_systeme = d_es; 120: (*s_etat_processus).erreur_execution = 121: d_ex_variable_non_definie; 122: return; 123: } 124: 125: (*(*s_etat_processus).pointeur_variable_courante) 126: .variable_verrouillee = d_vrai; 127: 128: l_element_courant = (*l_element_courant).suivant; 129: } 130: } 131: else 132: { 133: liberation(s_etat_processus, s_objet); 134: 135: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 136: return; 137: } 138: 139: liberation(s_etat_processus, s_objet); 140: 141: return; 142: } 143: 144: 145: /* 146: ================================================================================ 147: Fonction 'parameter' 148: ================================================================================ 149: Entrées : 150: -------------------------------------------------------------------------------- 151: Sorties : 152: -------------------------------------------------------------------------------- 153: Effets de bord : néant 154: ================================================================================ 155: */ 156: 157: void 158: instruction_parameter(struct_processus *s_etat_processus) 159: { 160: struct_liste_chainee *l_element_courant; 161: 162: struct_objet *s_objet; 163: 164: (*s_etat_processus).erreur_execution = d_ex; 165: 166: if ((*s_etat_processus).affichage_arguments == 'Y') 167: { 168: printf("\n PARAMETER "); 169: 170: if ((*s_etat_processus).langue == 'F') 171: { 172: printf("(verrouille une variable globale)\n\n"); 173: } 174: else 175: { 176: printf("(lock a global variable)\n\n"); 177: } 178: 179: printf(" 1: %s, %s\n", d_NOM, d_LST); 180: 181: return; 182: } 183: else if ((*s_etat_processus).test_instruction == 'Y') 184: { 185: (*s_etat_processus).nombre_arguments = -1; 186: return; 187: } 188: 189: if (test_cfsf(s_etat_processus, 31) == d_vrai) 190: { 191: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 192: { 193: return; 194: } 195: } 196: 197: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 198: &s_objet) == d_erreur) 199: { 200: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 201: return; 202: } 203: 204: if ((*s_objet).type == NOM) 205: { 206: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *) 207: (*s_objet).objet)).nom)) == d_faux) 208: { 209: liberation(s_etat_processus, s_objet); 210: 211: (*s_etat_processus).erreur_systeme = d_es; 212: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 213: return; 214: } 215: 216: (*(*s_etat_processus).pointeur_variable_courante) 217: .variable_verrouillee = d_vrai; 218: } 219: else if ((*s_objet).type == LST) 220: { 221: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 222: 223: while(l_element_courant != NULL) 224: { 225: if ((*(*l_element_courant).donnee).type != NOM) 226: { 227: liberation(s_etat_processus, s_objet); 228: 229: (*s_etat_processus).erreur_execution = d_ex_nom_invalide; 230: return; 231: } 232: 233: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *) 234: (*(*l_element_courant).donnee).objet)).nom) == d_faux) 235: { 236: liberation(s_etat_processus, s_objet); 237: 238: (*s_etat_processus).erreur_systeme = d_es; 239: (*s_etat_processus).erreur_execution = 240: d_ex_variable_non_definie; 241: return; 242: } 243: 244: (*(*s_etat_processus).pointeur_variable_courante) 245: .variable_verrouillee = d_vrai; 246: 247: l_element_courant = (*l_element_courant).suivant; 248: } 249: } 250: else 251: { 252: liberation(s_etat_processus, s_objet); 253: 254: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 255: return; 256: } 257: 258: liberation(s_etat_processus, s_objet); 259: 260: return; 261: } 262: 263: 264: /* 265: ================================================================================ 266: Fonction 'pshcntxt' 267: ================================================================================ 268: Entrées : 269: -------------------------------------------------------------------------------- 270: Sorties : 271: -------------------------------------------------------------------------------- 272: Effets de bord : néant 273: ================================================================================ 274: */ 275: 276: void 277: instruction_pshcntxt(struct_processus *s_etat_processus) 278: { 279: struct_objet *s_objet; 280: 281: (*s_etat_processus).erreur_execution = d_ex; 282: 283: if ((*s_etat_processus).affichage_arguments == 'Y') 284: { 285: printf("\n PSHCNTXT "); 286: 287: if ((*s_etat_processus).langue == 'F') 288: { 289: printf("(sauvegarde de contexte)\n\n"); 290: printf(" Aucun argument\n"); 291: } 292: else 293: { 294: printf("(pushes context)\n\n"); 295: printf(" No argument\n"); 296: } 297: 298: return; 299: } 300: else if ((*s_etat_processus).test_instruction == 'Y') 301: { 302: (*s_etat_processus).nombre_arguments = -1; 303: return; 304: } 305: 306: if (test_cfsf(s_etat_processus, 31) == d_vrai) 307: { 308: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 309: { 310: return; 311: } 312: } 313: 314: if ((s_objet = allocation(s_etat_processus, LST)) == NULL) 315: { 316: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 317: return; 318: } 319: 320: (*s_objet).objet = (*s_etat_processus).l_base_pile; 321: 322: if (empilement(s_etat_processus, &((*s_etat_processus). 323: l_base_pile_contextes), s_objet) == d_erreur) 324: { 325: return; 326: } 327: 328: if ((s_objet = allocation(s_etat_processus, INT)) == NULL) 329: { 330: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 331: return; 332: } 333: 334: (*((integer8 *) (*s_objet).objet)) = (*s_etat_processus) 335: .hauteur_pile_operationnelle; 336: 337: if (empilement(s_etat_processus, &((*s_etat_processus) 338: .l_base_pile_taille_contextes), s_objet) == d_erreur) 339: { 340: return; 341: } 342: 343: /* 344: * Vidage de la pile opérationnelle 345: */ 346: 347: (*s_etat_processus).l_base_pile = NULL; 348: (*s_etat_processus).hauteur_pile_operationnelle = 0; 349: 350: return; 351: } 352: 353: 354: /* 355: ================================================================================ 356: Fonction 'pulcntxt' 357: ================================================================================ 358: Entrées : 359: -------------------------------------------------------------------------------- 360: Sorties : 361: -------------------------------------------------------------------------------- 362: Effets de bord : néant 363: ================================================================================ 364: */ 365: 366: void 367: instruction_pulcntxt(struct_processus *s_etat_processus) 368: { 369: struct_objet *s_objet; 370: 371: (*s_etat_processus).erreur_execution = d_ex; 372: 373: if ((*s_etat_processus).affichage_arguments == 'Y') 374: { 375: printf("\n PULCNTXT "); 376: 377: if ((*s_etat_processus).langue == 'F') 378: { 379: printf("(restauration de contexte)\n\n"); 380: printf(" Aucun argument\n"); 381: } 382: else 383: { 384: printf("(pulls context)\n\n"); 385: printf(" No argument\n"); 386: } 387: 388: return; 389: } 390: else if ((*s_etat_processus).test_instruction == 'Y') 391: { 392: (*s_etat_processus).nombre_arguments = -1; 393: return; 394: } 395: 396: if (test_cfsf(s_etat_processus, 31) == d_vrai) 397: { 398: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 399: { 400: return; 401: } 402: } 403: 404: if (((*s_etat_processus).l_base_pile_contextes == NULL) || 405: ((*s_etat_processus).l_base_pile_taille_contextes == NULL)) 406: { 407: (*s_etat_processus).erreur_execution = d_ex_contexte; 408: return; 409: } 410: 411: instruction_clear(s_etat_processus); 412: 413: if (depilement(s_etat_processus, &((*s_etat_processus) 414: .l_base_pile_contextes), &s_objet) == d_erreur) 415: { 416: return; 417: } 418: 419: if ((*s_objet).type != LST) 420: { 421: (*s_etat_processus).erreur_systeme = d_es_contexte; 422: return; 423: } 424: 425: (*s_etat_processus).l_base_pile = (*s_objet).objet; 426: 427: BUG((*s_objet).nombre_occurrences != 1, 428: printf("(*s_objet).nombre_occurrences=%ld\n", 429: (*s_objet).nombre_occurrences)); 430: free(s_objet); 431: 432: if (depilement(s_etat_processus, &((*s_etat_processus) 433: .l_base_pile_taille_contextes), &s_objet) == d_erreur) 434: { 435: return; 436: } 437: 438: if ((*s_objet).type != INT) 439: { 440: (*s_etat_processus).erreur_systeme = d_es_contexte; 441: return; 442: } 443: 444: if ((*((integer8 *) (*s_objet).objet)) < 0) 445: { 446: (*s_etat_processus).erreur_systeme = d_es_contexte; 447: return; 448: } 449: 450: (*s_etat_processus).hauteur_pile_operationnelle = 451: (*((integer8 *) (*s_objet).objet)); 452: liberation(s_etat_processus, s_objet); 453: 454: return; 455: } 456: 457: 458: /* 459: ================================================================================ 460: Fonction 'peek' 461: ================================================================================ 462: Entrées : 463: -------------------------------------------------------------------------------- 464: Sorties : 465: -------------------------------------------------------------------------------- 466: Effets de bord : néant 467: ================================================================================ 468: */ 469: 470: void 471: instruction_peek(struct_processus *s_etat_processus) 472: { 473: sig_atomic_t registre; 474: 475: struct_objet *s_objet; 476: struct_objet *s_objet_drapeau; 477: 478: (*s_etat_processus).erreur_execution = d_ex; 479: 480: if ((*s_etat_processus).affichage_arguments == 'Y') 481: { 482: printf("\n PEEK "); 483: 484: if ((*s_etat_processus).langue == 'F') 485: { 486: printf("(réception de données d'un processus père)\n\n"); 487: } 488: else 489: { 490: printf("(data reception from parent process)\n\n"); 491: } 492: 493: printf("-> 1: %s (0)\n\n", d_INT); 494: 495: printf("-> 2: %s, %s, %s, %s, %s, %s,\n" 496: " %s, %s, %s, %s, %s,\n" 497: " %s, %s, %s, %s\n", 498: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 499: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN); 500: printf(" 1: %s (-1)\n", d_INT); 501: 502: return; 503: } 504: else if ((*s_etat_processus).test_instruction == 'Y') 505: { 506: (*s_etat_processus).nombre_arguments = -1; 507: return; 508: } 509: 510: if (test_cfsf(s_etat_processus, 31) == d_vrai) 511: { 512: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 513: { 514: return; 515: } 516: } 517: 518: if ((*s_etat_processus).presence_pipes == d_faux) 519: { 520: (*s_etat_processus).erreur_execution = 521: d_ex_absence_processus_pere; 522: return; 523: } 524: 525: if ((s_objet_drapeau = allocation(s_etat_processus, INT)) == NULL) 526: { 527: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 528: return; 529: } 530: 531: if ((*s_etat_processus).nombre_objets_injectes > 0) 532: { 533: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop; 534: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1; 535: 536: if ((*s_etat_processus).profilage == d_vrai) 537: { 538: profilage(s_etat_processus, "Interprocess or interthread " 539: "communications (PEEK)"); 540: 541: if ((*s_etat_processus).erreur_systeme != d_es) 542: { 543: return; 544: } 545: } 546: 547: if ((s_objet = lecture_pipe(s_etat_processus, 548: (*s_etat_processus).pipe_injections)) == NULL) 549: { 550: if (registre == 0) 551: { 552: if ((*s_etat_processus).var_volatile_traitement_retarde_stop 553: == -1) 554: { 555: (*s_etat_processus).var_volatile_requete_arret = -1; 556: } 557: 558: (*s_etat_processus).var_volatile_traitement_retarde_stop 559: = registre; 560: } 561: 562: if ((*s_etat_processus).profilage == d_vrai) 563: { 564: profilage(s_etat_processus, NULL); 565: } 566: 567: return; 568: } 569: 570: if ((*s_etat_processus).profilage == d_vrai) 571: { 572: profilage(s_etat_processus, NULL); 573: } 574: 575: if (registre == 0) 576: { 577: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1) 578: { 579: (*s_etat_processus).var_volatile_requete_arret = -1; 580: } 581: 582: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre; 583: } 584: 585: (*s_etat_processus).nombre_objets_injectes--; 586: 587: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 588: s_objet) == d_erreur) 589: { 590: return; 591: } 592: 593: (*((integer8 *) (*s_objet_drapeau).objet)) = -1; 594: } 595: else 596: { 597: (*((integer8 *) (*s_objet_drapeau).objet)) = 0; 598: } 599: 600: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 601: s_objet_drapeau) == d_erreur) 602: { 603: return; 604: } 605: 606: return; 607: } 608: 609: 610: /* 611: ================================================================================ 612: Fonction 'poke' 613: ================================================================================ 614: Entrées : 615: -------------------------------------------------------------------------------- 616: Sorties : 617: -------------------------------------------------------------------------------- 618: Effets de bord : néant 619: ================================================================================ 620: */ 621: 622: void 623: instruction_poke(struct_processus *s_etat_processus) 624: { 625: sig_atomic_t registre_stop; 626: 627: ssize_t longueur_ecriture; 628: 629: struct sigaction action; 630: struct sigaction registre; 631: 632: struct_liste_chainee *l_element_courant; 633: 634: struct_objet *s_objet_argument_1; 635: struct_objet *s_objet_argument_2; 636: 637: (*s_etat_processus).erreur_execution = d_ex; 638: 639: if ((*s_etat_processus).affichage_arguments == 'Y') 640: { 641: printf("\n POKE "); 642: 643: if ((*s_etat_processus).langue == 'F') 644: { 645: printf("(envoi d'une donnée à un processus fils)\n\n"); 646: } 647: else 648: { 649: printf("(send data to child process)\n\n"); 650: } 651: 652: printf(" 2: %s, %s, %s, %s, %s, %s,\n" 653: " %s, %s, %s, %s, %s,\n" 654: " %s, %s, %s, %s, %s\n", 655: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 656: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB); 657: printf(" 1: %s\n", d_PRC); 658: 659: return; 660: } 661: else if ((*s_etat_processus).test_instruction == 'Y') 662: { 663: (*s_etat_processus).nombre_arguments = -1; 664: return; 665: } 666: 667: if (test_cfsf(s_etat_processus, 31) == d_vrai) 668: { 669: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 670: { 671: return; 672: } 673: } 674: 675: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 676: &s_objet_argument_1) == d_erreur) 677: { 678: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 679: return; 680: } 681: 682: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 683: &s_objet_argument_2) == d_erreur) 684: { 685: liberation(s_etat_processus, s_objet_argument_1); 686: 687: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 688: return; 689: } 690: 691: if ((*s_objet_argument_1).type == PRC) 692: { 693: /* 694: * Vérification du type de la donnée transmise 695: */ 696: 697: if (((*s_objet_argument_2).type != INT) && 698: ((*s_objet_argument_2).type != REL) && 699: ((*s_objet_argument_2).type != CPL) && 700: ((*s_objet_argument_2).type != VIN) && 701: ((*s_objet_argument_2).type != VRL) && 702: ((*s_objet_argument_2).type != VCX) && 703: ((*s_objet_argument_2).type != MIN) && 704: ((*s_objet_argument_2).type != MRL) && 705: ((*s_objet_argument_2).type != MCX) && 706: ((*s_objet_argument_2).type != BIN) && 707: ((*s_objet_argument_2).type != NOM) && 708: ((*s_objet_argument_2).type != CHN) && 709: ((*s_objet_argument_2).type != LST) && 710: ((*s_objet_argument_2).type != ALG) && 711: ((*s_objet_argument_2).type != RPN) && 712: ((*s_objet_argument_2).type != TBL)) 713: { 714: liberation(s_etat_processus, s_objet_argument_1); 715: liberation(s_etat_processus, s_objet_argument_2); 716: 717: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 718: return; 719: } 720: 721: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) 722: { 723: (*s_etat_processus).erreur_systeme = d_es_processus; 724: return; 725: } 726: 727: l_element_courant = (struct_liste_chainee *) 728: (*s_etat_processus).l_base_pile_processus; 729: 730: while(l_element_courant != NULL) 731: { 732: if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet)) 733: .thread).processus_detache == d_vrai) 734: { 735: if ((*(*((struct_processus_fils *) (*(*l_element_courant) 736: .donnee).objet)).thread).processus_detache == d_faux) 737: { 738: l_element_courant = (*l_element_courant).suivant; 739: continue; 740: } 741: 742: if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet)) 743: .thread).pid == (*(*((struct_processus_fils *) 744: (*(*l_element_courant).donnee).objet)).thread).pid) 745: { 746: // Envoi des données 747: // Attention : si le processus n'existe plus, il n'y a plus 748: // de lecteur et on peut se prendre un SIGPIPE dans la 749: // figure ! 750: 751: action.sa_handler = SIG_IGN; 752: action.sa_flags = SA_ONSTACK; 753: 754: if (sigaction(SIGPIPE, &action, ®istre) != 0) 755: { 756: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 757: 758: (*s_etat_processus).erreur_systeme = d_es_signal; 759: return; 760: } 761: 762: // Validation des données. On envoie un signal pour 763: // débloquer les instructions de type WF* pour les 764: // lectures bloquantes. 765: 766: if (kill((*(*((struct_processus_fils *) 767: (*(*l_element_courant).donnee).objet)) 768: .thread).pid, SIGINJECT) != 0) 769: { 770: // Le processus fils peut s'être terminé. 771: break; 772: } 773: 774: registre_stop = (*s_etat_processus) 775: .var_volatile_traitement_retarde_stop; 776: (*s_etat_processus).var_volatile_traitement_retarde_stop 777: = 1; 778: 779: if ((*s_etat_processus).profilage == d_vrai) 780: { 781: profilage(s_etat_processus, 782: "Interprocess communications (POKE)"); 783: 784: if ((*s_etat_processus).erreur_systeme != d_es) 785: { 786: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 787: return; 788: } 789: } 790: 791: # ifndef SEMAPHORES_NOMMES 792: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 793: { 794: (*s_etat_processus).erreur_systeme = d_es_processus; 795: return; 796: } 797: # else 798: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 799: { 800: (*s_etat_processus).erreur_systeme = d_es_processus; 801: return; 802: } 803: # endif 804: 805: while((longueur_ecriture = write_atomic(s_etat_processus, 806: (*(*((struct_processus_fils *) 807: (*(*l_element_courant).donnee).objet)).thread) 808: .pipe_nombre_injections[1], "-", 809: sizeof(unsigned char))) != sizeof(unsigned char)) 810: { 811: # ifndef SEMAPHORES_NOMMES 812: while(sem_wait(&((*s_etat_processus) 813: .semaphore_fork)) == -1) 814: # else 815: while(sem_wait((*s_etat_processus) 816: .semaphore_fork) == -1) 817: # endif 818: { 819: if (errno != EINTR) 820: { 821: (*s_etat_processus).erreur_systeme = 822: d_es_processus; 823: return; 824: } 825: } 826: 827: if (longueur_ecriture == -1) 828: { 829: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 830: 831: liberation(s_etat_processus, s_objet_argument_1); 832: liberation(s_etat_processus, s_objet_argument_2); 833: 834: if (registre_stop == 0) 835: { 836: if ((*s_etat_processus) 837: .var_volatile_traitement_retarde_stop 838: == -1) 839: { 840: (*s_etat_processus) 841: .var_volatile_requete_arret = -1; 842: } 843: 844: (*s_etat_processus) 845: .var_volatile_traitement_retarde_stop 846: = registre_stop; 847: } 848: 849: if ((*s_etat_processus).profilage == d_vrai) 850: { 851: profilage(s_etat_processus, NULL); 852: } 853: 854: if (sigaction(SIGPIPE, ®istre, NULL) != 0) 855: { 856: (*s_etat_processus).erreur_systeme = 857: d_es_signal; 858: return; 859: } 860: 861: return; 862: } 863: 864: # ifndef SEMAPHORES_NOMMES 865: if (sem_post(&((*s_etat_processus) 866: .semaphore_fork)) != 0) 867: # else 868: if (sem_post((*s_etat_processus) 869: .semaphore_fork) != 0) 870: # endif 871: { 872: (*s_etat_processus).erreur_systeme = d_es_processus; 873: return; 874: } 875: } 876: 877: if (ecriture_pipe(s_etat_processus, 878: (*(*((struct_processus_fils *) 879: (*(*l_element_courant).donnee).objet)).thread) 880: .pipe_injections[1], s_objet_argument_2) 881: == d_erreur) 882: { 883: // Le processus fils peut s'être terminé. 884: 885: if ((*s_etat_processus).erreur_systeme != d_es) 886: { 887: (*s_etat_processus).erreur_systeme = d_es; 888: } 889: } 890: 891: # ifndef SEMAPHORES_NOMMES 892: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 893: # else 894: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 895: # endif 896: { 897: if (errno == EINTR) 898: { 899: (*s_etat_processus).erreur_systeme = d_es_processus; 900: return; 901: } 902: } 903: 904: if (registre_stop == 0) 905: { 906: if ((*s_etat_processus) 907: .var_volatile_traitement_retarde_stop 908: == -1) 909: { 910: (*s_etat_processus).var_volatile_requete_arret = -1; 911: } 912: 913: (*s_etat_processus).var_volatile_traitement_retarde_stop 914: = registre_stop; 915: } 916: 917: if ((*s_etat_processus).profilage == d_vrai) 918: { 919: profilage(s_etat_processus, NULL); 920: } 921: 922: if (sigaction(SIGPIPE, ®istre, NULL) != 0) 923: { 924: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 925: 926: (*s_etat_processus).erreur_systeme = d_es_signal; 927: return; 928: } 929: 930: break; 931: } 932: } 933: else 934: { 935: if ((*(*((struct_processus_fils *) (*(*l_element_courant) 936: .donnee).objet)).thread).processus_detache == d_vrai) 937: { 938: l_element_courant = (*l_element_courant).suivant; 939: continue; 940: } 941: 942: if (((pthread_equal((*(*((struct_processus_fils *) 943: (*s_objet_argument_1).objet)).thread).tid, 944: (*(*((struct_processus_fils *) 945: (*(*l_element_courant).donnee).objet)).thread).tid) 946: != 0)) && ((*(*((struct_processus_fils *) 947: (*s_objet_argument_1).objet)).thread).pid == 948: (*(*((struct_processus_fils *) 949: (*(*l_element_courant).donnee).objet)).thread).pid)) 950: { 951: // Envoi des données 952: // Attention : si le processus n'existe plus, il n'y a plus 953: // de lecteur et on peut se prendre un SIGPIPE dans la 954: // figure ! 955: 956: action.sa_handler = SIG_IGN; 957: action.sa_flags = SA_ONSTACK; 958: 959: if (sigaction(SIGPIPE, &action, ®istre) != 0) 960: { 961: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 962: 963: (*s_etat_processus).erreur_systeme = d_es_signal; 964: return; 965: } 966: 967: // Validation des données. On envoie un signal pour 968: // débloquer les instructions de type WF* pour les 969: // lectures bloquantes. 970: 971: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 972: (*(*l_element_courant).donnee).objet)).thread) 973: .mutex)) != 0) 974: { 975: (*s_etat_processus).erreur_systeme = d_es_processus; 976: return; 977: } 978: 979: if ((*(*((struct_processus_fils *) 980: (*(*l_element_courant).donnee).objet)).thread) 981: .thread_actif == d_vrai) 982: { 983: if (pthread_kill((*(*((struct_processus_fils *) 984: (*(*l_element_courant).donnee).objet)).thread) 985: .tid, SIGINJECT) != 0) 986: { 987: // Le processus fils peut s'être terminé. 988: 989: if (pthread_mutex_unlock( 990: &((*(*((struct_processus_fils *) 991: (*(*l_element_courant).donnee).objet)) 992: .thread).mutex)) != 0) 993: { 994: (*s_etat_processus).erreur_systeme = 995: d_es_processus; 996: return; 997: } 998: 999: break; 1000: } 1001: } 1002: else 1003: { 1004: if (pthread_mutex_unlock( 1005: &((*(*((struct_processus_fils *) 1006: (*(*l_element_courant).donnee).objet)) 1007: .thread).mutex)) != 0) 1008: { 1009: (*s_etat_processus).erreur_systeme = d_es_processus; 1010: return; 1011: } 1012: 1013: break; 1014: } 1015: 1016: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 1017: (*(*l_element_courant).donnee).objet)).thread) 1018: .mutex)) != 0) 1019: { 1020: (*s_etat_processus).erreur_systeme = d_es_processus; 1021: return; 1022: } 1023: 1024: registre_stop = (*s_etat_processus) 1025: .var_volatile_traitement_retarde_stop; 1026: (*s_etat_processus).var_volatile_traitement_retarde_stop 1027: = 1; 1028: 1029: if ((*s_etat_processus).profilage == d_vrai) 1030: { 1031: profilage(s_etat_processus, 1032: "Interthread communications (POKE)"); 1033: 1034: if ((*s_etat_processus).erreur_systeme != d_es) 1035: { 1036: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 1037: return; 1038: } 1039: } 1040: 1041: # ifndef SEMAPHORES_NOMMES 1042: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 1043: # else 1044: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 1045: # endif 1046: { 1047: (*s_etat_processus).erreur_systeme = d_es_processus; 1048: return; 1049: } 1050: 1051: while((longueur_ecriture = write_atomic(s_etat_processus, 1052: (*(*((struct_processus_fils *) 1053: (*(*l_element_courant).donnee).objet)).thread) 1054: .pipe_nombre_injections[1], "-", 1055: sizeof(unsigned char))) != sizeof(unsigned char)) 1056: { 1057: # ifndef SEMAPHORES_NOMMES 1058: while(sem_wait(&((*s_etat_processus) 1059: .semaphore_fork)) == -1) 1060: # else 1061: while(sem_wait((*s_etat_processus) 1062: .semaphore_fork) == -1) 1063: # endif 1064: { 1065: if (errno != EINTR) 1066: { 1067: (*s_etat_processus).erreur_systeme = 1068: d_es_processus; 1069: return; 1070: } 1071: } 1072: 1073: if (longueur_ecriture == -1) 1074: { 1075: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 1076: 1077: liberation(s_etat_processus, s_objet_argument_1); 1078: liberation(s_etat_processus, s_objet_argument_2); 1079: 1080: if (registre_stop == 0) 1081: { 1082: if ((*s_etat_processus) 1083: .var_volatile_traitement_retarde_stop 1084: == -1) 1085: { 1086: (*s_etat_processus) 1087: .var_volatile_requete_arret = -1; 1088: } 1089: 1090: (*s_etat_processus) 1091: .var_volatile_traitement_retarde_stop 1092: = registre_stop; 1093: } 1094: 1095: if ((*s_etat_processus).profilage == d_vrai) 1096: { 1097: profilage(s_etat_processus, NULL); 1098: } 1099: 1100: if (sigaction(SIGPIPE, ®istre, NULL) != 0) 1101: { 1102: (*s_etat_processus).erreur_systeme = 1103: d_es_signal; 1104: return; 1105: } 1106: 1107: return; 1108: } 1109: 1110: # ifndef SEMAPHORES_NOMMES 1111: if (sem_post(&((*s_etat_processus) 1112: .semaphore_fork)) != 0) 1113: # else 1114: if (sem_post((*s_etat_processus) 1115: .semaphore_fork) != 0) 1116: # endif 1117: { 1118: (*s_etat_processus).erreur_systeme = d_es_processus; 1119: return; 1120: } 1121: } 1122: 1123: if (ecriture_pipe(s_etat_processus, 1124: (*(*((struct_processus_fils *) 1125: (*(*l_element_courant).donnee).objet)).thread) 1126: .pipe_injections[1], s_objet_argument_2) 1127: == d_erreur) 1128: { 1129: // Le processus fils peut s'être terminé. 1130: 1131: if ((*s_etat_processus).erreur_systeme != d_es) 1132: { 1133: (*s_etat_processus).erreur_systeme = d_es; 1134: } 1135: } 1136: 1137: # ifndef SEMAPHORES_NOMMES 1138: while(sem_wait(&((*s_etat_processus) 1139: .semaphore_fork)) == -1) 1140: # else 1141: while(sem_wait((*s_etat_processus) 1142: .semaphore_fork) == -1) 1143: # endif 1144: { 1145: if (errno != EINTR) 1146: { 1147: (*s_etat_processus).erreur_systeme = d_es_processus; 1148: return; 1149: } 1150: } 1151: 1152: if (registre_stop == 0) 1153: { 1154: if ((*s_etat_processus) 1155: .var_volatile_traitement_retarde_stop 1156: == -1) 1157: { 1158: (*s_etat_processus).var_volatile_requete_arret = -1; 1159: } 1160: 1161: (*s_etat_processus).var_volatile_traitement_retarde_stop 1162: = registre_stop; 1163: } 1164: 1165: if ((*s_etat_processus).profilage == d_vrai) 1166: { 1167: profilage(s_etat_processus, NULL); 1168: } 1169: 1170: if (sigaction(SIGPIPE, ®istre, NULL) != 0) 1171: { 1172: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 1173: 1174: (*s_etat_processus).erreur_systeme = d_es_signal; 1175: return; 1176: } 1177: 1178: break; 1179: } 1180: } 1181: 1182: l_element_courant = (*l_element_courant).suivant; 1183: } 1184: 1185: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 1186: { 1187: (*s_etat_processus).erreur_systeme = d_es_processus; 1188: return; 1189: } 1190: 1191: if (l_element_courant == NULL) 1192: { 1193: liberation(s_etat_processus, s_objet_argument_1); 1194: liberation(s_etat_processus, s_objet_argument_2); 1195: 1196: (*s_etat_processus).erreur_execution = d_ex_processus; 1197: return; 1198: } 1199: } 1200: else 1201: { 1202: liberation(s_etat_processus, s_objet_argument_1); 1203: liberation(s_etat_processus, s_objet_argument_2); 1204: 1205: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1206: return; 1207: } 1208: 1209: liberation(s_etat_processus, s_objet_argument_1); 1210: liberation(s_etat_processus, s_objet_argument_2); 1211: 1212: return; 1213: } 1214: 1215: 1216: /* 1217: ================================================================================ 1218: Fonction 'private' 1219: ================================================================================ 1220: Entrées : 1221: -------------------------------------------------------------------------------- 1222: Sorties : 1223: -------------------------------------------------------------------------------- 1224: Effets de bord : néant 1225: ================================================================================ 1226: */ 1227: 1228: void 1229: instruction_private(struct_processus *s_etat_processus) 1230: { 1231: struct_liste_chainee *l_element_courant; 1232: 1233: struct_objet *s_objet; 1234: 1235: (*s_etat_processus).erreur_execution = d_ex; 1236: 1237: if ((*s_etat_processus).affichage_arguments == 'Y') 1238: { 1239: printf("\n PRIVATE "); 1240: 1241: if ((*s_etat_processus).langue == 'F') 1242: { 1243: printf("(rend privée une variable partagée)\n\n"); 1244: } 1245: else 1246: { 1247: printf("(switch a shared variable to private one)\n\n"); 1248: } 1249: 1250: printf(" 1: %s, %s\n", d_NOM, d_LST); 1251: 1252: return; 1253: } 1254: else if ((*s_etat_processus).test_instruction == 'Y') 1255: { 1256: (*s_etat_processus).nombre_arguments = -1; 1257: return; 1258: } 1259: 1260: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1261: { 1262: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1263: { 1264: return; 1265: } 1266: } 1267: 1268: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1269: &s_objet) == d_erreur) 1270: { 1271: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1272: return; 1273: } 1274: 1275: if ((*s_objet).type == NOM) 1276: { 1277: if (recherche_variable(s_etat_processus, ((*((struct_nom *) 1278: (*s_objet).objet)).nom)) == d_faux) 1279: { 1280: liberation(s_etat_processus, s_objet); 1281: 1282: (*s_etat_processus).erreur_systeme = d_es; 1283: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 1284: return; 1285: } 1286: 1287: if (pthread_mutex_lock(&((*(*s_etat_processus) 1288: .s_liste_variables_partagees).mutex)) != 0) 1289: { 1290: (*s_etat_processus).erreur_systeme = d_es_processus; 1291: return; 1292: } 1293: 1294: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *) 1295: (*s_objet).objet)).nom), (*(*s_etat_processus) 1296: .pointeur_variable_courante).variable_partagee, 1297: (*(*s_etat_processus).pointeur_variable_courante).origine) 1298: == d_faux) 1299: { 1300: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1301: .s_liste_variables_partagees).mutex)) != 0) 1302: { 1303: (*s_etat_processus).erreur_systeme = d_es_processus; 1304: return; 1305: } 1306: 1307: liberation(s_etat_processus, s_objet); 1308: 1309: (*s_etat_processus).erreur_systeme = d_es; 1310: return; 1311: } 1312: 1313: (*(*s_etat_processus).pointeur_variable_courante).objet = 1314: (*(*s_etat_processus).s_liste_variables_partagees).table 1315: [(*(*s_etat_processus).s_liste_variables_partagees) 1316: .position_variable].objet; 1317: (*(*s_etat_processus).s_liste_variables_partagees).table 1318: [(*(*s_etat_processus).s_liste_variables_partagees) 1319: .position_variable].objet = NULL; 1320: 1321: if (retrait_variable_partagee(s_etat_processus, 1322: (*((struct_nom *) (*s_objet).objet)).nom, 1323: (*(*s_etat_processus).pointeur_variable_courante) 1324: .variable_partagee) == d_erreur) 1325: { 1326: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1327: .s_liste_variables_partagees).mutex)) != 0) 1328: { 1329: (*s_etat_processus).erreur_systeme = d_es_processus; 1330: return; 1331: } 1332: 1333: liberation(s_etat_processus, s_objet); 1334: return; 1335: } 1336: 1337: if ((*(*s_etat_processus).pointeur_variable_courante).origine == 'P') 1338: { 1339: (*(*s_etat_processus).pointeur_variable_courante) 1340: .variable_partagee.adresse = 0; 1341: } 1342: else 1343: { 1344: (*(*s_etat_processus).pointeur_variable_courante) 1345: .variable_partagee.pointeur = NULL; 1346: } 1347: 1348: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1349: .s_liste_variables_partagees).mutex)) != 0) 1350: { 1351: (*s_etat_processus).erreur_systeme = d_es_processus; 1352: return; 1353: } 1354: } 1355: else if ((*s_objet).type == LST) 1356: { 1357: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 1358: 1359: while(l_element_courant != NULL) 1360: { 1361: if ((*(*l_element_courant).donnee).type != NOM) 1362: { 1363: liberation(s_etat_processus, s_objet); 1364: 1365: (*s_etat_processus).erreur_execution = d_ex_nom_invalide; 1366: return; 1367: } 1368: 1369: if (recherche_variable(s_etat_processus, ((*((struct_nom *) 1370: (*s_objet).objet)).nom)) == d_faux) 1371: { 1372: liberation(s_etat_processus, s_objet); 1373: 1374: (*s_etat_processus).erreur_systeme = d_es; 1375: (*s_etat_processus).erreur_execution = 1376: d_ex_variable_non_definie; 1377: return; 1378: } 1379: 1380: if (pthread_mutex_lock(&((*(*s_etat_processus) 1381: .s_liste_variables_partagees).mutex)) != 0) 1382: { 1383: (*s_etat_processus).erreur_systeme = d_es_processus; 1384: return; 1385: } 1386: 1387: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *) 1388: (*s_objet).objet)).nom), (*(*s_etat_processus) 1389: .pointeur_variable_courante).variable_partagee, 1390: (*(*s_etat_processus).pointeur_variable_courante).origine) 1391: == d_faux) 1392: { 1393: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1394: .s_liste_variables_partagees).mutex)) != 0) 1395: { 1396: (*s_etat_processus).erreur_systeme = d_es_processus; 1397: return; 1398: } 1399: 1400: liberation(s_etat_processus, s_objet); 1401: 1402: (*s_etat_processus).erreur_systeme = d_es; 1403: (*s_etat_processus).erreur_execution = 1404: d_ex_variable_non_definie; 1405: return; 1406: } 1407: 1408: (*(*s_etat_processus).pointeur_variable_courante).objet = 1409: (*(*s_etat_processus).s_liste_variables_partagees).table 1410: [(*(*s_etat_processus).s_liste_variables_partagees) 1411: .position_variable].objet; 1412: (*(*s_etat_processus).s_liste_variables_partagees).table 1413: [(*(*s_etat_processus).s_liste_variables_partagees) 1414: .position_variable].objet = NULL; 1415: 1416: if ((*(*s_etat_processus).pointeur_variable_courante).origine 1417: == 'P') 1418: { 1419: (*(*s_etat_processus).pointeur_variable_courante) 1420: .variable_partagee.adresse = 0; 1421: } 1422: else 1423: { 1424: (*(*s_etat_processus).pointeur_variable_courante) 1425: .variable_partagee.pointeur = NULL; 1426: } 1427: 1428: if (retrait_variable_partagee(s_etat_processus, 1429: (*((struct_nom *) (*s_objet).objet)).nom, 1430: (*(*s_etat_processus).pointeur_variable_courante) 1431: .variable_statique) == d_erreur) 1432: { 1433: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1434: .s_liste_variables_partagees).mutex)) != 0) 1435: { 1436: (*s_etat_processus).erreur_systeme = d_es_processus; 1437: return; 1438: } 1439: 1440: liberation(s_etat_processus, s_objet); 1441: return; 1442: } 1443: 1444: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1445: .s_liste_variables_partagees).mutex)) != 0) 1446: { 1447: (*s_etat_processus).erreur_systeme = d_es_processus; 1448: return; 1449: } 1450: 1451: l_element_courant = (*l_element_courant).suivant; 1452: } 1453: } 1454: else 1455: { 1456: liberation(s_etat_processus, s_objet); 1457: 1458: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1459: return; 1460: } 1461: 1462: liberation(s_etat_processus, s_objet); 1463: 1464: return; 1465: } 1466: 1467: 1468: /* 1469: ================================================================================ 1470: Fonction 'pshprfl' 1471: ================================================================================ 1472: Entrées : pointeur sur une structure struct_processus 1473: -------------------------------------------------------------------------------- 1474: Sorties : 1475: -------------------------------------------------------------------------------- 1476: Effets de bord : néant 1477: ================================================================================ 1478: */ 1479: 1480: void 1481: instruction_pshprfl(struct_processus *s_etat_processus) 1482: { 1483: struct_objet *s_objet_argument; 1484: 1485: (*s_etat_processus).erreur_execution = d_ex; 1486: 1487: if ((*s_etat_processus).affichage_arguments == 'Y') 1488: { 1489: printf("\n PSHPRFL "); 1490: 1491: if ((*s_etat_processus).langue == 'F') 1492: { 1493: printf("(empilement d'un point de profilage)\n\n"); 1494: } 1495: else 1496: { 1497: printf("(push profile data)\n\n"); 1498: } 1499: 1500: printf(" 1: %s\n", d_CHN); 1501: 1502: return; 1503: } 1504: else if ((*s_etat_processus).test_instruction == 'Y') 1505: { 1506: (*s_etat_processus).nombre_arguments = -1; 1507: return; 1508: } 1509: 1510: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1511: { 1512: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1513: { 1514: return; 1515: } 1516: } 1517: 1518: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1519: &s_objet_argument) == d_erreur) 1520: { 1521: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1522: return; 1523: } 1524: 1525: if ((*s_objet_argument).type == CHN) 1526: { 1527: if ((*s_etat_processus).profilage == d_vrai) 1528: { 1529: profilage(s_etat_processus, (unsigned char *) 1530: (*s_objet_argument).objet); 1531: } 1532: } 1533: else 1534: { 1535: liberation(s_etat_processus, s_objet_argument); 1536: 1537: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1538: return; 1539: } 1540: 1541: liberation(s_etat_processus, s_objet_argument); 1542: 1543: return; 1544: } 1545: 1546: 1547: /* 1548: ================================================================================ 1549: Fonction 'pulprfl' 1550: ================================================================================ 1551: Entrées : pointeur sur une structure struct_processus 1552: -------------------------------------------------------------------------------- 1553: Sorties : 1554: -------------------------------------------------------------------------------- 1555: Effets de bord : néant 1556: ================================================================================ 1557: */ 1558: 1559: void 1560: instruction_pulprfl(struct_processus *s_etat_processus) 1561: { 1562: (*s_etat_processus).erreur_execution = d_ex; 1563: 1564: if ((*s_etat_processus).affichage_arguments == 'Y') 1565: { 1566: printf("\n PULPRFL "); 1567: 1568: if ((*s_etat_processus).langue == 'F') 1569: { 1570: printf("(dépilement d'un point de profilage)\n\n"); 1571: printf(" Aucun argument\n"); 1572: } 1573: else 1574: { 1575: printf("(pull profile data)\n\n"); 1576: printf(" No argument\n"); 1577: } 1578: 1579: return; 1580: } 1581: else if ((*s_etat_processus).test_instruction == 'Y') 1582: { 1583: (*s_etat_processus).nombre_arguments = -1; 1584: return; 1585: } 1586: 1587: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1588: { 1589: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1590: { 1591: return; 1592: } 1593: } 1594: 1595: if ((*s_etat_processus).profilage == d_vrai) 1596: { 1597: profilage(s_etat_processus, NULL); 1598: } 1599: 1600: return; 1601: } 1602: 1603: 1604: /* 1605: ================================================================================ 1606: Fonction 'plot' 1607: ================================================================================ 1608: Entrées : pointeur sur une structure struct_processus 1609: -------------------------------------------------------------------------------- 1610: Sorties : 1611: -------------------------------------------------------------------------------- 1612: Effets de bord : néant 1613: ================================================================================ 1614: */ 1615: 1616: void 1617: instruction_plot(struct_processus *s_etat_processus) 1618: { 1619: (*s_etat_processus).erreur_execution = d_ex; 1620: 1621: if ((*s_etat_processus).affichage_arguments == 'Y') 1622: { 1623: printf("\n PLOT "); 1624: 1625: if ((*s_etat_processus).langue == 'F') 1626: { 1627: printf("(affiche les données graphiques mémorisées)\n\n"); 1628: printf(" Aucun argument\n"); 1629: } 1630: else 1631: { 1632: printf("(plot buffered graphic)\n\n"); 1633: printf(" No argument\n"); 1634: } 1635: 1636: return; 1637: } 1638: else if ((*s_etat_processus).test_instruction == 'Y') 1639: { 1640: (*s_etat_processus).nombre_arguments = -1; 1641: return; 1642: } 1643: 1644: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1645: { 1646: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1647: { 1648: return; 1649: } 1650: } 1651: 1652: if ((*s_etat_processus).fichiers_graphiques != NULL) 1653: { 1654: appel_gnuplot(s_etat_processus, 'N'); 1655: } 1656: 1657: (*s_etat_processus).mise_a_jour_trace_requise = d_faux; 1658: 1659: return; 1660: } 1661: 1662: 1663: /* 1664: ================================================================================ 1665: Fonction 'procid' 1666: ================================================================================ 1667: Entrées : pointeur sur une structure struct_processus 1668: -------------------------------------------------------------------------------- 1669: Sorties : 1670: -------------------------------------------------------------------------------- 1671: Effets de bord : néant 1672: ================================================================================ 1673: */ 1674: 1675: void 1676: instruction_procid(struct_processus *s_etat_processus) 1677: { 1678: pthread_mutexattr_t attributs_mutex; 1679: 1680: struct_objet *s_objet; 1681: 1682: (*s_etat_processus).erreur_execution = d_ex; 1683: 1684: if ((*s_etat_processus).affichage_arguments == 'Y') 1685: { 1686: printf("\n PROCID "); 1687: 1688: if ((*s_etat_processus).langue == 'F') 1689: { 1690: printf("(identifiant du processus)\n\n"); 1691: } 1692: else 1693: { 1694: printf("(process identifier)\n\n"); 1695: } 1696: 1697: printf("-> 1: %s\n", d_PRC); 1698: 1699: return; 1700: } 1701: else if ((*s_etat_processus).test_instruction == 'Y') 1702: { 1703: (*s_etat_processus).nombre_arguments = -1; 1704: return; 1705: } 1706: 1707: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1708: { 1709: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1710: { 1711: return; 1712: } 1713: } 1714: 1715: if ((s_objet = allocation(s_etat_processus, PRC)) == NULL) 1716: { 1717: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1718: return; 1719: } 1720: 1721: if (((*((struct_processus_fils *) (*s_objet).objet)).thread = 1722: malloc(sizeof(struct_descripteur_thread))) == NULL) 1723: { 1724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1725: return; 1726: } 1727: 1728: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1729: .nombre_references = 1; 1730: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1731: .pid = getpid(); 1732: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1733: .tid = pthread_self(); 1734: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1735: .processus_detache = (*s_etat_processus).processus_detache; 1736: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 1737: .argument = NULL; 1738: 1739: pthread_mutexattr_init(&attributs_mutex); 1740: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); 1741: pthread_mutex_init(&((*(*((struct_processus_fils *) 1742: (*s_objet).objet)).thread).mutex), &attributs_mutex); 1743: pthread_mutexattr_destroy(&attributs_mutex); 1744: 1745: pthread_mutexattr_init(&attributs_mutex); 1746: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); 1747: pthread_mutex_init(&((*(*((struct_processus_fils *) 1748: (*s_objet).objet)).thread).mutex_nombre_references), 1749: &attributs_mutex); 1750: pthread_mutexattr_destroy(&attributs_mutex); 1751: 1752: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1753: s_objet) == d_erreur) 1754: { 1755: return; 1756: } 1757: 1758: return; 1759: } 1760: 1761: // vim: ts=4