Annotation of rpl/src/instructions_r4.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 'r->b'
! 29: ================================================================================
! 30: Entrées : pointeur sur une structure struct_processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_r_vers_b(struct_processus *s_etat_processus)
! 40: {
! 41: struct_objet *s_objet_argument;
! 42: struct_objet *s_objet_resultat;
! 43:
! 44: (*s_etat_processus).erreur_execution = d_ex;
! 45:
! 46: if ((*s_etat_processus).affichage_arguments == 'Y')
! 47: {
! 48: printf("\n R->B ");
! 49:
! 50: if ((*s_etat_processus).langue == 'F')
! 51: {
! 52: printf("(réel vers binaire)\n\n");
! 53: }
! 54: else
! 55: {
! 56: printf("(real to binary)\n\n");
! 57: }
! 58:
! 59: printf(" 1: %s\n", d_INT);
! 60: printf("-> 1: %s\n", d_BIN);
! 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_argument) == d_erreur)
! 80: {
! 81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 82: return;
! 83: }
! 84:
! 85: if ((*s_objet_argument).type == INT)
! 86: {
! 87: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
! 88: {
! 89: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 90: return;
! 91: }
! 92:
! 93: if ((*((integer8 *) (*s_objet_argument).objet)) < 0)
! 94: {
! 95: (*((logical8 *) (*s_objet_resultat).objet)) = 0;
! 96: }
! 97: else
! 98: {
! 99: (*((logical8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
! 100: (*s_objet_argument).objet));
! 101: }
! 102: }
! 103: else
! 104: {
! 105: liberation(s_etat_processus, s_objet_argument);
! 106:
! 107: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 108: return;
! 109: }
! 110:
! 111: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 112: s_objet_resultat) == d_erreur)
! 113: {
! 114: return;
! 115: }
! 116:
! 117: liberation(s_etat_processus, s_objet_argument);
! 118: return;
! 119: }
! 120:
! 121:
! 122: /*
! 123: ================================================================================
! 124: Fonction 'rl'
! 125: ================================================================================
! 126: Entrées : pointeur sur une structure struct_processus
! 127: --------------------------------------------------------------------------------
! 128: Sorties :
! 129: --------------------------------------------------------------------------------
! 130: Effets de bord : néant
! 131: ================================================================================
! 132: */
! 133:
! 134: void
! 135: instruction_rl(struct_processus *s_etat_processus)
! 136: {
! 137: logical8 masque;
! 138: logical8 tampon;
! 139:
! 140: struct_objet *s_copie;
! 141: struct_objet *s_objet;
! 142:
! 143: unsigned long i;
! 144: unsigned long j;
! 145: unsigned long longueur;
! 146:
! 147: (*s_etat_processus).erreur_execution = d_ex;
! 148:
! 149: if ((*s_etat_processus).affichage_arguments == 'Y')
! 150: {
! 151: printf("\n RL ");
! 152:
! 153: if ((*s_etat_processus).langue == 'F')
! 154: {
! 155: printf("(rotation à gauche)\n\n");
! 156: }
! 157: else
! 158: {
! 159: printf("(rotate left)\n\n");
! 160: }
! 161:
! 162: printf(" 1: %s\n", d_BIN);
! 163: printf("-> 1: %s\n", d_BIN);
! 164:
! 165: return;
! 166: }
! 167: else if ((*s_etat_processus).test_instruction == 'Y')
! 168: {
! 169: (*s_etat_processus).nombre_arguments = -1;
! 170: return;
! 171: }
! 172:
! 173: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 174: {
! 175: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 176: {
! 177: return;
! 178: }
! 179: }
! 180:
! 181: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 182: &s_objet) == d_erreur)
! 183: {
! 184: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 185: return;
! 186: }
! 187:
! 188: if ((*s_objet).type == BIN)
! 189: {
! 190: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
! 191: {
! 192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 193: return;
! 194: }
! 195:
! 196: longueur = 1;
! 197: j = 1;
! 198:
! 199: for(i = 37; i <= 42; i++)
! 200: {
! 201: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
! 202: == d_vrai) ? j : 0;
! 203: j *= 2;
! 204: }
! 205:
! 206: tampon = (*((logical8 *) (*s_copie).objet));
! 207: masque = ((logical8) 1) << (longueur - 1);
! 208:
! 209: if ((tampon & masque) == 0)
! 210: {
! 211: tampon <<= 1;
! 212: }
! 213: else
! 214: {
! 215: tampon <<= 1;
! 216: tampon |= (logical8) 1;
! 217: }
! 218:
! 219: for(masque = 0, i = 0; i < longueur; i++)
! 220: {
! 221: masque <<= 1;
! 222: masque |= (logical8) 1;
! 223: }
! 224:
! 225: tampon &= masque;
! 226: (*((logical8 *) (*s_copie).objet)) = tampon;
! 227:
! 228: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 229: s_copie) == d_erreur)
! 230: {
! 231: return;
! 232: }
! 233: }
! 234: else
! 235: {
! 236: liberation(s_etat_processus, s_objet);
! 237:
! 238: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 239: return;
! 240: }
! 241:
! 242: liberation(s_etat_processus, s_objet);
! 243:
! 244: return;
! 245: }
! 246:
! 247:
! 248: /*
! 249: ================================================================================
! 250: Fonction 'rlb'
! 251: ================================================================================
! 252: Entrées : pointeur sur une structure struct_processus
! 253: --------------------------------------------------------------------------------
! 254: Sorties :
! 255: --------------------------------------------------------------------------------
! 256: Effets de bord : néant
! 257: ================================================================================
! 258: */
! 259:
! 260: void
! 261: instruction_rlb(struct_processus *s_etat_processus)
! 262: {
! 263: struct_liste_chainee *l_base_pile;
! 264:
! 265: unsigned long i;
! 266:
! 267: (*s_etat_processus).erreur_execution = d_ex;
! 268:
! 269: if ((*s_etat_processus).affichage_arguments == 'Y')
! 270: {
! 271: printf("\n RLB ");
! 272:
! 273: if ((*s_etat_processus).langue == 'F')
! 274: {
! 275: printf("(rotation d'un octet vers la gauche)\n\n");
! 276: }
! 277: else
! 278: {
! 279: printf("(rotate left byte)\n\n");
! 280: }
! 281:
! 282: printf(" 1: %s\n", d_BIN);
! 283: printf("-> 1: %s\n", d_BIN);
! 284:
! 285: return;
! 286: }
! 287: else if ((*s_etat_processus).test_instruction == 'Y')
! 288: {
! 289: (*s_etat_processus).nombre_arguments = -1;
! 290: return;
! 291: }
! 292:
! 293: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 294: {
! 295: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 296: {
! 297: return;
! 298: }
! 299: }
! 300:
! 301: l_base_pile = (*s_etat_processus).l_base_pile_last;
! 302: (*s_etat_processus).l_base_pile_last = NULL;
! 303:
! 304: for(i = 0; i < 8; i++)
! 305: {
! 306: instruction_rl(s_etat_processus);
! 307:
! 308: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 309: ((*s_etat_processus).erreur_execution != d_ex))
! 310: {
! 311: break;
! 312: }
! 313: }
! 314:
! 315: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 316: {
! 317: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 318: {
! 319: return;
! 320: }
! 321: }
! 322:
! 323: (*s_etat_processus).l_base_pile_last = l_base_pile;
! 324: return;
! 325: }
! 326:
! 327:
! 328: /*
! 329: ================================================================================
! 330: Fonction 'rr'
! 331: ================================================================================
! 332: Entrées : pointeur sur une structure struct_processus
! 333: --------------------------------------------------------------------------------
! 334: Sorties :
! 335: --------------------------------------------------------------------------------
! 336: Effets de bord : néant
! 337: ================================================================================
! 338: */
! 339:
! 340: void
! 341: instruction_rr(struct_processus *s_etat_processus)
! 342: {
! 343: logical8 masque;
! 344: logical8 tampon;
! 345:
! 346: struct_objet *s_copie;
! 347: struct_objet *s_objet;
! 348:
! 349: unsigned long i;
! 350: unsigned long j;
! 351: unsigned long longueur;
! 352:
! 353: (*s_etat_processus).erreur_execution = d_ex;
! 354:
! 355: if ((*s_etat_processus).affichage_arguments == 'Y')
! 356: {
! 357: printf("\n RR ");
! 358:
! 359: if ((*s_etat_processus).langue == 'F')
! 360: {
! 361: printf("(rotation à droite)\n\n");
! 362: }
! 363: else
! 364: {
! 365: printf("(rotate right)\n\n");
! 366: }
! 367:
! 368: printf(" 1: %s\n", d_BIN);
! 369: printf("-> 1: %s\n", d_BIN);
! 370:
! 371: return;
! 372: }
! 373: else if ((*s_etat_processus).test_instruction == 'Y')
! 374: {
! 375: (*s_etat_processus).nombre_arguments = -1;
! 376: return;
! 377: }
! 378:
! 379: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 380: {
! 381: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 382: {
! 383: return;
! 384: }
! 385: }
! 386:
! 387: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 388: &s_objet) == d_erreur)
! 389: {
! 390: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 391: return;
! 392: }
! 393:
! 394: if ((*s_objet).type == BIN)
! 395: {
! 396: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
! 397: {
! 398: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 399: return;
! 400: }
! 401:
! 402: longueur = 1;
! 403: j = 1;
! 404:
! 405: for(i = 37; i <= 42; i++)
! 406: {
! 407: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
! 408: == d_vrai) ? j : 0;
! 409: j *= 2;
! 410: }
! 411:
! 412: tampon = (*((logical8 *) (*s_copie).objet));
! 413: masque = (logical8) 1;
! 414:
! 415: if ((tampon & masque) == 0)
! 416: {
! 417: tampon >>= 1;
! 418: }
! 419: else
! 420: {
! 421: tampon >>= 1;
! 422: tampon |= (((logical8) 1) << (longueur - 1));
! 423: }
! 424:
! 425: for(masque = 0, i = 0; i < longueur; i++)
! 426: {
! 427: masque <<= 1;
! 428: masque |= 1;
! 429: }
! 430:
! 431: tampon &= masque;
! 432: (*((logical8 *) (*s_copie).objet)) = tampon;
! 433:
! 434: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 435: s_copie) == d_erreur)
! 436: {
! 437: return;
! 438: }
! 439: }
! 440: else
! 441: {
! 442: liberation(s_etat_processus, s_objet);
! 443:
! 444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 445: return;
! 446: }
! 447:
! 448: liberation(s_etat_processus, s_objet);
! 449:
! 450: return;
! 451: }
! 452:
! 453:
! 454: /*
! 455: ================================================================================
! 456: Fonction 'rrb'
! 457: ================================================================================
! 458: Entrées : pointeur sur une structure struct_processus
! 459: --------------------------------------------------------------------------------
! 460: Sorties :
! 461: --------------------------------------------------------------------------------
! 462: Effets de bord : néant
! 463: ================================================================================
! 464: */
! 465:
! 466: void
! 467: instruction_rrb(struct_processus *s_etat_processus)
! 468: {
! 469: struct_liste_chainee *l_base_pile;
! 470:
! 471: unsigned long i;
! 472:
! 473: (*s_etat_processus).erreur_execution = d_ex;
! 474:
! 475: if ((*s_etat_processus).affichage_arguments == 'Y')
! 476: {
! 477: printf("\n RRB ");
! 478:
! 479: if ((*s_etat_processus).langue == 'F')
! 480: {
! 481: printf("(rotation d'un octet vers la droite)\n\n");
! 482: }
! 483: else
! 484: {
! 485: printf("(rotate right byte)\n\n");
! 486: }
! 487:
! 488: printf(" 1: %s\n", d_BIN);
! 489: printf("-> 1: %s\n", d_BIN);
! 490:
! 491: return;
! 492: }
! 493: else if ((*s_etat_processus).test_instruction == 'Y')
! 494: {
! 495: (*s_etat_processus).nombre_arguments = -1;
! 496: return;
! 497: }
! 498:
! 499: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 500: {
! 501: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 502: {
! 503: return;
! 504: }
! 505: }
! 506:
! 507: l_base_pile = (*s_etat_processus).l_base_pile_last;
! 508: (*s_etat_processus).l_base_pile_last = NULL;
! 509:
! 510: for(i = 0; i < 8; i++)
! 511: {
! 512: instruction_rr(s_etat_processus);
! 513:
! 514: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 515: ((*s_etat_processus).erreur_execution != d_ex))
! 516: {
! 517: break;
! 518: }
! 519: }
! 520:
! 521: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 522: {
! 523: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 524: {
! 525: return;
! 526: }
! 527: }
! 528:
! 529: (*s_etat_processus).l_base_pile_last = l_base_pile;
! 530: return;
! 531: }
! 532:
! 533:
! 534: /*
! 535: ================================================================================
! 536: Fonction 'redraw'
! 537: ================================================================================
! 538: Entrées : pointeur sur une structure struct_processus
! 539: --------------------------------------------------------------------------------
! 540: Sorties :
! 541: --------------------------------------------------------------------------------
! 542: Effets de bord : néant
! 543: ================================================================================
! 544: */
! 545:
! 546: void
! 547: instruction_redraw(struct_processus *s_etat_processus)
! 548: {
! 549: (*s_etat_processus).erreur_execution = d_ex;
! 550:
! 551: if ((*s_etat_processus).affichage_arguments == 'Y')
! 552: {
! 553: printf("\n REDRAW ");
! 554:
! 555: if ((*s_etat_processus).langue == 'F')
! 556: {
! 557: printf("(redessine une courbe)\n\n");
! 558: printf(" Aucun argument\n");
! 559: }
! 560: else
! 561: {
! 562: printf("(redraw a graphic)\n\n");
! 563: printf(" No argument\n");
! 564: }
! 565:
! 566: return;
! 567: }
! 568: else if ((*s_etat_processus).test_instruction == 'Y')
! 569: {
! 570: (*s_etat_processus).nombre_arguments = -1;
! 571: return;
! 572: }
! 573:
! 574: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 575: {
! 576: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 577: {
! 578: return;
! 579: }
! 580: }
! 581:
! 582: if ((*s_etat_processus).mise_a_jour_trace_requise == d_vrai)
! 583: {
! 584: (*s_etat_processus).erreur_execution = d_ex_graphique_memorise;
! 585: return;
! 586: }
! 587:
! 588: if ((*s_etat_processus).fichiers_graphiques != NULL)
! 589: {
! 590: appel_gnuplot(s_etat_processus, 'N');
! 591: }
! 592:
! 593: return;
! 594: }
! 595:
! 596:
! 597: /*
! 598: ================================================================================
! 599: Fonction 'remove'
! 600: ================================================================================
! 601: Entrées : pointeur sur une structure struct_processus
! 602: --------------------------------------------------------------------------------
! 603: Sorties :
! 604: --------------------------------------------------------------------------------
! 605: Effets de bord : néant
! 606: ================================================================================
! 607: */
! 608:
! 609: void
! 610: instruction_remove(struct_processus *s_etat_processus)
! 611: {
! 612: struct_objet *s_objet_argument;
! 613:
! 614: (*s_etat_processus).erreur_execution = d_ex;
! 615:
! 616: if ((*s_etat_processus).affichage_arguments == 'Y')
! 617: {
! 618: printf("\n REMOVE ");
! 619:
! 620: if ((*s_etat_processus).langue == 'F')
! 621: {
! 622: printf("(retrait d'une bibliothèque dynamique)\n\n");
! 623: }
! 624: else
! 625: {
! 626: printf("(remove a shared library)\n\n");
! 627: }
! 628:
! 629: printf(" 1: %s\n", d_SLB);
! 630:
! 631: return;
! 632: }
! 633: else if ((*s_etat_processus).test_instruction == 'Y')
! 634: {
! 635: (*s_etat_processus).nombre_arguments = -1;
! 636: return;
! 637: }
! 638:
! 639: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 640: {
! 641: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 642: {
! 643: return;
! 644: }
! 645: }
! 646:
! 647: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 648: &s_objet_argument) == d_erreur)
! 649: {
! 650: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 651: return;
! 652: }
! 653:
! 654: if ((*s_objet_argument).type == SLB)
! 655: {
! 656: /*
! 657: * On ne décharge que les bibliothèques qui ont été chargées dans
! 658: * le couple pid/tid courant.
! 659: */
! 660:
! 661: if (((*((struct_bibliotheque *) (*s_objet_argument).objet)).pid ==
! 662: getpid()) && (pthread_equal((*((struct_bibliotheque *)
! 663: (*s_objet_argument).objet)).tid, pthread_self()) != 0))
! 664: {
! 665: if (retrait_bibliotheque(s_etat_processus,
! 666: (*s_objet_argument).objet) == d_erreur)
! 667: {
! 668: liberation(s_etat_processus, s_objet_argument);
! 669:
! 670: return;
! 671: }
! 672: }
! 673: }
! 674: else
! 675: {
! 676: liberation(s_etat_processus, s_objet_argument);
! 677:
! 678: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 679: return;
! 680: }
! 681:
! 682: liberation(s_etat_processus, s_objet_argument);
! 683:
! 684: return;
! 685: }
! 686:
! 687:
! 688: /*
! 689: ================================================================================
! 690: Fonction 'relax'
! 691: ================================================================================
! 692: Entrées : pointeur sur une structure struct_processus
! 693: --------------------------------------------------------------------------------
! 694: Sorties :
! 695: --------------------------------------------------------------------------------
! 696: Effets de bord : néant
! 697: ================================================================================
! 698: */
! 699:
! 700: void
! 701: instruction_relax(struct_processus *s_etat_processus)
! 702: {
! 703: (*s_etat_processus).erreur_execution = d_ex;
! 704:
! 705: if ((*s_etat_processus).affichage_arguments == 'Y')
! 706: {
! 707: printf("\n RELAX ");
! 708:
! 709: if ((*s_etat_processus).langue == 'F')
! 710: {
! 711: printf("(ne fait rien)\n\n");
! 712: printf(" Aucun argument\n");
! 713: }
! 714: else
! 715: {
! 716: printf("(do nothing)\n\n");
! 717: printf(" No argument\n");
! 718: }
! 719:
! 720: return;
! 721: }
! 722: else if ((*s_etat_processus).test_instruction == 'Y')
! 723: {
! 724: (*s_etat_processus).nombre_arguments = 1;
! 725: return;
! 726: }
! 727:
! 728: /*
! 729: * Cette instruction ne fait rien. Elle existe pour être symétrique
! 730: * à l'instruction CHS et permet de traiter les équations de façon
! 731: * simple (Ex : '+pi'). En principe, elle n'a pas a être appelée
! 732: * directement par l'utilisateur.
! 733: */
! 734:
! 735: return;
! 736: }
! 737:
! 738:
! 739: /*
! 740: ================================================================================
! 741: Fonction 'rewind'
! 742: ================================================================================
! 743: Entrées : pointeur sur une structure struct_processus
! 744: --------------------------------------------------------------------------------
! 745: Sorties :
! 746: --------------------------------------------------------------------------------
! 747: Effets de bord : néant
! 748: ================================================================================
! 749: */
! 750:
! 751: void
! 752: instruction_rewind(struct_processus *s_etat_processus)
! 753: {
! 754: file *descripteur;
! 755:
! 756: struct_objet *s_objet_argument;
! 757:
! 758: (*s_etat_processus).erreur_execution = d_ex;
! 759:
! 760: if ((*s_etat_processus).affichage_arguments == 'Y')
! 761: {
! 762: printf("\n REWIND ");
! 763:
! 764: if ((*s_etat_processus).langue == 'F')
! 765: {
! 766: printf("(retour au début d'un fichier)\n\n");
! 767: }
! 768: else
! 769: {
! 770: printf("(rewind a file)\n\n");
! 771: }
! 772:
! 773: printf(" 1: %s\n", d_FCH);
! 774:
! 775: return;
! 776: }
! 777: else if ((*s_etat_processus).test_instruction == 'Y')
! 778: {
! 779: (*s_etat_processus).nombre_arguments = -1;
! 780: return;
! 781: }
! 782:
! 783: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 784: {
! 785: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 786: {
! 787: return;
! 788: }
! 789: }
! 790:
! 791: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 792: &s_objet_argument) == d_erreur)
! 793: {
! 794: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 795: return;
! 796: }
! 797:
! 798: if ((*s_objet_argument).type == FCH)
! 799: {
! 800: if ((descripteur = descripteur_fichier(s_etat_processus,
! 801: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
! 802: {
! 803: return;
! 804: }
! 805:
! 806: if (fseek(descripteur, (long) 0, SEEK_SET) != 0)
! 807: {
! 808: liberation(s_etat_processus, s_objet_argument);
! 809:
! 810: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 811: return;
! 812: }
! 813: }
! 814: else
! 815: {
! 816: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 817: return;
! 818: }
! 819:
! 820: liberation(s_etat_processus, s_objet_argument);
! 821:
! 822: return;
! 823: }
! 824:
! 825:
! 826: /*
! 827: ================================================================================
! 828: Fonction 'read'
! 829: ================================================================================
! 830: Entrées : pointeur sur une structure struct_processus
! 831: --------------------------------------------------------------------------------
! 832: Sorties :
! 833: --------------------------------------------------------------------------------
! 834: Effets de bord : néant
! 835: ================================================================================
! 836: */
! 837:
! 838: void
! 839: instruction_read(struct_processus *s_etat_processus)
! 840: {
! 841: file *descripteur;
! 842:
! 843: logical1 indicateur_48;
! 844: logical1 presence_chaine;
! 845: logical1 presence_indicateur;
! 846:
! 847: long longueur_effective;
! 848: long longueur_enregistrement;
! 849: long longueur_questure;
! 850: long niveau;
! 851: long pointeur;
! 852: long position_finale;
! 853: long position_initiale;
! 854:
! 855: socklen_t longueur_adresse;
! 856:
! 857: struct flock lock;
! 858:
! 859: struct sockaddr_un adresse_unix;
! 860: struct sockaddr_in adresse_ipv4;
! 861: struct sockaddr_in6 adresse_ipv6;
! 862:
! 863: struct timespec attente;
! 864:
! 865: struct_objet *s_objet_adresse;
! 866: struct_objet *s_objet_argument;
! 867: struct_objet *s_objet_resultat;
! 868: struct_objet *s_objet_type;
! 869:
! 870: unsigned char caractere;
! 871: unsigned char *tampon_lecture;
! 872: unsigned char *tampon;
! 873:
! 874: unsigned long i;
! 875:
! 876: (*s_etat_processus).erreur_execution = d_ex;
! 877:
! 878: attente.tv_sec = 0;
! 879: attente.tv_nsec = GRANULARITE_us * 1000;
! 880:
! 881: if ((*s_etat_processus).affichage_arguments == 'Y')
! 882: {
! 883: printf("\n READ ");
! 884:
! 885: if ((*s_etat_processus).langue == 'F')
! 886: {
! 887: printf("(lecture d'un enregistrement d'un fichier)\n\n");
! 888: }
! 889: else
! 890: {
! 891: printf("(read a record of a file)\n\n");
! 892: }
! 893:
! 894: printf(" 1: %s, %s\n", d_FCH, d_SCK);
! 895: printf(" To be fixed !\n");
! 896:
! 897: return;
! 898: }
! 899: else if ((*s_etat_processus).test_instruction == 'Y')
! 900: {
! 901: (*s_etat_processus).nombre_arguments = -1;
! 902: return;
! 903: }
! 904:
! 905: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 906: {
! 907: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 908: {
! 909: return;
! 910: }
! 911: }
! 912:
! 913: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 914: &s_objet_argument) == d_erreur)
! 915: {
! 916: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 917: return;
! 918: }
! 919:
! 920: if ((*s_objet_argument).type == FCH)
! 921: {
! 922: /*
! 923: * Vérification des verrous
! 924: */
! 925:
! 926: lock.l_type = F_RDLCK;
! 927: lock.l_whence = SEEK_SET;
! 928: lock.l_start = 0;
! 929: lock.l_len = 0;
! 930: lock.l_pid = getpid();
! 931:
! 932: if ((descripteur = descripteur_fichier(s_etat_processus,
! 933: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
! 934: {
! 935: return;
! 936: }
! 937:
! 938: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
! 939: {
! 940: liberation(s_etat_processus, s_objet_argument);
! 941:
! 942: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 943: return;
! 944: }
! 945:
! 946: if (lock.l_type != F_UNLCK)
! 947: {
! 948: liberation(s_etat_processus, s_objet_argument);
! 949:
! 950: (*s_etat_processus).erreur_execution =
! 951: d_ex_fichier_verrouille;
! 952: return;
! 953: }
! 954:
! 955: /*
! 956: * Vérification de l'autorisation de lecture
! 957: */
! 958:
! 959: if ((*((struct_fichier *) (*s_objet_argument).objet)).protection == 'W')
! 960: {
! 961: liberation(s_etat_processus, s_objet_argument);
! 962:
! 963: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
! 964: return;
! 965: }
! 966: else if ((*((struct_fichier *) (*s_objet_argument).objet)).protection
! 967: == 'N')
! 968: {
! 969: if (fflush(descripteur) != 0)
! 970: {
! 971: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 972: return;
! 973: }
! 974: }
! 975:
! 976: if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire == 'N')
! 977: {
! 978: /*
! 979: * Fichiers formatés
! 980: */
! 981:
! 982: if ((*((struct_fichier *) (*s_objet_argument).objet)).acces == 'S')
! 983: {
! 984: /*
! 985: * Fichiers séquentiels
! 986: */
! 987:
! 988: longueur_questure = 256;
! 989:
! 990: if ((tampon_lecture = malloc(longueur_questure *
! 991: sizeof(unsigned char))) == NULL)
! 992: {
! 993: (*s_etat_processus).erreur_systeme =
! 994: d_es_allocation_memoire;
! 995: return;
! 996: }
! 997:
! 998: if ((position_initiale = ftell(descripteur)) == -1)
! 999: {
! 1000: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 1001: return;
! 1002: }
! 1003:
! 1004: do
! 1005: {
! 1006: longueur_effective = fread(tampon_lecture,
! 1007: (size_t) sizeof(unsigned char), longueur_questure,
! 1008: descripteur);
! 1009:
! 1010: pointeur = 0;
! 1011: presence_indicateur = d_faux;
! 1012:
! 1013: while(pointeur < longueur_effective)
! 1014: {
! 1015: if (tampon_lecture[pointeur] == '{')
! 1016: {
! 1017: presence_indicateur = d_vrai;
! 1018: break;
! 1019: }
! 1020:
! 1021: position_initiale++;
! 1022: pointeur++;
! 1023: }
! 1024:
! 1025: if (presence_indicateur == d_vrai)
! 1026: {
! 1027: break;
! 1028: }
! 1029: } while(longueur_effective == longueur_questure);
! 1030:
! 1031: if (presence_indicateur == d_faux)
! 1032: {
! 1033: liberation(s_etat_processus, s_objet_argument);
! 1034: free(tampon_lecture);
! 1035:
! 1036: (*s_etat_processus).erreur_execution =
! 1037: d_ex_fin_de_fichier_atteinte;
! 1038: return;
! 1039: }
! 1040:
! 1041: position_finale = position_initiale + 1;
! 1042: presence_chaine = d_faux;
! 1043: niveau = 1;
! 1044:
! 1045: if (fseek(descripteur, position_finale, SEEK_SET) != 0)
! 1046: {
! 1047: liberation(s_etat_processus, s_objet_argument);
! 1048: free(tampon_lecture);
! 1049:
! 1050: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 1051: return;
! 1052: }
! 1053:
! 1054: do
! 1055: {
! 1056: longueur_effective = fread(tampon_lecture,
! 1057: (size_t) sizeof(unsigned char), longueur_questure,
! 1058: descripteur);
! 1059:
! 1060: pointeur = 0;
! 1061: presence_indicateur = d_faux;
! 1062:
! 1063: while(pointeur < longueur_effective)
! 1064: {
! 1065: if (tampon_lecture[pointeur] == '"')
! 1066: {
! 1067: presence_chaine = (presence_chaine == d_vrai)
! 1068: ? d_faux : d_vrai;
! 1069: }
! 1070: else
! 1071: {
! 1072: if (presence_chaine == d_faux)
! 1073: {
! 1074: if (tampon_lecture[pointeur] == '{')
! 1075: {
! 1076: niveau++;
! 1077: }
! 1078: else if (tampon_lecture[pointeur] == '}')
! 1079: {
! 1080: niveau--;
! 1081: }
! 1082: }
! 1083: }
! 1084:
! 1085: position_finale++;
! 1086: pointeur++;
! 1087:
! 1088: if (niveau == 0)
! 1089: {
! 1090: presence_indicateur = d_vrai;
! 1091: break;
! 1092: }
! 1093: }
! 1094:
! 1095: if (presence_indicateur == d_vrai)
! 1096: {
! 1097: break;
! 1098: }
! 1099: } while(longueur_effective == longueur_questure);
! 1100:
! 1101: if (presence_indicateur == d_faux)
! 1102: {
! 1103: liberation(s_etat_processus, s_objet_argument);
! 1104: free(tampon_lecture);
! 1105:
! 1106: (*s_etat_processus).erreur_execution =
! 1107: d_ex_fin_de_fichier_atteinte;
! 1108: return;
! 1109: }
! 1110:
! 1111: free(tampon_lecture);
! 1112: longueur_enregistrement = position_finale - position_initiale;
! 1113:
! 1114: if ((tampon_lecture = malloc((longueur_enregistrement + 1) *
! 1115: sizeof(unsigned char))) == NULL)
! 1116: {
! 1117: (*s_etat_processus).erreur_systeme =
! 1118: d_es_allocation_memoire;
! 1119: return;
! 1120: }
! 1121:
! 1122: if (fseek(descripteur, position_initiale, SEEK_SET) != 0)
! 1123: {
! 1124: liberation(s_etat_processus, s_objet_argument);
! 1125: free(tampon_lecture);
! 1126:
! 1127: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 1128: return;
! 1129: }
! 1130:
! 1131: longueur_effective = fread(tampon_lecture,
! 1132: (size_t) sizeof(unsigned char),
! 1133: (size_t) longueur_enregistrement,
! 1134: descripteur);
! 1135:
! 1136: if (longueur_effective != longueur_enregistrement)
! 1137: {
! 1138: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 1139: return;
! 1140: }
! 1141:
! 1142: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
! 1143: tampon = (*s_etat_processus).instruction_courante;
! 1144: (*s_etat_processus).instruction_courante = tampon_lecture;
! 1145:
! 1146: indicateur_48 = test_cfsf(s_etat_processus, 48);
! 1147: cf(s_etat_processus, 48);
! 1148:
! 1149: recherche_type(s_etat_processus);
! 1150:
! 1151: if ((*s_etat_processus).erreur_execution != d_ex)
! 1152: {
! 1153: (*s_etat_processus).instruction_courante = tampon;
! 1154: free(tampon_lecture);
! 1155:
! 1156: liberation(s_etat_processus, s_objet_argument);
! 1157:
! 1158: return;
! 1159: }
! 1160:
! 1161: if (indicateur_48 == d_vrai)
! 1162: {
! 1163: sf(s_etat_processus, 48);
! 1164: }
! 1165: else
! 1166: {
! 1167: cf(s_etat_processus, 48);
! 1168: }
! 1169:
! 1170: (*s_etat_processus).instruction_courante = tampon;
! 1171: free(tampon_lecture);
! 1172: }
! 1173: else if ((*((struct_fichier *) (*s_objet_argument).objet)).acces
! 1174: == 'D')
! 1175: {
! 1176: }
! 1177: else
! 1178: {
! 1179: }
! 1180: }
! 1181: else if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire
! 1182: == 'Y')
! 1183: {
! 1184: /*
! 1185: * Fichiers non formatés
! 1186: */
! 1187: }
! 1188: else
! 1189: {
! 1190: /*
! 1191: * Fichiers de type FLOW
! 1192: */
! 1193: }
! 1194: }
! 1195: else if ((*s_objet_argument).type == SCK)
! 1196: {
! 1197: /*
! 1198: * Vérification de l'autorisation de lecture
! 1199: */
! 1200:
! 1201: if ((*((struct_socket *) (*s_objet_argument).objet)).protection == 'W')
! 1202: {
! 1203: liberation(s_etat_processus, s_objet_argument);
! 1204:
! 1205: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
! 1206: return;
! 1207: }
! 1208:
! 1209: /*
! 1210: * Vérification de l'écoute de la socket si celle-ci est connectée
! 1211: */
! 1212:
! 1213: if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type,
! 1214: "STREAM") == 0) || (strcmp((*((struct_socket *)
! 1215: (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") == 0))
! 1216: {
! 1217: if ((*((struct_socket *) (*s_objet_argument).objet))
! 1218: .socket_en_ecoute == 'Y')
! 1219: {
! 1220: liberation(s_etat_processus, s_objet_argument);
! 1221:
! 1222: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
! 1223: return;
! 1224: }
! 1225: }
! 1226:
! 1227: if ((*((struct_socket *) (*s_objet_argument).objet)).binaire == 'N')
! 1228: { // Socket formatée
! 1229: longueur_questure = 256;
! 1230:
! 1231: do
! 1232: {
! 1233: if ((tampon_lecture = malloc((longueur_questure + 1) *
! 1234: sizeof(unsigned char))) == NULL)
! 1235: {
! 1236: (*s_etat_processus).erreur_systeme =
! 1237: d_es_allocation_memoire;
! 1238: return;
! 1239: }
! 1240:
! 1241: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1242: {
! 1243: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1244: return;
! 1245: }
! 1246:
! 1247: for(;;)
! 1248: {
! 1249: if ((*((struct_socket *) (*s_objet_argument).objet)).domaine
! 1250: == PF_UNIX)
! 1251: {
! 1252: longueur_adresse = sizeof(adresse_unix);
! 1253: longueur_effective = recvfrom((*((struct_socket *)
! 1254: (*s_objet_argument).objet)).socket,
! 1255: tampon_lecture, longueur_questure,
! 1256: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
! 1257: &adresse_unix, &longueur_adresse);
! 1258: }
! 1259: else if ((*((struct_socket *) (*s_objet_argument).objet))
! 1260: .domaine == PF_INET)
! 1261: {
! 1262: longueur_adresse = sizeof(adresse_ipv4);
! 1263: longueur_effective = recvfrom((*((struct_socket *)
! 1264: (*s_objet_argument).objet)).socket,
! 1265: tampon_lecture, longueur_questure,
! 1266: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
! 1267: &adresse_ipv4, &longueur_adresse);
! 1268: }
! 1269: else if ((*((struct_socket *) (*s_objet_argument).objet))
! 1270: .domaine == PF_INET6)
! 1271: {
! 1272: longueur_adresse = sizeof(adresse_ipv6);
! 1273: longueur_effective = recvfrom((*((struct_socket *)
! 1274: (*s_objet_argument).objet)).socket,
! 1275: tampon_lecture, longueur_questure,
! 1276: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
! 1277: &adresse_ipv6, &longueur_adresse);
! 1278: }
! 1279: else
! 1280: {
! 1281: free(tampon_lecture);
! 1282: liberation(s_etat_processus, s_objet_argument);
! 1283:
! 1284: while(sem_wait(&((*s_etat_processus)
! 1285: .semaphore_fork)) == -1)
! 1286: {
! 1287: if (errno != EINTR)
! 1288: {
! 1289: (*s_etat_processus).erreur_systeme =
! 1290: d_es_processus;
! 1291: return;
! 1292: }
! 1293: }
! 1294:
! 1295: (*s_etat_processus).erreur_execution =
! 1296: d_ex_erreur_acces_fichier;
! 1297: return;
! 1298: }
! 1299:
! 1300: if (longueur_effective < 0)
! 1301: {
! 1302: nanosleep(&attente, NULL);
! 1303: scrutation_injection(s_etat_processus);
! 1304: }
! 1305:
! 1306: if (((*s_etat_processus).var_volatile_requete_arret == -1)
! 1307: || (longueur_effective >= 0))
! 1308: {
! 1309: break;
! 1310: }
! 1311: }
! 1312:
! 1313: while(sem_wait(&((*s_etat_processus).semaphore_fork))
! 1314: == -1)
! 1315: {
! 1316: if (errno != EINTR)
! 1317: {
! 1318: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1319: return;
! 1320: }
! 1321: }
! 1322:
! 1323: if ((*s_etat_processus).var_volatile_requete_arret == -1)
! 1324: {
! 1325:
! 1326: /*
! 1327: * Si le père tue le processus courant grâce au signal
! 1328: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
! 1329: * correspond à l'utilisation de STOP sur le processus
! 1330: * en cours. La variable longueur_effective vaut '-1'.
! 1331: */
! 1332:
! 1333: free(tampon_lecture);
! 1334: liberation(s_etat_processus, s_objet_argument);
! 1335: return;
! 1336: }
! 1337:
! 1338: if (longueur_effective == -1)
! 1339: {
! 1340: free(tampon_lecture);
! 1341: liberation(s_etat_processus, s_objet_argument);
! 1342:
! 1343: (*s_etat_processus).erreur_execution =
! 1344: d_ex_erreur_acces_fichier;
! 1345: return;
! 1346: }
! 1347:
! 1348: position_initiale = 0;
! 1349: presence_indicateur = d_faux;
! 1350:
! 1351: do
! 1352: {
! 1353: if (tampon_lecture[position_initiale] == '{')
! 1354: {
! 1355: presence_indicateur = d_vrai;
! 1356: break;
! 1357: }
! 1358:
! 1359: position_initiale++;
! 1360: } while(position_initiale < longueur_effective);
! 1361:
! 1362:
! 1363: if (presence_indicateur == d_vrai)
! 1364: {
! 1365: position_finale = position_initiale + 1;
! 1366: presence_chaine = d_faux;
! 1367: presence_indicateur = d_faux;
! 1368: niveau = 1;
! 1369:
! 1370: while(position_finale < longueur_effective)
! 1371: {
! 1372: caractere = tampon_lecture[position_finale];
! 1373:
! 1374: if (caractere == '"')
! 1375: {
! 1376: presence_chaine = (presence_chaine == d_vrai)
! 1377: ? d_faux : d_vrai;
! 1378: }
! 1379: else
! 1380: {
! 1381: if (presence_chaine == d_faux)
! 1382: {
! 1383: if (caractere == '{')
! 1384: {
! 1385: niveau++;
! 1386: }
! 1387: else if (caractere == '}')
! 1388: {
! 1389: niveau--;
! 1390: }
! 1391: }
! 1392: }
! 1393:
! 1394: if (niveau == 0)
! 1395: {
! 1396: presence_indicateur = d_vrai;
! 1397: break;
! 1398: }
! 1399:
! 1400: position_finale++;
! 1401: }
! 1402: }
! 1403:
! 1404: if (presence_indicateur == d_faux)
! 1405: {
! 1406: if (longueur_effective < longueur_questure)
! 1407: {
! 1408: liberation(s_etat_processus, s_objet_argument);
! 1409: free(tampon_lecture);
! 1410:
! 1411: (*s_etat_processus).erreur_execution =
! 1412: d_ex_fin_de_fichier_atteinte;
! 1413: return;
! 1414: }
! 1415:
! 1416: free(tampon_lecture);
! 1417: longueur_questure *= 2;
! 1418: }
! 1419: } while(presence_indicateur == d_faux);
! 1420:
! 1421: tampon_lecture[++position_finale] = d_code_fin_chaine;
! 1422: tampon = (*s_etat_processus).instruction_courante;
! 1423: (*s_etat_processus).instruction_courante = &(tampon_lecture
! 1424: [position_initiale]);
! 1425:
! 1426: indicateur_48 = test_cfsf(s_etat_processus, 48);
! 1427: cf(s_etat_processus, 48);
! 1428:
! 1429: recherche_type(s_etat_processus);
! 1430:
! 1431: if ((*s_etat_processus).erreur_execution != d_ex)
! 1432: {
! 1433: (*s_etat_processus).instruction_courante = tampon;
! 1434: free(tampon_lecture);
! 1435:
! 1436: liberation(s_etat_processus, s_objet_argument);
! 1437:
! 1438: return;
! 1439: }
! 1440:
! 1441: if (indicateur_48 == d_vrai)
! 1442: {
! 1443: sf(s_etat_processus, 48);
! 1444: }
! 1445: else
! 1446: {
! 1447: cf(s_etat_processus, 48);
! 1448: }
! 1449:
! 1450: (*s_etat_processus).instruction_courante = tampon;
! 1451:
! 1452: /*
! 1453: * Création de la liste de sortie
! 1454: */
! 1455:
! 1456: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1457: &s_objet_type) == d_erreur)
! 1458: {
! 1459: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1460: return;
! 1461: }
! 1462:
! 1463: if ((s_objet_resultat = allocation(s_etat_processus, LST))
! 1464: == NULL)
! 1465: {
! 1466: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1467: return;
! 1468: }
! 1469:
! 1470: if (((*s_objet_resultat).objet =
! 1471: allocation_maillon(s_etat_processus)) == NULL)
! 1472: {
! 1473: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1474: return;
! 1475: }
! 1476:
! 1477: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
! 1478: .donnee = s_objet_type;
! 1479:
! 1480: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
! 1481: .suivant = allocation_maillon(s_etat_processus)) == NULL)
! 1482: {
! 1483: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1484: return;
! 1485: }
! 1486:
! 1487: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
! 1488: .suivant = NULL;
! 1489:
! 1490: if ((s_objet_adresse = allocation(s_etat_processus, LST))
! 1491: == NULL)
! 1492: {
! 1493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1494: return;
! 1495: }
! 1496:
! 1497: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
! 1498: .donnee = s_objet_adresse;
! 1499:
! 1500: /*
! 1501: * Les informations concernant la cible sont valides si
! 1502: * la socket est non connectée et des domaines INET ou INET6.
! 1503: * Dans tous les autres cas, on renvoie une liste vide.
! 1504: */
! 1505:
! 1506: if (((*((struct_socket *) (*s_objet_argument).objet)).domaine
! 1507: == PF_UNIX) || (strcmp((*((struct_socket *)
! 1508: (*s_objet_argument).objet)).type, "STREAM") == 0) ||
! 1509: (strcmp((*((struct_socket *) (*s_objet_argument).objet))
! 1510: .type, "SEQUENTIAL DATAGRAM") == 0))
! 1511: {
! 1512: longueur_adresse = 0;
! 1513: recvfrom((*((struct_socket *)
! 1514: (*s_objet_argument).objet)).socket, tampon_lecture,
! 1515: position_finale, MSG_DONTWAIT,
! 1516: NULL, &longueur_adresse);
! 1517:
! 1518: (*s_objet_adresse).objet = NULL;
! 1519: }
! 1520: else if ((*((struct_socket *) (*s_objet_argument).objet))
! 1521: .domaine == PF_INET)
! 1522: {
! 1523: longueur_adresse = sizeof(adresse_ipv4);
! 1524: recvfrom((*((struct_socket *)
! 1525: (*s_objet_argument).objet)).socket, tampon_lecture,
! 1526: position_finale, MSG_DONTWAIT,
! 1527: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
! 1528:
! 1529: if (((*s_objet_adresse).objet =
! 1530: allocation_maillon(s_etat_processus)) == NULL)
! 1531: {
! 1532: (*s_etat_processus).erreur_systeme =
! 1533: d_es_allocation_memoire;
! 1534: return;
! 1535: }
! 1536:
! 1537: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1538: .donnee = allocation(s_etat_processus, VIN)) == NULL)
! 1539: {
! 1540: (*s_etat_processus).erreur_systeme =
! 1541: d_es_allocation_memoire;
! 1542: return;
! 1543: }
! 1544:
! 1545: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 1546: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
! 1547:
! 1548: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 1549: (*s_objet_adresse).objet)).donnee).objet)).tableau =
! 1550: malloc(4 * sizeof(integer8))) == NULL)
! 1551: {
! 1552: (*s_etat_processus).erreur_systeme =
! 1553: d_es_allocation_memoire;
! 1554: return;
! 1555: }
! 1556:
! 1557: ((integer8 *) (*((struct_vecteur *)
! 1558: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 1559: .objet)).donnee).objet)).tableau)[0] =
! 1560: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
! 1561: ((integer8 *) (*((struct_vecteur *)
! 1562: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 1563: .objet)).donnee).objet)).tableau)[1] =
! 1564: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
! 1565: ((integer8 *) (*((struct_vecteur *)
! 1566: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 1567: .objet)).donnee).objet)).tableau)[2] =
! 1568: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
! 1569: ((integer8 *) (*((struct_vecteur *)
! 1570: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 1571: .objet)).donnee).objet)).tableau)[3] =
! 1572: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
! 1573:
! 1574: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1575: .suivant = allocation_maillon(s_etat_processus))
! 1576: == NULL)
! 1577: {
! 1578: (*s_etat_processus).erreur_systeme =
! 1579: d_es_allocation_memoire;
! 1580: return;
! 1581: }
! 1582:
! 1583: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1584: .suivant).donnee = allocation(s_etat_processus, INT))
! 1585: == NULL)
! 1586: {
! 1587: (*s_etat_processus).erreur_systeme =
! 1588: d_es_allocation_memoire;
! 1589: return;
! 1590: }
! 1591:
! 1592: (*((integer8 *) (*(*(*((struct_liste_chainee *)
! 1593: (*s_objet_adresse) .objet)).suivant).donnee).objet)) =
! 1594: (integer8) ntohs(adresse_ipv4.sin_port);
! 1595:
! 1596: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1597: .suivant).suivant = NULL;
! 1598: }
! 1599: else if ((*((struct_socket *) (*s_objet_argument).objet))
! 1600: .domaine == PF_INET6)
! 1601: {
! 1602: longueur_adresse = sizeof(adresse_ipv6);
! 1603: recvfrom((*((struct_socket *)
! 1604: (*s_objet_argument).objet)).socket, tampon_lecture,
! 1605: position_finale, MSG_DONTWAIT,
! 1606: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
! 1607:
! 1608: if (((*s_objet_adresse).objet =
! 1609: allocation_maillon(s_etat_processus)) == NULL)
! 1610: {
! 1611: (*s_etat_processus).erreur_systeme =
! 1612: d_es_allocation_memoire;
! 1613: return;
! 1614: }
! 1615:
! 1616: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1617: .donnee = allocation(s_etat_processus, VIN)) == NULL)
! 1618: {
! 1619: (*s_etat_processus).erreur_systeme =
! 1620: d_es_allocation_memoire;
! 1621: return;
! 1622: }
! 1623:
! 1624: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 1625: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
! 1626:
! 1627: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
! 1628: (*s_objet_adresse).objet)).donnee).objet)).tableau =
! 1629: malloc(16 * sizeof(integer8))) == NULL)
! 1630: {
! 1631: (*s_etat_processus).erreur_systeme =
! 1632: d_es_allocation_memoire;
! 1633: return;
! 1634: }
! 1635:
! 1636: for(i = 0; i < 16; i++)
! 1637: {
! 1638: ((integer8 *) (*((struct_vecteur *)
! 1639: (*(*((struct_liste_chainee *) (*s_objet_adresse)
! 1640: .objet)).donnee).objet)).tableau)[0] =
! 1641: adresse_ipv6.sin6_addr.s6_addr[i];
! 1642: }
! 1643:
! 1644: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1645: .suivant = allocation_maillon(s_etat_processus))
! 1646: == NULL)
! 1647: {
! 1648: (*s_etat_processus).erreur_systeme =
! 1649: d_es_allocation_memoire;
! 1650: return;
! 1651: }
! 1652:
! 1653: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1654: .suivant).donnee = allocation(s_etat_processus, INT))
! 1655: == NULL)
! 1656: {
! 1657: (*s_etat_processus).erreur_systeme =
! 1658: d_es_allocation_memoire;
! 1659: return;
! 1660: }
! 1661:
! 1662: (*((integer8 *) (*(*(*((struct_liste_chainee *)
! 1663: (*s_objet_adresse) .objet)).suivant).donnee).objet)) =
! 1664: (integer8) ntohs(adresse_ipv6.sin6_port);
! 1665:
! 1666: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
! 1667: .suivant).suivant = NULL;
! 1668: }
! 1669: else
! 1670: {
! 1671: longueur_adresse = 0;
! 1672: recvfrom((*((struct_socket *)
! 1673: (*s_objet_argument).objet)).socket, tampon_lecture,
! 1674: position_finale, MSG_DONTWAIT,
! 1675: NULL, &longueur_adresse);
! 1676: }
! 1677:
! 1678: free(tampon_lecture);
! 1679:
! 1680: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1681: s_objet_resultat) == d_erreur)
! 1682: {
! 1683: return;
! 1684: }
! 1685: }
! 1686: else
! 1687: {
! 1688: /* FLOW ou UNFORMATTED */
! 1689: }
! 1690: }
! 1691: else
! 1692: {
! 1693: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1694: return;
! 1695: }
! 1696:
! 1697: liberation(s_etat_processus, s_objet_argument);
! 1698:
! 1699: return;
! 1700: }
! 1701:
! 1702: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_r4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src