![]() ![]() | ![]() |
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 'recv' 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_recv(struct_processus *s_etat_processus) 40: { 41: integer8 nombre_donnees; 42: 43: sig_atomic_t registre_stop; 44: 45: ssize_t longueur_ecriture; 46: 47: struct_liste_chainee *l_element_courant; 48: 49: struct_objet *s_objet_argument; 50: struct_objet *s_objet_resultat; 51: 52: struct sigaction action; 53: struct sigaction registre; 54: 55: (*s_etat_processus).erreur_execution = d_ex; 56: 57: if ((*s_etat_processus).affichage_arguments == 'Y') 58: { 59: printf("\n RECV "); 60: 61: if ((*s_etat_processus).langue == 'F') 62: { 63: printf("(réception de données d'un processus fils)\n\n"); 64: } 65: else 66: { 67: printf("(data reception from child process)\n\n"); 68: } 69: 70: printf(" 1: %s\n", d_PRC); 71: printf("-> 1: %s (0)\n\n", d_INT); 72: 73: printf(" 1: %s\n", d_PRC); 74: printf("-> 2: %s, %s, %s, %s, %s, %s,\n" 75: " %s, %s, %s, %s, %s,\n" 76: " %s, %s, %s, %s\n", 77: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 78: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN); 79: printf(" 1: %s (-1)\n", d_INT); 80: 81: return; 82: } 83: else if ((*s_etat_processus).test_instruction == 'Y') 84: { 85: (*s_etat_processus).nombre_arguments = -1; 86: return; 87: } 88: 89: if (test_cfsf(s_etat_processus, 31) == d_vrai) 90: { 91: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 92: { 93: return; 94: } 95: } 96: 97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 98: &s_objet_argument) == d_erreur) 99: { 100: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 101: return; 102: } 103: 104: if ((*s_objet_argument).type == PRC) 105: { 106: /* 107: * Le champ de la structure nombre_objets_dans_pipe à jour 108: * est celui présent dans *s_etat_processus et non celui 109: * de la structure présente dans la pile opérationnelle. 110: */ 111: 112: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) 113: { 114: (*s_etat_processus).erreur_systeme_processus_fils = 115: d_es_processus; 116: return; 117: } 118: 119: l_element_courant = (struct_liste_chainee *) 120: (*s_etat_processus).l_base_pile_processus; 121: nombre_donnees = -1; 122: 123: while(l_element_courant != NULL) 124: { 125: if ((*(*((struct_processus_fils *) (*s_objet_argument).objet)) 126: .thread).processus_detache == d_vrai) 127: { 128: if ((*(*((struct_processus_fils *) (*(*l_element_courant) 129: .donnee).objet)).thread).processus_detache == d_faux) 130: { 131: l_element_courant = (*l_element_courant).suivant; 132: continue; 133: } 134: 135: if ((*(*((struct_processus_fils *) (*s_objet_argument).objet)) 136: .thread).pid == (*(*((struct_processus_fils *) 137: (*(*l_element_courant).donnee).objet)).thread).pid) 138: { 139: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 140: (*s_objet_argument).objet)).thread).mutex)) != 0) 141: { 142: (*s_etat_processus).erreur_systeme = d_es_processus; 143: return; 144: } 145: 146: nombre_donnees = (*(*((struct_processus_fils *) 147: (*(*l_element_courant).donnee).objet)).thread) 148: .nombre_objets_dans_pipe; 149: 150: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 151: (*s_objet_argument).objet)).thread).mutex)) != 0) 152: { 153: (*s_etat_processus).erreur_systeme = d_es_processus; 154: return; 155: } 156: 157: break; 158: } 159: } 160: else 161: { 162: if ((*(*((struct_processus_fils *) (*(*l_element_courant) 163: .donnee).objet)).thread).processus_detache == d_vrai) 164: { 165: l_element_courant = (*l_element_courant).suivant; 166: continue; 167: } 168: 169: if ((pthread_equal((*(*((struct_processus_fils *) 170: (*s_objet_argument).objet)).thread).tid, 171: (*(*((struct_processus_fils *) (*(*l_element_courant) 172: .donnee).objet)).thread).tid) != 0) && 173: ((*(*((struct_processus_fils *) 174: (*s_objet_argument).objet)).thread).pid == 175: (*(*((struct_processus_fils *) (*(*l_element_courant) 176: .donnee).objet)).thread).pid)) 177: { 178: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 179: (*s_objet_argument).objet)).thread).mutex)) != 0) 180: { 181: (*s_etat_processus).erreur_systeme = d_es_processus; 182: return; 183: } 184: 185: nombre_donnees = (*(*((struct_processus_fils *) 186: (*(*l_element_courant).donnee).objet)).thread) 187: .nombre_objets_dans_pipe; 188: 189: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 190: (*s_objet_argument).objet)).thread).mutex)) != 0) 191: { 192: (*s_etat_processus).erreur_systeme = d_es_processus; 193: return; 194: } 195: 196: break; 197: } 198: } 199: 200: l_element_courant = (*l_element_courant).suivant; 201: } 202: 203: /* 204: * 0 : aucune donnée dans le pipe du processus. 205: * -1 : processus absent de la pile 206: */ 207: 208: if (nombre_donnees == -1) 209: { 210: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 211: { 212: (*s_etat_processus).erreur_systeme_processus_fils = 213: d_es_processus; 214: return; 215: } 216: 217: (*s_etat_processus).erreur_execution = d_ex_processus; 218: return; 219: } 220: else if (nombre_donnees == 0) 221: { 222: /* 223: * On empile une valeur nulle 224: */ 225: 226: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 227: { 228: (*s_etat_processus).erreur_systeme_processus_fils = 229: d_es_processus; 230: return; 231: } 232: 233: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 234: == NULL) 235: { 236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 237: return; 238: } 239: 240: (*((integer8 *) (*s_objet_resultat).objet)) = 0; 241: 242: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 243: s_objet_resultat) == d_erreur) 244: { 245: return; 246: } 247: 248: liberation(s_etat_processus, s_objet_argument); 249: 250: return; 251: } 252: 253: registre_stop = (*s_etat_processus) 254: .var_volatile_traitement_retarde_stop; 255: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1; 256: 257: if ((*s_etat_processus).profilage == d_vrai) 258: { 259: profilage(s_etat_processus, "Interprocess or interthread " 260: "communications (RECV)"); 261: 262: if ((*s_etat_processus).erreur_systeme != d_es) 263: { 264: return; 265: } 266: } 267: 268: # ifndef SEMAPHORES_NOMMES 269: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 270: { 271: (*s_etat_processus).erreur_systeme = d_es_processus; 272: return; 273: } 274: # else 275: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 276: { 277: (*s_etat_processus).erreur_systeme = d_es_processus; 278: return; 279: } 280: # endif 281: 282: if ((s_objet_resultat = lecture_pipe(s_etat_processus, 283: (*(*((struct_processus_fils *) (*s_objet_argument).objet)) 284: .thread).pipe_objets[0])) == NULL) 285: { 286: # ifndef SEMAPHORES_NOMMES 287: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 288: # else 289: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 290: # endif 291: { 292: if (errno != EINTR) 293: { 294: (*s_etat_processus).erreur_systeme = d_es_processus; 295: return; 296: } 297: } 298: 299: if (registre_stop == 0) 300: { 301: if ((*s_etat_processus).var_volatile_traitement_retarde_stop 302: == -1) 303: { 304: (*s_etat_processus).var_volatile_requete_arret = -1; 305: } 306: 307: (*s_etat_processus).var_volatile_traitement_retarde_stop 308: = registre_stop; 309: } 310: 311: if ((*s_etat_processus).profilage == d_vrai) 312: { 313: profilage(s_etat_processus, NULL); 314: } 315: 316: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 317: return; 318: } 319: 320: # ifndef SEMAPHORES_NOMMES 321: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 322: # else 323: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 324: # endif 325: { 326: if (errno != EINTR) 327: { 328: (*s_etat_processus).erreur_systeme = d_es_processus; 329: return; 330: } 331: } 332: 333: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 334: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0) 335: { 336: (*s_etat_processus).erreur_systeme = d_es_processus; 337: return; 338: } 339: 340: (*(*((struct_processus_fils *) (*(*l_element_courant).donnee).objet)) 341: .thread).nombre_objets_dans_pipe--; 342: 343: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 344: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0) 345: { 346: (*s_etat_processus).erreur_systeme = d_es_processus; 347: return; 348: } 349: 350: action.sa_handler = SIG_IGN; 351: action.sa_flags = SA_ONSTACK; 352: 353: if (sigaction(SIGPIPE, &action, ®istre) != 0) 354: { 355: if (registre_stop == 0) 356: { 357: if ((*s_etat_processus).var_volatile_traitement_retarde_stop 358: == -1) 359: { 360: (*s_etat_processus).var_volatile_requete_arret = -1; 361: } 362: 363: (*s_etat_processus).var_volatile_traitement_retarde_stop 364: = registre_stop; 365: } 366: 367: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 368: 369: if ((*s_etat_processus).profilage == d_vrai) 370: { 371: profilage(s_etat_processus, NULL); 372: } 373: 374: (*s_etat_processus).erreur_systeme = d_es_signal; 375: return; 376: } 377: 378: # ifndef SEMAPHORES_NOMMES 379: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 380: # else 381: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 382: # endif 383: { 384: (*s_etat_processus).erreur_systeme = d_es_processus; 385: return; 386: } 387: 388: while((longueur_ecriture = write_atomic(s_etat_processus, 389: (*(*((struct_processus_fils *) (*(*l_element_courant) 390: .donnee).objet)).thread).pipe_nombre_injections[1], "+", 391: sizeof(unsigned char))) != sizeof(unsigned char)) 392: { 393: if (longueur_ecriture == -1) 394: { 395: // Le processus n'existe plus. 396: break; 397: } 398: } 399: 400: # ifndef SEMAPHORES_NOMMES 401: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 402: # else 403: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 404: # endif 405: { 406: if (errno != EINTR) 407: { 408: (*s_etat_processus).erreur_systeme = d_es_processus; 409: return; 410: } 411: } 412: 413: if ((*s_etat_processus).profilage == d_vrai) 414: { 415: profilage(s_etat_processus, NULL); 416: } 417: 418: if (registre_stop == 0) 419: { 420: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1) 421: { 422: (*s_etat_processus).var_volatile_requete_arret = -1; 423: } 424: 425: (*s_etat_processus).var_volatile_traitement_retarde_stop 426: = registre_stop; 427: } 428: 429: if (sigaction(SIGPIPE, ®istre, NULL) != 0) 430: { 431: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 432: 433: (*s_etat_processus).erreur_systeme = d_es_signal; 434: return; 435: } 436: 437: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 438: { 439: (*s_etat_processus).erreur_systeme_processus_fils = 440: d_es_processus; 441: } 442: } 443: else 444: { 445: liberation(s_etat_processus, s_objet_argument); 446: 447: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 448: return; 449: } 450: 451: liberation(s_etat_processus, s_objet_argument); 452: 453: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 454: s_objet_resultat) == d_erreur) 455: { 456: return; 457: } 458: 459: /* 460: * On rajoute "-1" dans la pile. 461: */ 462: 463: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 464: { 465: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 466: return; 467: } 468: 469: (*((integer8 *) (*s_objet_resultat).objet)) = -1; 470: 471: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 472: s_objet_resultat) == d_erreur) 473: { 474: return; 475: } 476: 477: return; 478: } 479: 480: 481: /* 482: ================================================================================ 483: Fonction 'row->' 484: ================================================================================ 485: Entrées : 486: -------------------------------------------------------------------------------- 487: Sorties : 488: -------------------------------------------------------------------------------- 489: Effets de bord : néant 490: ================================================================================ 491: */ 492: 493: void 494: instruction_row_fleche(struct_processus *s_etat_processus) 495: { 496: struct_objet *s_objet; 497: struct_objet *s_objet_elementaire; 498: 499: unsigned long i; 500: unsigned long j; 501: 502: (*s_etat_processus).erreur_execution = d_ex; 503: 504: if ((*s_etat_processus).affichage_arguments == 'Y') 505: { 506: printf("\n ROW-> "); 507: 508: if ((*s_etat_processus).langue == 'F') 509: { 510: printf("(extraction des lignes d'une matrice)\n\n"); 511: } 512: else 513: { 514: printf("(extract matrix rows)\n\n"); 515: } 516: 517: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); 518: printf("-> n: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); 519: printf(" ...\n"); 520: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); 521: printf(" 1: %s\n", d_INT); 522: 523: return; 524: } 525: else if ((*s_etat_processus).test_instruction == 'Y') 526: { 527: (*s_etat_processus).nombre_arguments = -1; 528: return; 529: } 530: 531: if (test_cfsf(s_etat_processus, 31) == d_vrai) 532: { 533: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 534: { 535: return; 536: } 537: } 538: 539: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 540: &s_objet) == d_erreur) 541: { 542: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 543: return; 544: } 545: 546: if ((*s_objet).type == MIN) 547: { 548: for(i = 0; i < (*((struct_matrice *) 549: (*s_objet).objet)).nombre_lignes; i++) 550: { 551: if ((s_objet_elementaire = allocation(s_etat_processus, MIN)) 552: == NULL) 553: { 554: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 555: return; 556: } 557: 558: (*((struct_matrice *) (*s_objet_elementaire).objet)) 559: .nombre_lignes = 1; 560: (*((struct_matrice *) (*s_objet_elementaire).objet)) 561: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet)) 562: .nombre_colonnes; 563: 564: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau = 565: malloc(sizeof(integer8 *))) == NULL) 566: { 567: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 568: return; 569: } 570: 571: if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire) 572: .objet)).tableau)[0] = malloc((*((struct_matrice *) 573: (*s_objet_elementaire).objet)).nombre_colonnes * 574: sizeof(integer8))) == NULL) 575: { 576: (*s_etat_processus).erreur_systeme = 577: d_es_allocation_memoire; 578: return; 579: } 580: 581: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet)) 582: .nombre_colonnes; j++) 583: { 584: ((integer8 **) (*((struct_matrice *) (*s_objet_elementaire) 585: .objet)).tableau)[0][j] = 586: ((integer8 **) (*((struct_matrice *) 587: (*s_objet).objet)).tableau)[i][j]; 588: } 589: 590: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 591: s_objet_elementaire) == d_erreur) 592: { 593: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 594: return; 595: } 596: } 597: } 598: else if ((*s_objet).type == MRL) 599: { 600: for(i = 0; i < (*((struct_matrice *) 601: (*s_objet).objet)).nombre_lignes; i++) 602: { 603: if ((s_objet_elementaire = allocation(s_etat_processus, MRL)) 604: == NULL) 605: { 606: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 607: return; 608: } 609: 610: (*((struct_matrice *) (*s_objet_elementaire).objet)) 611: .nombre_lignes = 1; 612: (*((struct_matrice *) (*s_objet_elementaire).objet)) 613: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet)) 614: .nombre_colonnes; 615: 616: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau = 617: malloc(sizeof(real8 *))) == NULL) 618: { 619: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 620: return; 621: } 622: 623: if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire) 624: .objet)).tableau)[0] = malloc((*((struct_matrice *) 625: (*s_objet_elementaire).objet)).nombre_colonnes * 626: sizeof(real8))) == NULL) 627: { 628: (*s_etat_processus).erreur_systeme = 629: d_es_allocation_memoire; 630: return; 631: } 632: 633: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet)) 634: .nombre_colonnes; j++) 635: { 636: ((real8 **) (*((struct_matrice *) (*s_objet_elementaire) 637: .objet)).tableau)[0][j] = 638: ((real8 **) (*((struct_matrice *) 639: (*s_objet).objet)).tableau)[i][j]; 640: } 641: 642: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 643: s_objet_elementaire) == d_erreur) 644: { 645: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 646: return; 647: } 648: } 649: } 650: else if ((*s_objet).type == MCX) 651: { 652: for(i = 0; i < (*((struct_matrice *) 653: (*s_objet).objet)).nombre_lignes; i++) 654: { 655: if ((s_objet_elementaire = allocation(s_etat_processus, MCX)) 656: == NULL) 657: { 658: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 659: return; 660: } 661: 662: (*((struct_matrice *) (*s_objet_elementaire).objet)) 663: .nombre_lignes = 1; 664: (*((struct_matrice *) (*s_objet_elementaire).objet)) 665: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet)) 666: .nombre_colonnes; 667: 668: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau = 669: malloc(sizeof(complex16 *))) == NULL) 670: { 671: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 672: return; 673: } 674: 675: if ((((complex16 **) (*((struct_matrice *) (*s_objet_elementaire) 676: .objet)).tableau)[0] = malloc((*((struct_matrice *) 677: (*s_objet_elementaire).objet)).nombre_colonnes * 678: sizeof(complex16))) == NULL) 679: { 680: (*s_etat_processus).erreur_systeme = 681: d_es_allocation_memoire; 682: return; 683: } 684: 685: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet)) 686: .nombre_colonnes; j++) 687: { 688: ((complex16 **) (*((struct_matrice *) (*s_objet_elementaire) 689: .objet)).tableau)[0][j].partie_reelle = 690: ((complex16 **) (*((struct_matrice *) 691: (*s_objet).objet)).tableau)[i][j].partie_reelle; 692: ((complex16 **) (*((struct_matrice *) (*s_objet_elementaire) 693: .objet)).tableau)[0][j].partie_imaginaire = 694: ((complex16 **) (*((struct_matrice *) 695: (*s_objet).objet)).tableau)[i][j].partie_imaginaire; 696: } 697: 698: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 699: s_objet_elementaire) == d_erreur) 700: { 701: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 702: return; 703: } 704: } 705: } 706: else 707: { 708: liberation(s_etat_processus, s_objet); 709: 710: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 711: return; 712: } 713: 714: if ((s_objet_elementaire = allocation(s_etat_processus, INT)) == NULL) 715: { 716: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 717: return; 718: } 719: 720: (*((integer8 *) (*s_objet_elementaire).objet)) = 721: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes; 722: 723: liberation(s_etat_processus, s_objet); 724: 725: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 726: s_objet_elementaire) == d_erreur) 727: { 728: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 729: return; 730: } 731: 732: return; 733: } 734: 735: 736: /* 737: ================================================================================ 738: Fonction 'rdate' 739: ================================================================================ 740: Entrées : pointeur sur une structure struct_processus 741: -------------------------------------------------------------------------------- 742: Sorties : 743: -------------------------------------------------------------------------------- 744: Effets de bord : néant 745: ================================================================================ 746: */ 747: 748: void 749: instruction_rdate(struct_processus *s_etat_processus) 750: { 751: struct_objet *s_objet; 752: struct_objet *s_objet_argument; 753: 754: struct timeval horodatage; 755: 756: (*s_etat_processus).erreur_execution = d_ex; 757: 758: if ((*s_etat_processus).affichage_arguments == 'Y') 759: { 760: printf("\n RDATE "); 761: 762: if ((*s_etat_processus).langue == 'F') 763: { 764: printf("(information sur la date et l'heure avec offset)\n\n"); 765: } 766: else 767: { 768: printf("(date and time with offset)\n\n"); 769: } 770: 771: printf(" 1: %s\n", d_INT); 772: printf("-> 1: %s\n", d_LST); 773: 774: return; 775: } 776: else if ((*s_etat_processus).test_instruction == 'Y') 777: { 778: (*s_etat_processus).nombre_arguments = 1; 779: return; 780: } 781: 782: if (test_cfsf(s_etat_processus, 31) == d_vrai) 783: { 784: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 785: { 786: return; 787: } 788: } 789: 790: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 791: &s_objet_argument) == d_erreur) 792: { 793: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 794: return; 795: } 796: 797: if ((*s_objet_argument).type == INT) 798: { 799: gettimeofday(&horodatage, NULL); 800: horodatage.tv_sec += (*((integer8 *) (*s_objet_argument).objet)); 801: 802: if (horodatage.tv_sec < 0) 803: { 804: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 805: 806: liberation(s_etat_processus, s_objet_argument); 807: return; 808: } 809: 810: if ((s_objet = formateur_date(s_etat_processus, &horodatage)) == NULL) 811: { 812: liberation(s_etat_processus, s_objet_argument); 813: return; 814: } 815: 816: liberation(s_etat_processus, s_objet_argument); 817: } 818: else 819: { 820: liberation(s_etat_processus, s_objet_argument); 821: 822: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 823: return; 824: } 825: 826: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 827: s_objet) == d_erreur) 828: { 829: return; 830: } 831: 832: return; 833: } 834: 835: 836: /* 837: ================================================================================ 838: Fonction 'rclswi' 839: ================================================================================ 840: Entrées : pointeur sur une structure struct_processus 841: -------------------------------------------------------------------------------- 842: Sorties : 843: -------------------------------------------------------------------------------- 844: Effets de bord : néant 845: ================================================================================ 846: */ 847: 848: void 849: instruction_rclswi(struct_processus *s_etat_processus) 850: { 851: integer8 interruption; 852: 853: struct_objet *s_objet_argument; 854: struct_objet *s_objet_resultat; 855: 856: (*s_etat_processus).erreur_execution = d_ex; 857: 858: if ((*s_etat_processus).affichage_arguments == 'Y') 859: { 860: printf("\n RCLSWI "); 861: 862: if ((*s_etat_processus).langue == 'F') 863: { 864: printf("(rappel d'une interruption logicielle)\n\n"); 865: } 866: else 867: { 868: printf("(recall software interrupt)\n\n"); 869: } 870: 871: printf(" 1: %s\n", d_INT); 872: printf("-> 1: %s, %s\n", d_NOM, d_RPN); 873: 874: return; 875: } 876: else if ((*s_etat_processus).test_instruction == 'Y') 877: { 878: (*s_etat_processus).nombre_arguments = -1; 879: return; 880: } 881: 882: if (test_cfsf(s_etat_processus, 31) == d_vrai) 883: { 884: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 885: { 886: return; 887: } 888: } 889: 890: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 891: &s_objet_argument) == d_erreur) 892: { 893: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 894: return; 895: } 896: 897: if ((*s_objet_argument).type == INT) 898: { 899: interruption = (*((integer8 *) (*s_objet_argument).objet)); 900: 901: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS)) 902: { 903: liberation(s_etat_processus, s_objet_argument); 904: 905: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide; 906: return; 907: } 908: 909: if ((*s_etat_processus).corps_interruptions[interruption - 1] == NULL) 910: { 911: liberation(s_etat_processus, s_objet_argument); 912: 913: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide; 914: return; 915: } 916: 917: if ((s_objet_resultat = copie_objet(s_etat_processus, 918: (*s_etat_processus).corps_interruptions[interruption - 1], 'P')) 919: == NULL) 920: { 921: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 922: return; 923: } 924: } 925: else 926: { 927: liberation(s_etat_processus, s_objet_argument); 928: 929: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 930: return; 931: } 932: 933: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 934: s_objet_resultat) == d_erreur) 935: { 936: return; 937: } 938: 939: return; 940: } 941: 942: 943: /* 944: ================================================================================ 945: Fonction 'revlist' 946: ================================================================================ 947: Entrées : pointeur sur une structure struct_processus 948: -------------------------------------------------------------------------------- 949: Sorties : 950: -------------------------------------------------------------------------------- 951: Effets de bord : néant 952: ================================================================================ 953: */ 954: 955: void 956: instruction_revlist(struct_processus *s_etat_processus) 957: { 958: struct_liste_chainee *l_ancienne_base; 959: struct_liste_chainee *l_nouvelle_base; 960: 961: struct_objet *s_objet_argument; 962: struct_objet *s_objet_intermediaire; 963: struct_objet *s_objet_resultat; 964: 965: (*s_etat_processus).erreur_execution = d_ex; 966: 967: if ((*s_etat_processus).affichage_arguments == 'Y') 968: { 969: printf("\n REVLIST "); 970: 971: if ((*s_etat_processus).langue == 'F') 972: { 973: printf("(inverse les éléments d'une liste)\n\n"); 974: } 975: else 976: { 977: printf("(inverts list elements)\n\n"); 978: } 979: 980: printf(" 1: %s\n", d_LST); 981: printf("-> 1: %s\n", d_LST); 982: 983: return; 984: } 985: else if ((*s_etat_processus).test_instruction == 'Y') 986: { 987: (*s_etat_processus).nombre_arguments = -1; 988: return; 989: } 990: 991: if (test_cfsf(s_etat_processus, 31) == d_vrai) 992: { 993: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 994: { 995: return; 996: } 997: } 998: 999: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1000: &s_objet_argument) == d_erreur) 1001: { 1002: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1003: return; 1004: } 1005: 1006: if ((*s_objet_argument).type == LST) 1007: { 1008: if ((s_objet_resultat = copie_objet(s_etat_processus, 1009: s_objet_argument, 'N')) == NULL) 1010: { 1011: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1012: return; 1013: } 1014: 1015: l_ancienne_base = (*s_objet_resultat).objet; 1016: l_nouvelle_base = NULL; 1017: 1018: while(l_ancienne_base != NULL) 1019: { 1020: if (depilement(s_etat_processus, &l_ancienne_base, 1021: &s_objet_intermediaire) == d_erreur) 1022: { 1023: (*s_etat_processus).erreur_systeme = d_es_pile_vide; 1024: return; 1025: } 1026: 1027: if (empilement(s_etat_processus, &l_nouvelle_base, 1028: s_objet_intermediaire) == d_erreur) 1029: { 1030: return; 1031: } 1032: } 1033: 1034: (*s_objet_resultat).objet = l_nouvelle_base; 1035: } 1036: else 1037: { 1038: liberation(s_etat_processus, s_objet_argument); 1039: 1040: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1041: return; 1042: } 1043: 1044: liberation(s_etat_processus, s_objet_argument); 1045: 1046: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1047: s_objet_resultat) == d_erreur) 1048: { 1049: return; 1050: } 1051: 1052: return; 1053: } 1054: 1055: 1056: /* 1057: ================================================================================ 1058: Fonction 'rstop' 1059: ================================================================================ 1060: Entrées : 1061: -------------------------------------------------------------------------------- 1062: Sorties : 1063: -------------------------------------------------------------------------------- 1064: Effets de bord : néant 1065: ================================================================================ 1066: */ 1067: 1068: void 1069: instruction_rstop(struct_processus *s_etat_processus) 1070: { 1071: (*s_etat_processus).erreur_execution = d_ex; 1072: 1073: if ((*s_etat_processus).affichage_arguments == 'Y') 1074: { 1075: printf("\n RSTOP "); 1076: 1077: if ((*s_etat_processus).langue == 'F') 1078: { 1079: printf("(libère le signal stop)\n\n"); 1080: printf(" Aucun argument\n"); 1081: } 1082: else 1083: { 1084: printf("(release stop signal)\n\n"); 1085: printf(" No argument\n"); 1086: } 1087: 1088: return; 1089: } 1090: else if ((*s_etat_processus).test_instruction == 'Y') 1091: { 1092: (*s_etat_processus).nombre_arguments = -1; 1093: return; 1094: } 1095: 1096: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1097: { 1098: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1099: { 1100: return; 1101: } 1102: } 1103: 1104: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0) 1105: { 1106: (*s_etat_processus).erreur_execution = d_ex_stop; 1107: return; 1108: } 1109: 1110: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1) 1111: { 1112: (*s_etat_processus).var_volatile_requete_arret = -1; 1113: } 1114: 1115: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0; 1116: 1117: return; 1118: } 1119: 1120: 1121: /* 1122: ================================================================================ 1123: fonction 'rfuse' 1124: ================================================================================ 1125: entrées : 1126: -------------------------------------------------------------------------------- 1127: sorties : 1128: -------------------------------------------------------------------------------- 1129: effets de bord : néant 1130: ================================================================================ 1131: */ 1132: 1133: void 1134: instruction_rfuse(struct_processus *s_etat_processus) 1135: { 1136: struct_objet *s_objet_resultat; 1137: 1138: (*s_etat_processus).erreur_execution = d_ex; 1139: 1140: if ((*s_etat_processus).affichage_arguments == 'Y') 1141: { 1142: printf("\n RFUSE "); 1143: 1144: if ((*s_etat_processus).langue == 'F') 1145: { 1146: printf("(valeur courante du fusible)\n\n"); 1147: } 1148: else 1149: { 1150: printf("(remaining fuse value)\n\n"); 1151: } 1152: 1153: printf("-> 1: %s\n", d_REL); 1154: return; 1155: } 1156: else if ((*s_etat_processus).test_instruction == 'Y') 1157: { 1158: (*s_etat_processus).nombre_arguments = -1; 1159: return; 1160: } 1161: 1162: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1163: { 1164: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1165: { 1166: return; 1167: } 1168: } 1169: 1170: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) 1171: { 1172: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1173: return; 1174: } 1175: 1176: (*((real8 *) (*s_objet_resultat).objet)) = 1177: (*s_etat_processus).temps_maximal_cpu; 1178: 1179: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1180: s_objet_resultat) == d_erreur) 1181: { 1182: return; 1183: } 1184: 1185: return; 1186: } 1187: 1188: 1189: /* 1190: ================================================================================ 1191: fonction 'rdgn' 1192: ================================================================================ 1193: entrées : 1194: -------------------------------------------------------------------------------- 1195: sorties : 1196: -------------------------------------------------------------------------------- 1197: effets de bord : néant 1198: ================================================================================ 1199: */ 1200: 1201: void 1202: instruction_rdgn(struct_processus *s_etat_processus) 1203: { 1204: const gsl_rng_type **type_courant; 1205: const gsl_rng_type **types; 1206: 1207: const unsigned char *message = "UNINITIALIZED RANDOM GENERATOR"; 1208: 1209: long dernier; 1210: long i; 1211: long j; 1212: long premier; 1213: 1214: struct_objet *s_objet_argument; 1215: struct_objet *s_objet_resultat; 1216: 1217: unsigned char *pointeur; 1218: unsigned char *requete; 1219: unsigned char **types_generateurs; 1220: 1221: unsigned long nombre_types; 1222: 1223: (*s_etat_processus).erreur_execution = d_ex; 1224: 1225: types = gsl_rng_types_setup(); 1226: 1227: if ((*s_etat_processus).affichage_arguments == 'Y') 1228: { 1229: printf("\n RDGN "); 1230: 1231: if ((*s_etat_processus).langue == 'F') 1232: { 1233: printf("(choix du générateur de nombres aléatoires)\n\n"); 1234: } 1235: else 1236: { 1237: printf("(random number generator specification)\n\n"); 1238: } 1239: 1240: printf(" 1: %s\n\n", d_CHN); 1241: 1242: printf(" 1: \"QUERY\"\n"); 1243: printf("-> 1: %s\n\n", d_CHN); 1244: 1245: if ((*s_etat_processus).langue == 'F') 1246: { 1247: printf(" Générateurs disponibles :\n\n"); 1248: } 1249: else 1250: { 1251: printf(" Available generators:\n\n"); 1252: } 1253: 1254: for(nombre_types = 0, type_courant = types; 1255: (*type_courant) != NULL; type_courant++, nombre_types++); 1256: 1257: if ((types_generateurs = malloc(nombre_types * sizeof(unsigned char *))) 1258: == NULL) 1259: { 1260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1261: return; 1262: } 1263: 1264: for(i = 0, type_courant = types; (*type_courant) != NULL; 1265: type_courant++, i++) 1266: { 1267: if ((types_generateurs[i] = malloc((strlen((**type_courant).name) 1268: + 1) * sizeof(unsigned char))) == NULL) 1269: { 1270: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1271: return; 1272: } 1273: 1274: strcpy(types_generateurs[i], (**type_courant).name); 1275: pointeur = types_generateurs[i]; 1276: 1277: while((*pointeur) != d_code_fin_chaine) 1278: { 1279: if ((*pointeur) == '-') 1280: { 1281: (*pointeur) = '_'; 1282: } 1283: 1284: pointeur++; 1285: } 1286: } 1287: 1288: // Tri des types de générateurs (tri shaker) 1289: 1290: premier = 1; 1291: dernier = nombre_types - 2; 1292: 1293: while((dernier - premier) >= 2) 1294: { 1295: for(j = 2, i = premier; i <= dernier; i++) 1296: { 1297: if (strcmp(types_generateurs[i], types_generateurs[i + 1]) > 0) 1298: { 1299: swap(&(types_generateurs[i]), 1300: &(types_generateurs[i + 1]), 1301: sizeof(unsigned char *)); 1302: j = i; 1303: } 1304: } 1305: 1306: dernier = j; 1307: i = nombre_types - 2; 1308: 1309: for(i = dernier; i >= premier; i--) 1310: { 1311: if (strcmp(types_generateurs[i - 1], types_generateurs[i]) > 0) 1312: { 1313: swap(&(types_generateurs[i - 1]), 1314: &(types_generateurs[i]), 1315: sizeof(unsigned char *)); 1316: j = i; 1317: } 1318: } 1319: 1320: premier = j; 1321: } 1322: 1323: for(i = 0; i < (long) nombre_types; i++) 1324: { 1325: printf(" - %s\n", types_generateurs[i]); 1326: free(types_generateurs[i]); 1327: } 1328: 1329: free(types_generateurs); 1330: return; 1331: } 1332: else if ((*s_etat_processus).test_instruction == 'Y') 1333: { 1334: (*s_etat_processus).nombre_arguments = -1; 1335: return; 1336: } 1337: 1338: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1339: { 1340: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1341: { 1342: return; 1343: } 1344: } 1345: 1346: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1347: &s_objet_argument) == d_erreur) 1348: { 1349: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1350: return; 1351: } 1352: 1353: if ((*s_objet_argument).type == CHN) 1354: { 1355: if ((requete = conversion_majuscule((unsigned char *) 1356: (*s_objet_argument).objet)) == NULL) 1357: { 1358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1359: return; 1360: } 1361: 1362: if (strcmp(requete, "QUERY") == 0) 1363: { 1364: /* 1365: * Récupération du type du générateur 1366: */ 1367: 1368: free(requete); 1369: 1370: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL) 1371: { 1372: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1373: return; 1374: } 1375: 1376: if ((*s_etat_processus).type_generateur_aleatoire == NULL) 1377: { 1378: if (((*s_objet_resultat).objet = malloc((strlen(message) + 1) * 1379: sizeof(unsigned char))) == NULL) 1380: { 1381: (*s_etat_processus).erreur_systeme = 1382: d_es_allocation_memoire; 1383: return; 1384: } 1385: 1386: strcpy((unsigned char *) (*s_objet_resultat).objet, message); 1387: } 1388: else 1389: { 1390: if (((*s_objet_resultat).objet = conversion_majuscule( 1391: (unsigned char *) gsl_rng_name( 1392: (*s_etat_processus).generateur_aleatoire))) == NULL) 1393: { 1394: (*s_etat_processus).erreur_systeme = 1395: d_es_allocation_memoire; 1396: return; 1397: } 1398: } 1399: 1400: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1401: s_objet_resultat) == d_erreur) 1402: { 1403: return; 1404: } 1405: } 1406: else 1407: { 1408: /* 1409: * Affectation d'un nouveau type de générateur 1410: */ 1411: 1412: # include "generateurs.c" 1413: 1414: free(requete); 1415: 1416: if ((*s_etat_processus).generateur_aleatoire != NULL) 1417: { 1418: liberation_generateur_aleatoire(s_etat_processus); 1419: } 1420: 1421: initialisation_generateur_aleatoire(s_etat_processus, d_vrai, 0); 1422: } 1423: } 1424: else 1425: { 1426: liberation(s_etat_processus, s_objet_argument); 1427: 1428: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1429: return; 1430: } 1431: 1432: liberation(s_etat_processus, s_objet_argument); 1433: 1434: return; 1435: } 1436: 1437: 1438: /* 1439: ================================================================================ 1440: fonction 'rank' 1441: ================================================================================ 1442: entrées : 1443: -------------------------------------------------------------------------------- 1444: sorties : 1445: -------------------------------------------------------------------------------- 1446: effets de bord : néant 1447: ================================================================================ 1448: */ 1449: 1450: void 1451: instruction_rank(struct_processus *s_etat_processus) 1452: { 1453: struct_objet *s_objet_argument; 1454: struct_objet *s_objet_resultat; 1455: 1456: (*s_etat_processus).erreur_execution = d_ex; 1457: 1458: if ((*s_etat_processus).affichage_arguments == 'Y') 1459: { 1460: printf("\n RANK "); 1461: 1462: if ((*s_etat_processus).langue == 'F') 1463: { 1464: printf("(rang de la matrice)\n\n"); 1465: } 1466: else 1467: { 1468: printf("(matrix rank)\n\n"); 1469: } 1470: 1471: printf(" 1: %s, %s, %s\n", d_MIN, d_REL, d_MCX); 1472: printf("-> 1: %s\n", d_INT); 1473: 1474: return; 1475: } 1476: else if ((*s_etat_processus).test_instruction == 'Y') 1477: { 1478: (*s_etat_processus).nombre_arguments = -1; 1479: return; 1480: } 1481: 1482: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1483: { 1484: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1485: { 1486: return; 1487: } 1488: } 1489: 1490: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1491: &s_objet_argument) == d_erreur) 1492: { 1493: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1494: return; 1495: } 1496: 1497: if (((*s_objet_argument).type == MIN) || 1498: ((*s_objet_argument).type == MRL) || 1499: ((*s_objet_argument).type == MCX)) 1500: { 1501: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 1502: { 1503: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1504: return; 1505: } 1506: 1507: rang(s_etat_processus, (*s_objet_argument).objet, 1508: (*s_objet_resultat).objet); 1509: 1510: if ((*s_etat_processus).erreur_systeme != d_es) 1511: { 1512: return; 1513: } 1514: 1515: if (((*s_etat_processus).erreur_execution != d_ex) || 1516: ((*s_etat_processus).exception != d_ep)) 1517: { 1518: liberation(s_etat_processus, s_objet_argument); 1519: liberation(s_etat_processus, s_objet_resultat); 1520: return; 1521: } 1522: } 1523: else 1524: { 1525: liberation(s_etat_processus, s_objet_argument); 1526: 1527: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1528: return; 1529: } 1530: 1531: liberation(s_etat_processus, s_objet_argument); 1532: 1533: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1534: s_objet_resultat) == d_erreur) 1535: { 1536: return; 1537: } 1538: 1539: return; 1540: } 1541: 1542: 1543: /* 1544: ================================================================================ 1545: Fonction 'recode' 1546: ================================================================================ 1547: Entrées : 1548: -------------------------------------------------------------------------------- 1549: Sorties : 1550: -------------------------------------------------------------------------------- 1551: Effets de bord : néant 1552: ================================================================================ 1553: */ 1554: 1555: void 1556: instruction_recode(struct_processus *s_etat_processus) 1557: { 1558: struct_objet *s_objet_argument_1; 1559: struct_objet *s_objet_argument_2; 1560: struct_objet *s_objet_argument_3; 1561: struct_objet *s_objet_resultat; 1562: 1563: unsigned char *encodage_destination; 1564: unsigned char *encodage_source; 1565: unsigned char *tampon; 1566: 1567: (*s_etat_processus).erreur_execution = d_ex; 1568: 1569: if ((*s_etat_processus).affichage_arguments == 'Y') 1570: { 1571: printf("\n RECODE "); 1572: 1573: if ((*s_etat_processus).langue == 'F') 1574: { 1575: printf("(conversion d'encodage d'une chaîne de caractères)\n\n"); 1576: } 1577: else 1578: { 1579: printf("(string recodage)\n\n"); 1580: } 1581: 1582: printf(" 3: %s\n", d_CHN); 1583: printf(" 2: %s\n", d_CHN); 1584: printf(" 1: %s\n", d_CHN); 1585: printf("-> 1: %s\n\n", d_CHN); 1586: 1587: if ((*s_etat_processus).langue == 'F') 1588: { 1589: printf(" Utilisation :\n\n"); 1590: } 1591: else 1592: { 1593: printf(" Usage:\n\n"); 1594: } 1595: 1596: printf(" \"string\" \"ISO8859-1\" \"UTF-8\" recode\n"); 1597: printf(" \"string\" \"ISO8859-1\" \"UTF-8//TRANSLIT\" recode\n"); 1598: printf(" \"string\" \"ISO8859-1\" \"UTF-8//IGNORE\" recode\n"); 1599: return; 1600: } 1601: else if ((*s_etat_processus).test_instruction == 'Y') 1602: { 1603: (*s_etat_processus).nombre_arguments = -1; 1604: return; 1605: } 1606: 1607: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1608: { 1609: if (empilement_pile_last(s_etat_processus, 3) == d_erreur) 1610: { 1611: return; 1612: } 1613: } 1614: 1615: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1616: &s_objet_argument_1) == d_erreur) 1617: { 1618: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1619: return; 1620: } 1621: 1622: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1623: &s_objet_argument_2) == d_erreur) 1624: { 1625: liberation(s_etat_processus, s_objet_argument_1); 1626: 1627: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1628: return; 1629: } 1630: 1631: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1632: &s_objet_argument_3) == d_erreur) 1633: { 1634: liberation(s_etat_processus, s_objet_argument_1); 1635: liberation(s_etat_processus, s_objet_argument_2); 1636: 1637: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1638: return; 1639: } 1640: 1641: if (((*s_objet_argument_1).type == CHN) && 1642: ((*s_objet_argument_2).type == CHN) && 1643: ((*s_objet_argument_3).type == CHN)) 1644: { 1645: if ((encodage_source = conversion_majuscule((unsigned char *) 1646: (*s_objet_argument_2).objet)) == NULL) 1647: { 1648: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1649: return; 1650: } 1651: 1652: if ((encodage_destination = conversion_majuscule((unsigned char *) 1653: (*s_objet_argument_1).objet)) == NULL) 1654: { 1655: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1656: return; 1657: } 1658: 1659: tampon = reencodage(s_etat_processus, 1660: (*s_objet_argument_3).objet, encodage_source, 1661: encodage_destination); 1662: 1663: free(encodage_destination); 1664: free(encodage_source); 1665: 1666: if (tampon == NULL) 1667: { 1668: liberation(s_etat_processus, s_objet_argument_1); 1669: liberation(s_etat_processus, s_objet_argument_2); 1670: liberation(s_etat_processus, s_objet_argument_3); 1671: return; 1672: } 1673: 1674: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL) 1675: { 1676: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1677: return; 1678: } 1679: 1680: (*s_objet_resultat).objet = tampon; 1681: } 1682: else 1683: { 1684: liberation(s_etat_processus, s_objet_argument_1); 1685: liberation(s_etat_processus, s_objet_argument_2); 1686: liberation(s_etat_processus, s_objet_argument_3); 1687: 1688: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1689: return; 1690: } 1691: 1692: liberation(s_etat_processus, s_objet_argument_1); 1693: liberation(s_etat_processus, s_objet_argument_2); 1694: liberation(s_etat_processus, s_objet_argument_3); 1695: 1696: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1697: s_objet_resultat) == d_erreur) 1698: { 1699: return; 1700: } 1701: 1702: return; 1703: } 1704: 1705: 1706: /* 1707: ================================================================================ 1708: Fonction 'repl' 1709: ================================================================================ 1710: Entrées : 1711: -------------------------------------------------------------------------------- 1712: Sorties : 1713: -------------------------------------------------------------------------------- 1714: Effets de bord : néant 1715: ================================================================================ 1716: */ 1717: 1718: void 1719: instruction_repl(struct_processus *s_etat_processus) 1720: { 1721: integer8 position; 1722: 1723: long difference; 1724: long difference_ecriture; 1725: long difference_lecture; 1726: long nombre_occurrences; 1727: 1728: struct_liste_chainee *l_element_a_supprimer; 1729: struct_liste_chainee *l_element_courant; 1730: struct_liste_chainee *l_element_courant_2; 1731: struct_liste_chainee *l_element_precedent; 1732: struct_liste_chainee *l_element_precedent_2; 1733: 1734: struct_objet *s_objet_argument_1; 1735: struct_objet *s_objet_argument_2; 1736: struct_objet *s_objet_argument_3; 1737: struct_objet *s_objet_intermediaire; 1738: struct_objet *s_objet_resultat; 1739: 1740: unsigned char *ancien_pointeur_ecriture; 1741: unsigned char *ancien_pointeur_lecture; 1742: unsigned char *pointeur_ecriture; 1743: unsigned char *pointeur_lecture; 1744: 1745: (*s_etat_processus).erreur_execution = d_ex; 1746: 1747: if ((*s_etat_processus).affichage_arguments == 'Y') 1748: { 1749: printf("\n REPL "); 1750: 1751: if ((*s_etat_processus).langue == 'F') 1752: { 1753: printf("(remplacement d'éléments dans une liste ou une chaîne" 1754: ")\n\n"); 1755: } 1756: else 1757: { 1758: printf("(replace elements in list or string)\n\n"); 1759: } 1760: 1761: printf(" 3: %s\n", d_LST); 1762: printf(" 2: %s\n", d_INT); 1763: printf(" 1: %s\n", d_LST); 1764: printf("-> 1: %s\n\n", d_LST); 1765: 1766: printf(" 3: %s\n", d_CHN); 1767: printf(" 2: %s\n", d_CHN); 1768: printf(" 1: %s\n", d_CHN); 1769: printf("-> 1: %s\n\n", d_CHN); 1770: return; 1771: } 1772: else if ((*s_etat_processus).test_instruction == 'Y') 1773: { 1774: (*s_etat_processus).nombre_arguments = -1; 1775: return; 1776: } 1777: 1778: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1779: { 1780: if (empilement_pile_last(s_etat_processus, 3) == d_erreur) 1781: { 1782: return; 1783: } 1784: } 1785: 1786: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1787: &s_objet_argument_1) == d_erreur) 1788: { 1789: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1790: return; 1791: } 1792: 1793: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1794: &s_objet_argument_2) == d_erreur) 1795: { 1796: liberation(s_etat_processus, s_objet_argument_1); 1797: 1798: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1799: return; 1800: } 1801: 1802: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1803: &s_objet_argument_3) == d_erreur) 1804: { 1805: liberation(s_etat_processus, s_objet_argument_1); 1806: liberation(s_etat_processus, s_objet_argument_2); 1807: 1808: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1809: return; 1810: } 1811: 1812: if (((*s_objet_argument_1).type == CHN) && 1813: ((*s_objet_argument_2).type == CHN) && 1814: ((*s_objet_argument_3).type == CHN)) 1815: { 1816: if (strcmp((unsigned char *) (*s_objet_argument_2).objet, "") == 0) 1817: { 1818: liberation(s_etat_processus, s_objet_argument_1); 1819: liberation(s_etat_processus, s_objet_argument_2); 1820: liberation(s_etat_processus, s_objet_argument_3); 1821: 1822: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1823: return; 1824: } 1825: 1826: nombre_occurrences = 0; 1827: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet; 1828: 1829: for(;;) 1830: { 1831: pointeur_lecture = strstr(pointeur_lecture, (unsigned char *) 1832: (*s_objet_argument_2).objet); 1833: 1834: if (pointeur_lecture == NULL) 1835: { 1836: break; 1837: } 1838: 1839: pointeur_lecture++; 1840: nombre_occurrences++; 1841: } 1842: 1843: // Différence est positive si la nouvelle chaîne est plus longue 1844: // que la chaîne originelle. 1845: 1846: difference = strlen((unsigned char *) (*s_objet_argument_1).objet) 1847: - strlen((unsigned char *) (*s_objet_argument_2).objet); 1848: 1849: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL) 1850: { 1851: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1852: return; 1853: } 1854: 1855: if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *) 1856: (*s_objet_argument_3).objet) + (nombre_occurrences * 1857: difference) + 1) * sizeof(unsigned char))) == NULL) 1858: { 1859: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1860: return; 1861: } 1862: 1863: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet; 1864: pointeur_ecriture = (unsigned char *) (*s_objet_resultat).objet; 1865: difference_lecture = strlen((unsigned char *) 1866: (*s_objet_argument_2).objet); 1867: difference_ecriture = strlen((unsigned char *) 1868: (*s_objet_argument_1).objet); 1869: 1870: for(;;) 1871: { 1872: ancien_pointeur_lecture = pointeur_lecture; 1873: ancien_pointeur_ecriture = pointeur_ecriture; 1874: 1875: pointeur_lecture = strstr(ancien_pointeur_lecture, 1876: (unsigned char *) (*s_objet_argument_2).objet); 1877: 1878: if (pointeur_lecture == NULL) 1879: { 1880: strcpy(ancien_pointeur_ecriture, ancien_pointeur_lecture); 1881: break; 1882: } 1883: 1884: strncpy(ancien_pointeur_ecriture, ancien_pointeur_lecture, 1885: pointeur_lecture - ancien_pointeur_lecture); 1886: strcpy(ancien_pointeur_ecriture + 1887: (pointeur_lecture - ancien_pointeur_lecture), 1888: (unsigned char *) (*s_objet_argument_1).objet); 1889: 1890: pointeur_ecriture += difference_ecriture + 1891: (pointeur_lecture - ancien_pointeur_lecture); 1892: pointeur_lecture += difference_lecture; 1893: } 1894: } 1895: else if (((*s_objet_argument_1).type == LST) && 1896: ((*s_objet_argument_2).type == INT) && 1897: ((*s_objet_argument_3).type == LST)) 1898: { 1899: if ((*((integer8 *) (*s_objet_argument_2).objet)) <= 0) 1900: { 1901: liberation(s_etat_processus, s_objet_argument_1); 1902: liberation(s_etat_processus, s_objet_argument_2); 1903: liberation(s_etat_processus, s_objet_argument_3); 1904: 1905: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1906: return; 1907: } 1908: 1909: if ((s_objet_resultat = copie_objet(s_etat_processus, 1910: s_objet_argument_3, 'N')) == NULL) 1911: { 1912: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1913: return; 1914: } 1915: 1916: l_element_courant = (*s_objet_resultat).objet; 1917: l_element_precedent = NULL; 1918: position = 1; 1919: 1920: while(position < (*((integer8 *) (*s_objet_argument_2).objet))) 1921: { 1922: if (l_element_courant == NULL) 1923: { 1924: liberation(s_etat_processus, s_objet_argument_1); 1925: liberation(s_etat_processus, s_objet_argument_2); 1926: liberation(s_etat_processus, s_objet_argument_3); 1927: liberation(s_etat_processus, s_objet_resultat); 1928: 1929: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1930: return; 1931: } 1932: 1933: position++; 1934: l_element_precedent = l_element_courant; 1935: l_element_courant = (*l_element_courant).suivant; 1936: } 1937: 1938: l_element_a_supprimer = l_element_courant; 1939: 1940: if (l_element_courant == NULL) 1941: { 1942: liberation(s_etat_processus, s_objet_argument_1); 1943: liberation(s_etat_processus, s_objet_argument_2); 1944: liberation(s_etat_processus, s_objet_argument_3); 1945: liberation(s_etat_processus, s_objet_resultat); 1946: 1947: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1948: return; 1949: } 1950: 1951: if ((s_objet_intermediaire = copie_objet(s_etat_processus, 1952: s_objet_argument_1, 'N')) == NULL) 1953: { 1954: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1955: return; 1956: } 1957: 1958: if (l_element_precedent == NULL) 1959: { 1960: (*s_objet_resultat).objet = (*s_objet_intermediaire).objet; 1961: } 1962: else 1963: { 1964: (*l_element_precedent).suivant = (*s_objet_intermediaire).objet; 1965: } 1966: 1967: // (*l_element_precedent).suivant contient le premier maillon 1968: // de la liste accrochée, l_element_a_supprimer est le premier maillons 1969: // à supprimer. 1970: 1971: l_element_courant = (*s_objet_intermediaire).objet; 1972: (*s_objet_intermediaire).objet = l_element_a_supprimer; 1973: 1974: l_element_courant_2 = l_element_a_supprimer; 1975: l_element_precedent_2 = NULL; 1976: 1977: for(;;) 1978: { 1979: if (l_element_courant == NULL) 1980: { 1981: // La nouvelle liste est plus courte. On raboute les éléments 1982: // restant de l'ancienne liste à la nouvelle. 1983: 1984: if (l_element_precedent == NULL) 1985: { 1986: (*s_objet_resultat).objet = l_element_courant_2; 1987: } 1988: else 1989: { 1990: (*l_element_precedent).suivant = l_element_courant_2; 1991: } 1992: 1993: if (l_element_precedent_2 == NULL) 1994: { 1995: (*s_objet_intermediaire).objet = NULL; 1996: } 1997: else 1998: { 1999: (*l_element_precedent_2).suivant = NULL; 2000: } 2001: 2002: break; 2003: } 2004: 2005: if (l_element_courant_2 == NULL) 2006: { 2007: // L'ancienne liste est plus courte. 2008: break; 2009: } 2010: 2011: l_element_precedent = l_element_courant; 2012: l_element_precedent_2 = l_element_courant_2; 2013: l_element_courant = (*l_element_courant).suivant; 2014: l_element_courant_2 = (*l_element_courant_2).suivant; 2015: } 2016: 2017: liberation(s_etat_processus, s_objet_intermediaire); 2018: } 2019: else 2020: { 2021: liberation(s_etat_processus, s_objet_argument_1); 2022: liberation(s_etat_processus, s_objet_argument_2); 2023: liberation(s_etat_processus, s_objet_argument_3); 2024: 2025: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2026: return; 2027: } 2028: 2029: liberation(s_etat_processus, s_objet_argument_1); 2030: liberation(s_etat_processus, s_objet_argument_2); 2031: liberation(s_etat_processus, s_objet_argument_3); 2032: 2033: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2034: s_objet_resultat) == d_erreur) 2035: { 2036: return; 2037: } 2038: 2039: return; 2040: } 2041: 2042: // vim: ts=4