![]() ![]() | ![]() |
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 'trnc' 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_trnc(struct_processus *s_etat_processus) 40: { 41: int parametre; 42: 43: logical1 i43; 44: logical1 i44; 45: logical1 i49; 46: logical1 i50; 47: logical1 i53; 48: logical1 i54; 49: logical1 i55; 50: logical1 i56; 51: 52: struct_objet *s_objet_argument_1; 53: struct_objet *s_objet_argument_2; 54: struct_objet *s_objet_parametre; 55: 56: unsigned char *instruction_courante; 57: unsigned char *valeur_binaire; 58: 59: unsigned long i; 60: unsigned long j; 61: 62: (*s_etat_processus).erreur_execution = d_ex; 63: 64: if ((*s_etat_processus).affichage_arguments == 'Y') 65: { 66: printf("\n TRNC "); 67: 68: if ((*s_etat_processus).langue == 'F') 69: { 70: printf("(troncature)\n\n"); 71: } 72: else 73: { 74: printf("(truncation)\n\n"); 75: } 76: 77: printf(" 2: %s, %s, %s, %s, %s, %s,\n" 78: " %s, %s, %s\n", 79: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX); 80: printf(" 1: %s\n", d_INT); 81: printf("-> 1: %s, %s, %s, %s, %s, %s,\n" 82: " %s, %s, %s\n", 83: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX); 84: 85: return; 86: } 87: else if ((*s_etat_processus).test_instruction == 'Y') 88: { 89: (*s_etat_processus).nombre_arguments = -1; 90: return; 91: } 92: 93: if (test_cfsf(s_etat_processus, 31) == d_vrai) 94: { 95: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 96: { 97: return; 98: } 99: } 100: 101: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 102: &s_objet_argument_1) == d_erreur) 103: { 104: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 105: return; 106: } 107: 108: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 109: &s_objet_argument_2) == d_erreur) 110: { 111: liberation(s_etat_processus, s_objet_argument_1); 112: 113: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 114: return; 115: } 116: 117: if (((*s_objet_argument_1).type == INT) && 118: (((*s_objet_argument_2).type == INT) || 119: ((*s_objet_argument_2).type == REL) || 120: ((*s_objet_argument_2).type == CPL) || 121: ((*s_objet_argument_2).type == VIN) || 122: ((*s_objet_argument_2).type == VRL) || 123: ((*s_objet_argument_2).type == VCX) || 124: ((*s_objet_argument_2).type == MIN) || 125: ((*s_objet_argument_2).type == MRL) || 126: ((*s_objet_argument_2).type == MCX))) 127: { 128: parametre = (*((integer8 *) (*s_objet_argument_1).objet)); 129: 130: if ((parametre >= -15) && (parametre <= 15)) 131: { 132: if ((s_objet_parametre = allocation(s_etat_processus, BIN)) 133: == NULL) 134: { 135: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 136: return; 137: } 138: 139: (*((integer8 *) (*s_objet_parametre).objet)) = 140: abs((*((integer8 *) (*s_objet_argument_1).objet))); 141: 142: i43 = test_cfsf(s_etat_processus, 43); 143: i44 = test_cfsf(s_etat_processus, 44); 144: 145: sf(s_etat_processus, 44); 146: cf(s_etat_processus, 43); 147: 148: if ((valeur_binaire = formateur(s_etat_processus, 0, 149: s_objet_parametre)) == NULL) 150: { 151: liberation(s_etat_processus, s_objet_parametre); 152: 153: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 154: return; 155: } 156: 157: liberation(s_etat_processus, s_objet_parametre); 158: 159: if (i43 == d_vrai) 160: { 161: sf(s_etat_processus, 43); 162: } 163: else 164: { 165: cf(s_etat_processus, 43); 166: } 167: 168: if (i44 == d_vrai) 169: { 170: sf(s_etat_processus, 44); 171: } 172: else 173: { 174: cf(s_etat_processus, 44); 175: } 176: 177: i53 = test_cfsf(s_etat_processus, 53); 178: i54 = test_cfsf(s_etat_processus, 54); 179: i55 = test_cfsf(s_etat_processus, 55); 180: i56 = test_cfsf(s_etat_processus, 56); 181: 182: for(j = 53, i = strlen(valeur_binaire) - 2; i >= 2; i--) 183: { 184: if (valeur_binaire[i] == '0') 185: { 186: cf(s_etat_processus, j++); 187: } 188: else 189: { 190: sf(s_etat_processus, j++); 191: } 192: } 193: 194: for(; j <= 56; cf(s_etat_processus, j++)); 195: 196: free(valeur_binaire); 197: 198: i49 = test_cfsf(s_etat_processus, 49); 199: i50 = test_cfsf(s_etat_processus, 50); 200: 201: if (parametre >= 0) 202: { 203: // Troncature FIX 204: sf(s_etat_processus, 49); 205: cf(s_etat_processus, 50); 206: } 207: else 208: { 209: // Troncature SCI 210: cf(s_etat_processus, 49); 211: sf(s_etat_processus, 50); 212: } 213: 214: instruction_courante = (*s_etat_processus).instruction_courante; 215: 216: if (((*s_etat_processus).instruction_courante = 217: formateur(s_etat_processus, 0, s_objet_argument_2)) == NULL) 218: { 219: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 220: (*s_etat_processus).instruction_courante = instruction_courante; 221: return; 222: } 223: 224: if (i49 == d_vrai) 225: { 226: sf(s_etat_processus, 49); 227: } 228: else 229: { 230: cf(s_etat_processus, 49); 231: } 232: 233: if (i50 == d_vrai) 234: { 235: sf(s_etat_processus, 50); 236: } 237: else 238: { 239: cf(s_etat_processus, 50); 240: } 241: 242: if (i53 == d_vrai) 243: { 244: sf(s_etat_processus, 53); 245: } 246: else 247: { 248: cf(s_etat_processus, 53); 249: } 250: 251: if (i54 == d_vrai) 252: { 253: sf(s_etat_processus, 54); 254: } 255: else 256: { 257: cf(s_etat_processus, 54); 258: } 259: 260: if (i55 == d_vrai) 261: { 262: sf(s_etat_processus, 55); 263: } 264: else 265: { 266: cf(s_etat_processus, 55); 267: } 268: 269: if (i56 == d_vrai) 270: { 271: sf(s_etat_processus, 56); 272: } 273: else 274: { 275: cf(s_etat_processus, 56); 276: } 277: 278: recherche_type(s_etat_processus); 279: 280: free((*s_etat_processus).instruction_courante); 281: (*s_etat_processus).instruction_courante = instruction_courante; 282: 283: if ((*s_etat_processus).erreur_systeme != d_es) 284: { 285: return; 286: } 287: 288: if ((*s_etat_processus).erreur_execution != d_ex) 289: { 290: liberation(s_etat_processus, s_objet_argument_1); 291: liberation(s_etat_processus, s_objet_argument_2); 292: return; 293: } 294: } 295: else 296: { 297: liberation(s_etat_processus, s_objet_argument_1); 298: liberation(s_etat_processus, s_objet_argument_2); 299: 300: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 301: return; 302: } 303: } 304: 305: /* 306: -------------------------------------------------------------------------------- 307: Fonction troncature impossible à réaliser 308: -------------------------------------------------------------------------------- 309: */ 310: 311: else 312: { 313: liberation(s_etat_processus, s_objet_argument_1); 314: liberation(s_etat_processus, s_objet_argument_2); 315: 316: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 317: return; 318: } 319: 320: liberation(s_etat_processus, s_objet_argument_1); 321: liberation(s_etat_processus, s_objet_argument_2); 322: 323: return; 324: } 325: 326: 327: /* 328: ================================================================================ 329: Fonction 'table->' 330: ================================================================================ 331: Entrées : structure processus 332: -------------------------------------------------------------------------------- 333: Sorties : 334: -------------------------------------------------------------------------------- 335: Effets de bord : néant 336: ================================================================================ 337: */ 338: 339: void 340: instruction_table_fleche(struct_processus *s_etat_processus) 341: { 342: struct_objet *s_objet; 343: struct_objet *s_objet_resultat; 344: 345: unsigned long i; 346: 347: (*s_etat_processus).erreur_execution = d_ex; 348: 349: if ((*s_etat_processus).affichage_arguments == 'Y') 350: { 351: printf("\n TABLE-> "); 352: 353: if ((*s_etat_processus).langue == 'F') 354: { 355: printf("(expansion d'une table)\n\n"); 356: } 357: else 358: { 359: printf("(expand table)\n\n"); 360: } 361: 362: printf(" 1: %s\n", d_TAB); 363: printf("-> n: %s, %s, %s, %s, %s, %s,\n" 364: " %s, %s, %s, %s, %s,\n" 365: " %s, %s, %s, %s, %s,\n" 366: " %s, %s\n", 367: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 368: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB); 369: printf(" ...\n"); 370: printf(" 2: %s, %s, %s, %s, %s, %s,\n" 371: " %s, %s, %s, %s, %s,\n" 372: " %s, %s, %s, %s, %s,\n" 373: " %s, %s\n", 374: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 375: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB); 376: printf(" 1: %s\n", d_INT); 377: 378: return; 379: } 380: else if ((*s_etat_processus).test_instruction == 'Y') 381: { 382: (*s_etat_processus).nombre_arguments = -1; 383: return; 384: } 385: 386: if (test_cfsf(s_etat_processus, 31) == d_vrai) 387: { 388: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 389: { 390: return; 391: } 392: } 393: 394: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 395: &s_objet) == d_erreur) 396: { 397: return; 398: } 399: 400: if ((*s_objet).type != TBL) 401: { 402: liberation(s_etat_processus, s_objet); 403: 404: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 405: return; 406: } 407: 408: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 409: .nombre_elements; i++) 410: { 411: if (((*((struct_tableau *) (*s_objet).objet)).elements[i] = 412: copie_objet(s_etat_processus, (*((struct_tableau *) 413: (*s_objet).objet)).elements[i], 'P')) == NULL) 414: { 415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 416: return; 417: } 418: 419: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 420: (*((struct_tableau *) (*s_objet).objet)).elements[i]) 421: == d_erreur) 422: { 423: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 424: return; 425: } 426: } 427: 428: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 429: { 430: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 431: return; 432: } 433: 434: (*((integer8 *) ((*s_objet_resultat).objet))) = (integer8) 435: (*((struct_tableau *) (*s_objet).objet)).nombre_elements; 436: 437: liberation(s_etat_processus, s_objet); 438: 439: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 440: s_objet_resultat) == d_erreur) 441: { 442: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 443: return; 444: } 445: 446: return; 447: } 448: 449: 450: /* 451: ================================================================================ 452: Fonction 'trim' 453: ================================================================================ 454: Entrées : pointeur sur une structure struct_processus 455: -------------------------------------------------------------------------------- 456: Sorties : 457: -------------------------------------------------------------------------------- 458: Effets de bord : néant 459: ================================================================================ 460: */ 461: 462: void 463: instruction_trim(struct_processus *s_etat_processus) 464: { 465: struct_objet *s_objet_argument; 466: struct_objet *s_objet_resultat; 467: 468: unsigned char *debut; 469: unsigned char *fin; 470: 471: (*s_etat_processus).erreur_execution = d_ex; 472: 473: if ((*s_etat_processus).affichage_arguments == 'Y') 474: { 475: printf("\n TRIM "); 476: 477: if ((*s_etat_processus).langue == 'F') 478: { 479: printf("(suppression des espaces initiaux et finaux d'une " 480: "chaîne)\n\n"); 481: } 482: else 483: { 484: printf("(delete initial and final spaces from string)\n\n"); 485: } 486: 487: printf(" 1: %s\n", d_CHN); 488: printf("-> 1: %s\n", d_CHN); 489: 490: return; 491: } 492: else if ((*s_etat_processus).test_instruction == 'Y') 493: { 494: (*s_etat_processus).nombre_arguments = -1; 495: return; 496: } 497: 498: if (test_cfsf(s_etat_processus, 31) == d_vrai) 499: { 500: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 501: { 502: return; 503: } 504: } 505: 506: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 507: &s_objet_argument) == d_erreur) 508: { 509: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 510: return; 511: } 512: 513: if ((*s_objet_argument).type == CHN) 514: { 515: debut = (unsigned char *) (*s_objet_argument).objet; 516: 517: while(((*debut) != d_code_fin_chaine) && 518: (((*debut) == d_code_espace) 519: || ((*debut) == d_code_retour_chariot) 520: || ((*debut) == d_code_tabulation))) 521: { 522: debut++; 523: } 524: 525: fin = &(((unsigned char *) (*s_objet_argument).objet) 526: [strlen((unsigned char *) (*s_objet_argument).objet) - 1]); 527: 528: while((fin > debut) && 529: (((*fin) == d_code_espace) 530: || ((*fin) == d_code_retour_chariot) 531: || ((*fin) == d_code_tabulation))) 532: { 533: fin--; 534: } 535: 536: (*(++fin)) = d_code_fin_chaine; 537: 538: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL) 539: { 540: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 541: return; 542: } 543: 544: if (((*s_objet_resultat).objet = malloc((1 + fin - debut) 545: * sizeof(unsigned char))) == NULL) 546: { 547: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 548: return; 549: } 550: 551: strcpy((unsigned char *) (*s_objet_resultat).objet, debut); 552: } 553: 554: /* 555: -------------------------------------------------------------------------------- 556: Fonction TRIM impossible à réaliser 557: -------------------------------------------------------------------------------- 558: */ 559: 560: else 561: { 562: liberation(s_etat_processus, s_objet_argument); 563: 564: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 565: return; 566: } 567: 568: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 569: s_objet_resultat) == d_erreur) 570: { 571: return; 572: } 573: 574: liberation(s_etat_processus, s_objet_argument); 575: 576: return; 577: } 578: 579: 580: /* 581: ================================================================================ 582: Fonction 'tokenize' 583: ================================================================================ 584: Entrées : pointeur sur une structure struct_processus 585: -------------------------------------------------------------------------------- 586: Sorties : 587: -------------------------------------------------------------------------------- 588: Effets de bord : néant 589: ================================================================================ 590: */ 591: 592: void 593: instruction_tokenize(struct_processus *s_etat_processus) 594: { 595: struct_objet *s_objet_argument; 596: struct_objet *s_objet_resultat; 597: 598: struct_liste_chainee *l_element_courant; 599: 600: unsigned char *ptr; 601: unsigned char *ptr2; 602: unsigned char *registre_instruction_courante; 603: unsigned char *registre_definitions_chainees; 604: unsigned char *tampon; 605: 606: unsigned long nombre_caracteres_echappement; 607: unsigned long registre_longueur_definitions_chainees; 608: unsigned long registre_position_courante; 609: 610: (*s_etat_processus).erreur_execution = d_ex; 611: 612: if ((*s_etat_processus).affichage_arguments == 'Y') 613: { 614: printf("\n TOKENIZE "); 615: 616: if ((*s_etat_processus).langue == 'F') 617: { 618: printf("(extraction d'objets en sous-chaînes)\n\n"); 619: } 620: else 621: { 622: printf("(extract objects in substrings)\n\n"); 623: } 624: 625: printf(" 1: %s\n", d_CHN); 626: printf("-> 1: %s\n", d_LST); 627: 628: return; 629: } 630: else if ((*s_etat_processus).test_instruction == 'Y') 631: { 632: (*s_etat_processus).nombre_arguments = -1; 633: return; 634: } 635: 636: if (test_cfsf(s_etat_processus, 31) == d_vrai) 637: { 638: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 639: { 640: return; 641: } 642: } 643: 644: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 645: &s_objet_argument) == d_erreur) 646: { 647: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 648: return; 649: } 650: 651: if ((*s_objet_argument).type == CHN) 652: { 653: // Conversion des caractères d'échappement 654: 655: ptr = (unsigned char *) (*s_objet_argument).objet; 656: ptr2 = ptr; 657: 658: while((*ptr) != d_code_fin_chaine) 659: { 660: (*ptr2) = (*ptr); 661: 662: // Début de la séquence d'échappement 663: 664: if ((*ptr) == '\\') 665: { 666: if ((*(ptr + 1)) == '"') 667: { 668: ptr++; 669: (*ptr2) = '\"'; 670: } 671: else if ((*(ptr + 1)) == 'n') 672: { 673: ptr++; 674: (*ptr2) = '\n'; 675: } 676: else if ((*(ptr + 1)) == 't') 677: { 678: ptr++; 679: (*ptr2) = '\t'; 680: } 681: else if ((*(ptr + 1)) == '\\') 682: { 683: ptr++; 684: } 685: else 686: { 687: if ((*s_etat_processus).langue == 'F') 688: { 689: printf("+++Information : Séquence d'échappement " 690: "inconnue [%d]\n", (int) getpid()); 691: } 692: else 693: { 694: printf("+++Warning : Unknown escape code " 695: "[%d]\n", (int) getpid()); 696: } 697: } 698: } 699: 700: ptr++; 701: ptr2++; 702: } 703: 704: (*ptr2) = d_code_fin_chaine; 705: 706: // Remplacement des éventuels retours à la ligne et tabulations par 707: // des espaces. 708: 709: ptr = (unsigned char *) (*s_objet_argument).objet; 710: 711: while((*ptr) != d_code_fin_chaine) 712: { 713: if (((*ptr) == d_code_retour_chariot) || 714: ((*ptr) == d_code_tabulation)) 715: { 716: (*ptr) = d_code_espace; 717: } 718: 719: ptr++; 720: } 721: 722: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) 723: { 724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 725: return; 726: } 727: 728: registre_instruction_courante = (*s_etat_processus) 729: .instruction_courante; 730: registre_definitions_chainees = (*s_etat_processus) 731: .definitions_chainees; 732: registre_longueur_definitions_chainees = (*s_etat_processus) 733: .longueur_definitions_chainees; 734: registre_position_courante = (*s_etat_processus).position_courante; 735: 736: (*s_etat_processus).definitions_chainees = (unsigned char *) 737: (*s_objet_argument).objet; 738: (*s_etat_processus).longueur_definitions_chainees = 739: strlen((*s_etat_processus).definitions_chainees); 740: (*s_etat_processus).position_courante = 0; 741: 742: l_element_courant = NULL; 743: 744: while((*s_etat_processus).position_courante 745: < (*s_etat_processus).longueur_definitions_chainees) 746: { 747: if (recherche_instruction_suivante(s_etat_processus) == d_erreur) 748: { 749: free((*s_etat_processus).instruction_courante); 750: 751: (*s_etat_processus).instruction_courante = 752: registre_instruction_courante; 753: (*s_etat_processus).definitions_chainees = 754: registre_definitions_chainees; 755: (*s_etat_processus).longueur_definitions_chainees = 756: registre_longueur_definitions_chainees; 757: (*s_etat_processus).position_courante = 758: registre_position_courante; 759: 760: liberation(s_etat_processus, s_objet_argument); 761: liberation(s_etat_processus, s_objet_resultat); 762: 763: return; 764: } 765: 766: if ((*s_etat_processus).instruction_courante[0] != 767: d_code_fin_chaine) 768: { 769: if (l_element_courant == NULL) 770: { 771: if (((*s_objet_resultat).objet = 772: allocation_maillon(s_etat_processus)) == NULL) 773: { 774: (*s_etat_processus).erreur_systeme = 775: d_es_allocation_memoire; 776: return; 777: } 778: 779: l_element_courant = (*s_objet_resultat).objet; 780: } 781: else 782: { 783: if (((*l_element_courant).suivant = 784: allocation_maillon(s_etat_processus)) == NULL) 785: { 786: (*s_etat_processus).erreur_systeme = 787: d_es_allocation_memoire; 788: return; 789: } 790: 791: l_element_courant = (*l_element_courant).suivant; 792: } 793: 794: if (((*l_element_courant).donnee = allocation(s_etat_processus, 795: CHN)) == NULL) 796: { 797: (*s_etat_processus).erreur_systeme = 798: d_es_allocation_memoire; 799: return; 800: } 801: 802: (*(*l_element_courant).donnee).objet = (*s_etat_processus) 803: .instruction_courante; 804: (*l_element_courant).suivant = NULL; 805: 806: /* 807: * Rajout du caractère d'échappement devant un guillemet 808: */ 809: 810: nombre_caracteres_echappement = 0; 811: ptr = (unsigned char *) (*(*l_element_courant).donnee).objet; 812: 813: while((*ptr) != d_code_fin_chaine) 814: { 815: if ((*ptr) == '\"') 816: { 817: nombre_caracteres_echappement++; 818: } 819: 820: ptr++; 821: } 822: 823: if (nombre_caracteres_echappement != 0) 824: { 825: tampon = (unsigned char *) (*(*l_element_courant) 826: .donnee).objet; 827: 828: if (((*(*l_element_courant).donnee).objet = malloc( 829: (strlen(tampon) + 1 + nombre_caracteres_echappement) 830: * sizeof(unsigned char))) == NULL) 831: { 832: (*s_etat_processus).erreur_systeme = 833: d_es_allocation_memoire; 834: return; 835: } 836: 837: ptr = tampon; 838: ptr2 = (*(*l_element_courant).donnee).objet; 839: 840: while((*ptr) != d_code_fin_chaine) 841: { 842: if ((*ptr) == '\"') 843: { 844: (*(ptr2++)) = '\\'; 845: 846: } 847: else if ((*ptr) == '\\') 848: { 849: (*(ptr2++)) = '\\'; 850: } 851: 852: (*(ptr2++)) = (*(ptr++)); 853: } 854: 855: (*ptr2) = d_code_fin_chaine; 856: free(tampon); 857: } 858: } 859: else 860: { 861: free((*s_etat_processus).instruction_courante); 862: } 863: } 864: 865: (*s_etat_processus).instruction_courante = 866: registre_instruction_courante; 867: (*s_etat_processus).definitions_chainees = 868: registre_definitions_chainees; 869: (*s_etat_processus).longueur_definitions_chainees = 870: registre_longueur_definitions_chainees; 871: (*s_etat_processus).position_courante = registre_position_courante; 872: } 873: 874: /* 875: -------------------------------------------------------------------------------- 876: Fonction TOKENIZE impossible à réaliser 877: -------------------------------------------------------------------------------- 878: */ 879: 880: else 881: { 882: liberation(s_etat_processus, s_objet_argument); 883: 884: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 885: return; 886: } 887: 888: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 889: s_objet_resultat) == d_erreur) 890: { 891: return; 892: } 893: 894: liberation(s_etat_processus, s_objet_argument); 895: 896: return; 897: } 898: 899: 900: /* 901: ================================================================================ 902: Fonction 't->l' 903: ================================================================================ 904: Entrées : pointeur sur une structure struct_processus 905: -------------------------------------------------------------------------------- 906: Sorties : 907: -------------------------------------------------------------------------------- 908: Effets de bord : néant 909: ================================================================================ 910: */ 911: 912: void 913: instruction_t_vers_l(struct_processus *s_etat_processus) 914: { 915: logical1 last; 916: 917: (*s_etat_processus).erreur_execution = d_ex; 918: 919: if ((*s_etat_processus).affichage_arguments == 'Y') 920: { 921: printf("\n T->L "); 922: 923: if ((*s_etat_processus).langue == 'F') 924: { 925: printf("(converison d'une table en liste)\n\n"); 926: } 927: else 928: { 929: printf("(convert table to list)\n\n"); 930: } 931: 932: printf(" 1: %s\n", d_TAB); 933: printf("-> 1: %s\n", d_LST); 934: return; 935: } 936: else if ((*s_etat_processus).test_instruction == 'Y') 937: { 938: (*s_etat_processus).nombre_arguments = -1; 939: return; 940: } 941: 942: if (test_cfsf(s_etat_processus, 31) == d_vrai) 943: { 944: last = d_vrai; 945: cf(s_etat_processus, 31); 946: 947: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 948: { 949: return; 950: } 951: } 952: else 953: { 954: last = d_faux; 955: } 956: 957: instruction_table_fleche(s_etat_processus); 958: 959: if (((*s_etat_processus).erreur_systeme == d_es) && 960: ((*s_etat_processus).erreur_execution == d_ex)) 961: { 962: instruction_fleche_list(s_etat_processus); 963: } 964: 965: if (last == d_vrai) 966: { 967: sf(s_etat_processus, 31); 968: } 969: 970: return; 971: } 972: // vim: ts=4