Annotation of rpl/src/instructions_s8.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
! 5:
! 6: This file is part of RPL/2.
! 7:
! 8: RPL/2 is free software; you can redistribute it and/or modify it
! 9: under the terms of the CeCILL V2 License as published by the french
! 10: CEA, CNRS and INRIA.
! 11:
! 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
! 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
! 15: for more details.
! 16:
! 17: You should have received a copy of the CeCILL License
! 18: along with RPL/2. If not, write to info@cecill.info.
! 19: ================================================================================
! 20: */
! 21:
! 22:
! 23: #include "rpl.conv.h"
! 24:
! 25:
! 26: /*
! 27: ================================================================================
! 28: Fonction '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: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 251: {
! 252: (*s_etat_processus).erreur_systeme = d_es_processus;
! 253: return;
! 254: }
! 255:
! 256: while((longueur_ecriture = write_atomic(s_etat_processus,
! 257: (*s_etat_processus).pipe_nombre_objets_attente,
! 258: &pid, sizeof(pid))) != sizeof(pid))
! 259: {
! 260: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 261: {
! 262: if (errno != EINTR)
! 263: {
! 264: (*s_etat_processus).erreur_systeme = d_es_processus;
! 265: return;
! 266: }
! 267: }
! 268:
! 269: if (longueur_ecriture == -1)
! 270: {
! 271: if ((*s_etat_processus).profilage == d_vrai)
! 272: {
! 273: profilage(s_etat_processus, NULL);
! 274: }
! 275:
! 276: (*s_etat_processus).erreur_systeme = d_es_processus;
! 277: return;
! 278: }
! 279:
! 280: nanosleep(&attente, NULL);
! 281: INCR_GRANULARITE(attente.tv_nsec);
! 282:
! 283: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 284: {
! 285: (*s_etat_processus).erreur_systeme = d_es_processus;
! 286: return;
! 287: }
! 288: }
! 289:
! 290: pid = getpid();
! 291:
! 292: attente.tv_sec = 0;
! 293: attente.tv_nsec = GRANULARITE_us * 1000;
! 294:
! 295: while((longueur_ecriture = write_atomic(s_etat_processus,
! 296: (*s_etat_processus).pipe_nombre_objets_attente,
! 297: &pid, sizeof(pid))) != sizeof(pid))
! 298: {
! 299: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 300: {
! 301: if (errno != EINTR)
! 302: {
! 303: (*s_etat_processus).erreur_systeme = d_es_processus;
! 304: return;
! 305: }
! 306: }
! 307:
! 308: if (longueur_ecriture == -1)
! 309: {
! 310: if ((*s_etat_processus).profilage == d_vrai)
! 311: {
! 312: profilage(s_etat_processus, NULL);
! 313: }
! 314:
! 315: (*s_etat_processus).erreur_systeme = d_es_processus;
! 316: return;
! 317: }
! 318:
! 319: nanosleep(&attente, NULL);
! 320: INCR_GRANULARITE(attente.tv_nsec);
! 321:
! 322: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 323: {
! 324: (*s_etat_processus).erreur_systeme = d_es_processus;
! 325: return;
! 326: }
! 327: }
! 328:
! 329: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 330: {
! 331: if (errno != EINTR)
! 332: {
! 333: (*s_etat_processus).erreur_systeme = d_es_processus;
! 334: return;
! 335: }
! 336: }
! 337: }
! 338: else
! 339: {
! 340: if ((*s_etat_processus).profilage == d_vrai)
! 341: {
! 342: profilage(s_etat_processus, "Interthread communications (SEND)");
! 343:
! 344: if ((*s_etat_processus).erreur_systeme != d_es)
! 345: {
! 346: return;
! 347: }
! 348: }
! 349:
! 350: tid = -3;
! 351:
! 352: attente.tv_sec = 0;
! 353: attente.tv_nsec = GRANULARITE_us * 1000;
! 354:
! 355: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 356: {
! 357: (*s_etat_processus).erreur_systeme = d_es_processus;
! 358: return;
! 359: }
! 360:
! 361: while((longueur_ecriture = write_atomic(s_etat_processus,
! 362: (*s_etat_processus).pipe_nombre_objets_attente,
! 363: &tid, sizeof(tid))) != sizeof(tid))
! 364: {
! 365: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 366: {
! 367: if (errno != EINTR)
! 368: {
! 369: (*s_etat_processus).erreur_systeme = d_es_processus;
! 370: return;
! 371: }
! 372: }
! 373:
! 374: if (longueur_ecriture == -1)
! 375: {
! 376: if ((*s_etat_processus).profilage == d_vrai)
! 377: {
! 378: profilage(s_etat_processus, NULL);
! 379: }
! 380:
! 381: (*s_etat_processus).erreur_systeme = d_es_processus;
! 382: return;
! 383: }
! 384:
! 385: nanosleep(&attente, NULL);
! 386: INCR_GRANULARITE(attente.tv_nsec);
! 387:
! 388: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 389: {
! 390: (*s_etat_processus).erreur_systeme = d_es_processus;
! 391: return;
! 392: }
! 393: }
! 394:
! 395: tid = pthread_self();
! 396:
! 397: attente.tv_sec = 0;
! 398: attente.tv_nsec = GRANULARITE_us * 1000;
! 399:
! 400: while((longueur_ecriture = write_atomic(s_etat_processus,
! 401: (*s_etat_processus).pipe_nombre_objets_attente,
! 402: &tid, sizeof(tid))) != sizeof(tid))
! 403: {
! 404: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 405: {
! 406: if (errno != EINTR)
! 407: {
! 408: (*s_etat_processus).erreur_systeme = d_es_processus;
! 409: return;
! 410: }
! 411: }
! 412:
! 413: if (longueur_ecriture == -1)
! 414: {
! 415: if ((*s_etat_processus).profilage == d_vrai)
! 416: {
! 417: profilage(s_etat_processus, NULL);
! 418: }
! 419:
! 420: (*s_etat_processus).erreur_systeme = d_es_processus;
! 421: return;
! 422: }
! 423:
! 424: nanosleep(&attente, NULL);
! 425: INCR_GRANULARITE(attente.tv_nsec);
! 426:
! 427: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 428: {
! 429: (*s_etat_processus).erreur_systeme = d_es_processus;
! 430: return;
! 431: }
! 432: }
! 433:
! 434: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 435: {
! 436: if (errno != EINTR)
! 437: {
! 438: (*s_etat_processus).erreur_systeme = d_es_processus;
! 439: return;
! 440: }
! 441: }
! 442: }
! 443:
! 444: (*s_etat_processus).nombre_objets_envoyes_non_lus++;
! 445:
! 446: attente.tv_sec = 0;
! 447: attente.tv_nsec = GRANULARITE_us * 1000;
! 448:
! 449: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 450: {
! 451: (*s_etat_processus).erreur_systeme = d_es_processus;
! 452: return;
! 453: }
! 454:
! 455: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
! 456: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
! 457: {
! 458: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 459: {
! 460: if (errno != EINTR)
! 461: {
! 462: (*s_etat_processus).erreur_systeme = d_es_processus;
! 463: return;
! 464: }
! 465: }
! 466:
! 467: nanosleep(&attente, NULL);
! 468: INCR_GRANULARITE(attente.tv_nsec);
! 469:
! 470: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 471: {
! 472: (*s_etat_processus).erreur_systeme = d_es_processus;
! 473: return;
! 474: }
! 475: }
! 476:
! 477: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 478: {
! 479: if (errno != EINTR)
! 480: {
! 481: (*s_etat_processus).erreur_systeme = d_es_processus;
! 482: return;
! 483: }
! 484: }
! 485:
! 486: // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
! 487: // de surveillance.
! 488:
! 489: if ((*s_etat_processus).processus_detache == d_vrai)
! 490: {
! 491: pid = -1;
! 492:
! 493: attente.tv_sec = 0;
! 494: attente.tv_nsec = GRANULARITE_us * 1000;
! 495:
! 496: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 497: {
! 498: (*s_etat_processus).erreur_systeme = d_es_processus;
! 499: return;
! 500: }
! 501:
! 502: while((longueur_ecriture = write_atomic(s_etat_processus,
! 503: (*s_etat_processus).pipe_nombre_interruptions_attente,
! 504: &pid, sizeof(pid))) != sizeof(pid))
! 505: {
! 506: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 507: {
! 508: if (errno != EINTR)
! 509: {
! 510: (*s_etat_processus).erreur_systeme = d_es_processus;
! 511: return;
! 512: }
! 513: }
! 514:
! 515: if (longueur_ecriture == -1)
! 516: {
! 517: if ((*s_etat_processus).profilage == d_vrai)
! 518: {
! 519: profilage(s_etat_processus, NULL);
! 520: }
! 521:
! 522: (*s_etat_processus).erreur_systeme = d_es_processus;
! 523: return;
! 524: }
! 525:
! 526: nanosleep(&attente, NULL);
! 527: INCR_GRANULARITE(attente.tv_nsec);
! 528:
! 529: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 530: {
! 531: (*s_etat_processus).erreur_systeme = d_es_processus;
! 532: return;
! 533: }
! 534: }
! 535:
! 536: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 537: {
! 538: if (errno != EINTR)
! 539: {
! 540: (*s_etat_processus).erreur_systeme = d_es_processus;
! 541: return;
! 542: }
! 543: }
! 544: }
! 545: else
! 546: {
! 547: tid = -1;
! 548:
! 549: attente.tv_sec = 0;
! 550: attente.tv_nsec = GRANULARITE_us * 1000;
! 551:
! 552: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 553: {
! 554: (*s_etat_processus).erreur_systeme = d_es_processus;
! 555: return;
! 556: }
! 557:
! 558: while((longueur_ecriture = write_atomic(s_etat_processus,
! 559: (*s_etat_processus).pipe_nombre_interruptions_attente,
! 560: &tid, sizeof(tid))) != sizeof(tid))
! 561: {
! 562: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 563: {
! 564: if (errno != EINTR)
! 565: {
! 566: (*s_etat_processus).erreur_systeme = d_es_processus;
! 567: return;
! 568: }
! 569: }
! 570:
! 571: if (longueur_ecriture == -1)
! 572: {
! 573: if ((*s_etat_processus).profilage == d_vrai)
! 574: {
! 575: profilage(s_etat_processus, NULL);
! 576: }
! 577:
! 578: (*s_etat_processus).erreur_systeme = d_es_processus;
! 579: return;
! 580: }
! 581:
! 582: nanosleep(&attente, NULL);
! 583: INCR_GRANULARITE(attente.tv_nsec);
! 584:
! 585: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 586: {
! 587: (*s_etat_processus).erreur_systeme = d_es_processus;
! 588: return;
! 589: }
! 590: }
! 591:
! 592: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 593: {
! 594: if (errno != EINTR)
! 595: {
! 596: (*s_etat_processus).erreur_systeme = d_es_processus;
! 597: return;
! 598: }
! 599: }
! 600: }
! 601:
! 602: // ecriture_pipe() ne peut être interrompu par un signal.
! 603:
! 604: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 605: {
! 606: (*s_etat_processus).erreur_systeme = d_es_processus;
! 607: return;
! 608: }
! 609:
! 610: if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
! 611: s_objet) == d_erreur)
! 612: {
! 613: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 614: {
! 615: if (errno != EINTR)
! 616: {
! 617: (*s_etat_processus).erreur_systeme = d_es_processus;
! 618: return;
! 619: }
! 620: }
! 621:
! 622: if ((*s_etat_processus).profilage == d_vrai)
! 623: {
! 624: profilage(s_etat_processus, NULL);
! 625: }
! 626:
! 627: liberation(s_etat_processus, s_objet);
! 628: return;
! 629: }
! 630:
! 631: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 632: {
! 633: if (errno != EINTR)
! 634: {
! 635: (*s_etat_processus).erreur_systeme = d_es_processus;
! 636: return;
! 637: }
! 638: }
! 639:
! 640: if ((*s_etat_processus).profilage == d_vrai)
! 641: {
! 642: profilage(s_etat_processus, NULL);
! 643: }
! 644:
! 645: if (registre == 0)
! 646: {
! 647: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
! 648: {
! 649: (*s_etat_processus).var_volatile_requete_arret = -1;
! 650: }
! 651:
! 652: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
! 653: }
! 654:
! 655: liberation(s_etat_processus, s_objet);
! 656: return;
! 657: }
! 658:
! 659:
! 660: /*
! 661: ================================================================================
! 662: Fonction 'sqlquery'
! 663: ================================================================================
! 664: Entrées :
! 665: --------------------------------------------------------------------------------
! 666: Sorties :
! 667: --------------------------------------------------------------------------------
! 668: Effets de bord : néant
! 669: ================================================================================
! 670: */
! 671:
! 672: void
! 673: instruction_sqlquery(struct_processus *s_etat_processus)
! 674: {
! 675: # define d_LONGUEUR 1024
! 676:
! 677: logical1 connexion_permanente;
! 678: logical1 presence_resultat;
! 679:
! 680: struct_objet *s_copie_1;
! 681: struct_objet *s_objet_1;
! 682: struct_objet *s_copie_2;
! 683: struct_objet *s_objet_2;
! 684: struct_objet *s_objet_resultat;
! 685:
! 686: struct_liste_chainee *l_element_courant;
! 687: struct_liste_chainee *l_element_courant_ligne;
! 688:
! 689: unsigned char *tampon;
! 690:
! 691: unsigned int i;
! 692: unsigned int j;
! 693: unsigned int nombre_colonnes;
! 694: unsigned int nombre_lignes;
! 695:
! 696: (*s_etat_processus).erreur_execution = d_ex;
! 697:
! 698: if ((*s_etat_processus).affichage_arguments == 'Y')
! 699: {
! 700: printf("\n SQLQUERY ");
! 701:
! 702: if ((*s_etat_processus).langue == 'F')
! 703: {
! 704: printf("(requête SQL)\n\n");
! 705: }
! 706: else
! 707: {
! 708: printf("(SQL query)\n\n");
! 709: }
! 710:
! 711: printf(" 2: %s\n", d_CHN);
! 712: printf(" 1: %s\n", d_LST);
! 713: printf("-> 1: %s\n\n", d_LST);
! 714:
! 715: printf(" 2: %s\n", d_CHN);
! 716: printf(" 1: %s\n", d_SQL);
! 717: printf("-> 1: %s\n\n", d_LST);
! 718:
! 719: if ((*s_etat_processus).langue == 'F')
! 720: {
! 721: printf(" Utilisation :\n\n");
! 722: }
! 723: else
! 724: {
! 725: printf(" Usage:\n\n");
! 726: }
! 727:
! 728: printf(" \"select * from table\"\n");
! 729: printf(" { \"mysql\" \"server\" \"database\" "
! 730: "\"user\" \"password\" } SQLQUERY\n");
! 731: printf(" \"select field from table\"\n");
! 732: printf(" { \"postgresql:iso-8859-1\" \"server\" "
! 733: "\"database\" \"user\" \"password\" port }\n");
! 734: printf(" SQLQUERY\n");
! 735:
! 736: return;
! 737: }
! 738: else if ((*s_etat_processus).test_instruction == 'Y')
! 739: {
! 740: (*s_etat_processus).nombre_arguments = -1;
! 741: return;
! 742: }
! 743:
! 744: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 745: {
! 746: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 747: {
! 748: return;
! 749: }
! 750: }
! 751:
! 752: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 753: &s_objet_1) == d_erreur)
! 754: {
! 755: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 756: return;
! 757: }
! 758:
! 759: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 760: &s_objet_2) == d_erreur)
! 761: {
! 762: liberation(s_etat_processus, s_objet_1);
! 763:
! 764: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 765: return;
! 766: }
! 767:
! 768: if ((*s_objet_1).type == LST)
! 769: {
! 770: connexion_permanente = d_faux;
! 771:
! 772: s_copie_1 = s_objet_1;
! 773:
! 774: if ((s_objet_1 = parametres_sql(s_etat_processus, s_copie_1)) == NULL)
! 775: {
! 776: liberation(s_etat_processus, s_copie_1);
! 777: liberation(s_etat_processus, s_objet_2);
! 778: return;
! 779: }
! 780:
! 781: liberation(s_etat_processus, s_copie_1);
! 782: }
! 783: else
! 784: {
! 785: if ((*s_objet_1).type == SQL)
! 786: {
! 787: if (((*((struct_connecteur_sql *) (*s_objet_1).objet)).pid !=
! 788: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
! 789: (*s_objet_1).objet)).tid, pthread_self()) == 0))
! 790: {
! 791: (*s_etat_processus).erreur_execution =
! 792: d_ex_fichier_hors_contexte;
! 793:
! 794: liberation(s_etat_processus, s_objet_1);
! 795: liberation(s_etat_processus, s_objet_2);
! 796: return;
! 797: }
! 798: }
! 799:
! 800: connexion_permanente = d_vrai;
! 801: }
! 802:
! 803: if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))
! 804: {
! 805: if ((*((struct_connecteur_sql *) (*s_objet_1).objet)).locale != NULL)
! 806: {
! 807: /*
! 808: * Transcodage de la commande SQL
! 809: */
! 810:
! 811: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O'))
! 812: == NULL)
! 813: {
! 814: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 815: return;
! 816: }
! 817:
! 818: liberation(s_etat_processus, s_objet_2);
! 819: s_objet_2 = s_copie_2;
! 820:
! 821: tampon = (*s_objet_2).objet;
! 822:
! 823: if (((*s_objet_2).objet = transliteration(s_etat_processus, tampon,
! 824: (*((struct_connecteur_sql *) (*s_objet_1).objet)).locale,
! 825: d_locale)) == NULL)
! 826: {
! 827: return;
! 828: }
! 829:
! 830: free(tampon);
! 831: }
! 832:
! 833: /*
! 834: * Pilote MySQL
! 835: */
! 836:
! 837: if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
! 838: "MYSQL") == 0)
! 839: {
! 840: # ifdef MYSQL_SUPPORT
! 841:
! 842: MYSQL_RES *resultat_mysql;
! 843: MYSQL_ROW ligne;
! 844:
! 845: if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
! 846: .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
! 847: .objet, strlen((unsigned char *) (*s_objet_2).objet)) != 0)
! 848: {
! 849: if (connexion_permanente == d_faux)
! 850: {
! 851: mysql_close((*((struct_connecteur_sql *) (*s_objet_1)
! 852: .objet)).descripteur.mysql);
! 853: }
! 854:
! 855: liberation(s_etat_processus, s_objet_1);
! 856: liberation(s_etat_processus, s_objet_2);
! 857:
! 858: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
! 859: return;
! 860: }
! 861:
! 862: if ((resultat_mysql = mysql_store_result(
! 863: (*((struct_connecteur_sql *) (*s_objet_1).objet))
! 864: .descripteur.mysql)) == NULL)
! 865: {
! 866: // La requête ne renvoie rien (exemple : INSERT)
! 867: presence_resultat = d_faux;
! 868: nombre_colonnes = 0;
! 869: }
! 870: else
! 871: {
! 872: // La requête renvoie une ou plusieurs valeurs.
! 873: presence_resultat = d_vrai;
! 874: nombre_colonnes = mysql_field_count((*((struct_connecteur_sql *)
! 875: (*s_objet_1).objet)).descripteur.mysql);
! 876: }
! 877:
! 878: if ((s_objet_resultat = allocation(s_etat_processus, LST))
! 879: == NULL)
! 880: {
! 881: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 882: return;
! 883: }
! 884:
! 885: (*s_objet_resultat).objet = NULL;
! 886: l_element_courant = (*s_objet_resultat).objet;
! 887:
! 888: while(((presence_resultat == d_vrai) ?
! 889: (ligne = mysql_fetch_row(resultat_mysql)) : NULL) != NULL)
! 890: {
! 891: unsigned long *longueurs;
! 892:
! 893: longueurs = mysql_fetch_lengths(resultat_mysql);
! 894:
! 895: if (l_element_courant == NULL)
! 896: {
! 897: if (((*s_objet_resultat).objet =
! 898: allocation_maillon(s_etat_processus)) == NULL)
! 899: {
! 900: (*s_etat_processus).erreur_systeme =
! 901: d_es_allocation_memoire;
! 902: return;
! 903: }
! 904:
! 905: l_element_courant = (struct_liste_chainee *)
! 906: (*s_objet_resultat).objet;
! 907: }
! 908: else
! 909: {
! 910: if (((*l_element_courant).suivant =
! 911: allocation_maillon(s_etat_processus)) == NULL)
! 912: {
! 913: (*s_etat_processus).erreur_systeme =
! 914: d_es_allocation_memoire;
! 915: return;
! 916: }
! 917:
! 918: l_element_courant = (*l_element_courant).suivant;
! 919: }
! 920:
! 921: (*l_element_courant).suivant = NULL;
! 922:
! 923: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 924: LST)) == NULL)
! 925: {
! 926: (*s_etat_processus).erreur_systeme =
! 927: d_es_allocation_memoire;
! 928: return;
! 929: }
! 930:
! 931: (*(*l_element_courant).donnee).objet = NULL;
! 932: l_element_courant_ligne = NULL;
! 933:
! 934: for(i = 0; i < nombre_colonnes; i++)
! 935: {
! 936: if (l_element_courant_ligne == NULL)
! 937: {
! 938: if (((*(*l_element_courant).donnee).objet =
! 939: allocation_maillon(s_etat_processus)) == NULL)
! 940: {
! 941: (*s_etat_processus).erreur_systeme =
! 942: d_es_allocation_memoire;
! 943: return;
! 944: }
! 945:
! 946: l_element_courant_ligne = (struct_liste_chainee *)
! 947: (*(*l_element_courant).donnee).objet;
! 948: }
! 949: else
! 950: {
! 951: if (((*l_element_courant_ligne).suivant =
! 952: allocation_maillon(s_etat_processus)) == NULL)
! 953: {
! 954: (*s_etat_processus).erreur_systeme =
! 955: d_es_allocation_memoire;
! 956: return;
! 957: }
! 958:
! 959: l_element_courant_ligne =
! 960: (*l_element_courant_ligne).suivant;
! 961: }
! 962:
! 963: (*l_element_courant_ligne).suivant = NULL;
! 964:
! 965: if (((*l_element_courant_ligne).donnee =
! 966: allocation(s_etat_processus, CHN)) == NULL)
! 967: {
! 968: (*s_etat_processus).erreur_systeme =
! 969: d_es_allocation_memoire;
! 970: return;
! 971: }
! 972:
! 973: if (ligne[i] == NULL)
! 974: {
! 975: if (((*(*l_element_courant_ligne).donnee).objet =
! 976: malloc(5 * sizeof(unsigned char))) == NULL)
! 977: {
! 978: (*s_etat_processus).erreur_systeme =
! 979: d_es_allocation_memoire;
! 980: return;
! 981: }
! 982:
! 983: strcpy((unsigned char *) (*(*l_element_courant_ligne)
! 984: .donnee).objet, "NULL");
! 985: }
! 986: else
! 987: {
! 988: if (((*(*l_element_courant_ligne).donnee).objet =
! 989: malloc((longueurs[i] + 1) *
! 990: sizeof(unsigned char))) == NULL)
! 991: {
! 992: (*s_etat_processus).erreur_systeme =
! 993: d_es_allocation_memoire;
! 994: return;
! 995: }
! 996:
! 997: strcpy((unsigned char *) (*(*l_element_courant_ligne)
! 998: .donnee).objet, ligne[i]);
! 999: }
! 1000: }
! 1001: }
! 1002:
! 1003: mysql_free_result(resultat_mysql);
! 1004:
! 1005: if (connexion_permanente == d_faux)
! 1006: {
! 1007: mysql_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
! 1008: .descripteur.mysql);
! 1009: }
! 1010:
! 1011: if (presence_resultat == d_vrai)
! 1012: {
! 1013: if (empilement(s_etat_processus,
! 1014: &((*s_etat_processus).l_base_pile),
! 1015: s_objet_resultat) == d_erreur)
! 1016: {
! 1017: return;
! 1018: }
! 1019: }
! 1020:
! 1021: # else
! 1022:
! 1023: if ((*s_etat_processus).langue == 'F')
! 1024: {
! 1025: printf("+++Attention : Support de MySQL non compilé !\n");
! 1026: }
! 1027: else
! 1028: {
! 1029: printf("+++Warning : MySQL support not available !\n");
! 1030: }
! 1031:
! 1032: fflush(stdout);
! 1033: # endif
! 1034: }
! 1035:
! 1036: /*
! 1037: * Pilote PostgreSQL
! 1038: */
! 1039:
! 1040: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
! 1041: "POSTGRESQL") == 0)
! 1042: {
! 1043: # ifdef POSTGRESQL_SUPPORT
! 1044:
! 1045: PGresult *resultat_postgresql;
! 1046:
! 1047: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
! 1048: .descripteur.postgresql) != CONNECTION_OK)
! 1049: {
! 1050: if (connexion_permanente == d_faux)
! 1051: {
! 1052: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
! 1053: .descripteur.postgresql);
! 1054: }
! 1055:
! 1056: liberation(s_etat_processus, s_objet_1);
! 1057: liberation(s_etat_processus, s_objet_2);
! 1058:
! 1059: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
! 1060: return;
! 1061: }
! 1062:
! 1063: resultat_postgresql = PQexec((*((struct_connecteur_sql *)
! 1064: (*s_objet_1).objet)).descripteur.postgresql,
! 1065: (unsigned char *) (*s_objet_2).objet);
! 1066: presence_resultat = d_faux;
! 1067:
! 1068: switch(PQresultStatus(resultat_postgresql))
! 1069: {
! 1070: case PGRES_COMMAND_OK :
! 1071: { // Commande qui ne renvoit rien
! 1072: if ((s_objet_resultat = allocation(s_etat_processus, LST))
! 1073: == NULL)
! 1074: {
! 1075: (*s_etat_processus).erreur_systeme =
! 1076: d_es_allocation_memoire;
! 1077: return;
! 1078: }
! 1079:
! 1080: (*s_objet_resultat).objet = NULL;
! 1081: l_element_courant = (*s_objet_resultat).objet;
! 1082: presence_resultat = d_vrai;
! 1083:
! 1084: break;
! 1085: }
! 1086:
! 1087: case PGRES_TUPLES_OK :
! 1088: { // Commande renvoyant des données
! 1089: if ((s_objet_resultat = allocation(s_etat_processus, LST))
! 1090: == NULL)
! 1091: {
! 1092: (*s_etat_processus).erreur_systeme =
! 1093: d_es_allocation_memoire;
! 1094: return;
! 1095: }
! 1096:
! 1097: (*s_objet_resultat).objet = NULL;
! 1098: l_element_courant = (*s_objet_resultat).objet;
! 1099: presence_resultat = d_vrai;
! 1100:
! 1101: nombre_colonnes = PQnfields(resultat_postgresql);
! 1102: nombre_lignes = PQntuples(resultat_postgresql);
! 1103:
! 1104: for(i = 0; i < nombre_lignes; i++)
! 1105: {
! 1106: // Chaînage d'un nouveau maillon de la liste résultat
! 1107:
! 1108: if (l_element_courant == NULL)
! 1109: {
! 1110: if (((*s_objet_resultat).objet =
! 1111: allocation_maillon(s_etat_processus))
! 1112: == NULL)
! 1113: {
! 1114: (*s_etat_processus).erreur_systeme =
! 1115: d_es_allocation_memoire;
! 1116: return;
! 1117: }
! 1118:
! 1119: l_element_courant = (struct_liste_chainee *)
! 1120: (*s_objet_resultat).objet;
! 1121: }
! 1122: else
! 1123: {
! 1124: if (((*l_element_courant).suivant =
! 1125: allocation_maillon(s_etat_processus))
! 1126: == NULL)
! 1127: {
! 1128: (*s_etat_processus).erreur_systeme =
! 1129: d_es_allocation_memoire;
! 1130: return;
! 1131: }
! 1132:
! 1133: l_element_courant = (*l_element_courant).suivant;
! 1134: }
! 1135:
! 1136: (*l_element_courant).suivant = NULL;
! 1137:
! 1138: // Création de la liste fille
! 1139:
! 1140: if (((*l_element_courant).donnee =
! 1141: allocation(s_etat_processus, LST)) == NULL)
! 1142: {
! 1143: (*s_etat_processus).erreur_systeme =
! 1144: d_es_allocation_memoire;
! 1145: return;
! 1146: }
! 1147:
! 1148: (*(*l_element_courant).donnee).objet = NULL;
! 1149: l_element_courant_ligne = NULL;
! 1150:
! 1151: for(j = 0; j < nombre_colonnes; j++)
! 1152: {
! 1153: if (l_element_courant_ligne == NULL)
! 1154: {
! 1155: if (((*(*l_element_courant).donnee).objet =
! 1156: allocation_maillon(s_etat_processus))
! 1157: == NULL)
! 1158: {
! 1159: (*s_etat_processus).erreur_systeme =
! 1160: d_es_allocation_memoire;
! 1161: return;
! 1162: }
! 1163:
! 1164: l_element_courant_ligne =
! 1165: (struct_liste_chainee *)
! 1166: (*(*l_element_courant).donnee).objet;
! 1167: }
! 1168: else
! 1169: {
! 1170: if (((*l_element_courant_ligne).suivant =
! 1171: allocation_maillon(s_etat_processus))
! 1172: == NULL)
! 1173: {
! 1174: l_element_courant_ligne =
! 1175: (*l_element_courant_ligne).suivant;
! 1176: }
! 1177:
! 1178: l_element_courant_ligne =
! 1179: (*l_element_courant_ligne).suivant;
! 1180: }
! 1181:
! 1182: (*l_element_courant_ligne).suivant = NULL;
! 1183:
! 1184: if (((*l_element_courant_ligne).donnee =
! 1185: allocation(s_etat_processus, CHN))
! 1186: == NULL)
! 1187: {
! 1188: (*s_etat_processus).erreur_systeme =
! 1189: d_es_allocation_memoire;
! 1190: return;
! 1191: }
! 1192:
! 1193: if (PQgetisnull(resultat_postgresql, i, j) != 0)
! 1194: {
! 1195: if (((*(*l_element_courant_ligne).donnee).objet
! 1196: = malloc(5 * sizeof(unsigned char)))
! 1197: == NULL)
! 1198: {
! 1199: (*s_etat_processus).erreur_systeme =
! 1200: d_es_allocation_memoire;
! 1201: return;
! 1202: }
! 1203:
! 1204: strcpy((unsigned char *)
! 1205: (*(*l_element_courant_ligne).donnee)
! 1206: .objet, "NULL");
! 1207: }
! 1208: else
! 1209: {
! 1210: if (((*(*l_element_courant_ligne).donnee).objet
! 1211: = malloc((PQgetlength(
! 1212: resultat_postgresql, i, j) + 1) *
! 1213: sizeof(unsigned char))) == NULL)
! 1214: {
! 1215: (*s_etat_processus).erreur_systeme =
! 1216: d_es_allocation_memoire;
! 1217: return;
! 1218: }
! 1219:
! 1220: strcpy((unsigned char *)
! 1221: (*(*l_element_courant_ligne).donnee)
! 1222: .objet, PQgetvalue(resultat_postgresql,
! 1223: i, j));
! 1224: }
! 1225: }
! 1226: }
! 1227:
! 1228: break;
! 1229: }
! 1230:
! 1231: case PGRES_EMPTY_QUERY :
! 1232: case PGRES_COPY_OUT :
! 1233: case PGRES_COPY_IN :
! 1234: case PGRES_BAD_RESPONSE :
! 1235: case PGRES_NONFATAL_ERROR :
! 1236: case PGRES_FATAL_ERROR :
! 1237: default :
! 1238: {
! 1239: printf("%s\n", PQresultErrorMessage(resultat_postgresql));
! 1240: PQclear(resultat_postgresql);
! 1241:
! 1242: if (connexion_permanente == d_faux)
! 1243: {
! 1244: PQfinish((*((struct_connecteur_sql *) (*s_objet_1)
! 1245: .objet)).descripteur.postgresql);
! 1246: }
! 1247:
! 1248: liberation(s_etat_processus, s_objet_1);
! 1249: liberation(s_etat_processus, s_objet_2);
! 1250:
! 1251: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
! 1252:
! 1253: return;
! 1254: break;
! 1255: }
! 1256: }
! 1257:
! 1258: PQclear(resultat_postgresql);
! 1259:
! 1260: if (connexion_permanente == d_faux)
! 1261: {
! 1262: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
! 1263: .descripteur.postgresql);
! 1264: }
! 1265:
! 1266: if (presence_resultat == d_vrai)
! 1267: {
! 1268: if (empilement(s_etat_processus, &((*s_etat_processus)
! 1269: .l_base_pile), s_objet_resultat) == d_erreur)
! 1270: {
! 1271: return;
! 1272: }
! 1273: }
! 1274:
! 1275: # else
! 1276:
! 1277: if ((*s_etat_processus).langue == 'F')
! 1278: {
! 1279: printf("+++Attention : Support de PostgreSQL non compilé !\n");
! 1280: }
! 1281: else
! 1282: {
! 1283: printf("+++Warning : PostgreSQL support not available !\n");
! 1284: }
! 1285:
! 1286: fflush(stdout);
! 1287: # endif
! 1288: }
! 1289: else
! 1290: {
! 1291: liberation(s_etat_processus, s_objet_1);
! 1292: liberation(s_etat_processus, s_objet_2);
! 1293:
! 1294: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
! 1295: return;
! 1296: }
! 1297: }
! 1298: else
! 1299: {
! 1300: liberation(s_etat_processus, s_objet_1);
! 1301: liberation(s_etat_processus, s_objet_2);
! 1302:
! 1303: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1304: return;
! 1305: }
! 1306:
! 1307: liberation(s_etat_processus, s_objet_1);
! 1308: liberation(s_etat_processus, s_objet_2);
! 1309:
! 1310: return;
! 1311: }
! 1312:
! 1313:
! 1314: /*
! 1315: ================================================================================
! 1316: Fonction 'stop'
! 1317: ================================================================================
! 1318: Entrées :
! 1319: --------------------------------------------------------------------------------
! 1320: Sorties :
! 1321: --------------------------------------------------------------------------------
! 1322: Effets de bord : néant
! 1323: ================================================================================
! 1324: */
! 1325:
! 1326: void
! 1327: instruction_stop(struct_processus *s_etat_processus)
! 1328: {
! 1329: struct_liste_chainee *l_element_courant;
! 1330:
! 1331: struct_objet *s_objet;
! 1332:
! 1333: struct timespec attente;
! 1334:
! 1335: attente.tv_sec = 0;
! 1336: attente.tv_nsec = GRANULARITE_us * 1000;
! 1337:
! 1338: (*s_etat_processus).erreur_execution = d_ex;
! 1339:
! 1340: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1341: {
! 1342: printf("\n STOP ");
! 1343:
! 1344: if ((*s_etat_processus).langue == 'F')
! 1345: {
! 1346: printf("(arrêt d'un processus)\n\n");
! 1347: }
! 1348: else
! 1349: {
! 1350: printf("(kill process)\n\n");
! 1351: }
! 1352:
! 1353: printf(" 1: %s\n", d_PRC);
! 1354:
! 1355: return;
! 1356: }
! 1357: else if ((*s_etat_processus).test_instruction == 'Y')
! 1358: {
! 1359: (*s_etat_processus).nombre_arguments = -1;
! 1360: return;
! 1361: }
! 1362:
! 1363: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1364: {
! 1365: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1366: {
! 1367: return;
! 1368: }
! 1369: }
! 1370:
! 1371: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1372: &s_objet) == d_erreur)
! 1373: {
! 1374: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1375: return;
! 1376: }
! 1377:
! 1378: if ((*s_objet).type == PRC)
! 1379: {
! 1380: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
! 1381: .processus_detache == d_vrai)
! 1382: {
! 1383: kill((*(*((struct_processus_fils *) (*s_objet).objet)).thread).pid,
! 1384: SIGFSTOP);
! 1385: }
! 1386: else
! 1387: {
! 1388: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 1389: {
! 1390: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1391: return;
! 1392: }
! 1393:
! 1394: l_element_courant = (struct_liste_chainee *)
! 1395: (*s_etat_processus).l_base_pile_processus;
! 1396:
! 1397: while(l_element_courant != NULL)
! 1398: {
! 1399: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
! 1400: .donnee).objet)).thread).processus_detache == d_faux)
! 1401: {
! 1402: if ((pthread_equal((*(*((struct_processus_fils *)
! 1403: (*(*l_element_courant).donnee).objet)).thread).pid,
! 1404: (*(*((struct_processus_fils *)
! 1405: (*s_objet).objet)).thread).tid) != 0) &&
! 1406: ((*(*((struct_processus_fils *)
! 1407: (*(*l_element_courant).donnee).objet)).thread).pid
! 1408: == (*(*((struct_processus_fils *)
! 1409: (*s_objet).objet)).thread).pid))
! 1410: {
! 1411: break;
! 1412: }
! 1413: }
! 1414:
! 1415: l_element_courant = (*l_element_courant).suivant;
! 1416: }
! 1417:
! 1418: if (l_element_courant != NULL)
! 1419: {
! 1420: // Le champ thread_actif est un pointeur sur un champ de la
! 1421: // structure s_argument_thread libéré par la fonction
! 1422: // retrait_thread_surveillance().
! 1423:
! 1424: if ((*(*((struct_processus_fils *)
! 1425: (*s_objet).objet)).thread).thread_actif == d_vrai)
! 1426: {
! 1427: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
! 1428: (*s_objet).objet)).thread).mutex)) != 0)
! 1429: {
! 1430: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
! 1431: != 0)
! 1432: {
! 1433: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1434: return;
! 1435: }
! 1436:
! 1437: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1438: return;
! 1439: }
! 1440:
! 1441: if ((*(*((struct_processus_fils *)
! 1442: (*s_objet).objet)).thread).thread_actif == d_vrai)
! 1443: {
! 1444: pthread_kill((*(*((struct_processus_fils *)
! 1445: (*s_objet).objet)).thread).tid, SIGFSTOP);
! 1446: }
! 1447:
! 1448: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 1449: (*s_objet).objet)).thread).mutex)) != 0)
! 1450: {
! 1451: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
! 1452: != 0)
! 1453: {
! 1454: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1455: return;
! 1456: }
! 1457:
! 1458: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1459: return;
! 1460: }
! 1461: }
! 1462: }
! 1463:
! 1464: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1465: {
! 1466: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1467: return;
! 1468: }
! 1469: }
! 1470: }
! 1471: else
! 1472: {
! 1473: liberation(s_etat_processus, s_objet);
! 1474:
! 1475: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1476: return;
! 1477: }
! 1478:
! 1479: liberation(s_etat_processus, s_objet);
! 1480:
! 1481: return;
! 1482: }
! 1483:
! 1484: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s8.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src