![]() ![]() | ![]() |
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: Routine de chaînage du programme (lecture du fichier puis constitution 29: de la chaîne exécutable) 30: ================================================================================ 31: Entrées: structure processus 32: -------------------------------------------------------------------------------- 33: Sortie: drapeau d'erreur 34: -------------------------------------------------------------------------------- 35: Effets de bord: néant 36: ================================================================================ 37: */ 38: 39: logical1 40: chainage(struct_processus *s_etat_processus) 41: { 42: char *nom_fichier_temporaire; 43: 44: file *f_source; 45: 46: int caractere; 47: int erreur; 48: int erreur_os; 49: 50: logical1 drapeau_fin; 51: logical1 existence; 52: logical1 initialisation; 53: logical1 ouverture; 54: logical1 presence_chaine; 55: 56: long i; 57: long nombre_caracteres_source; 58: 59: unsigned char *commande; 60: unsigned char *executable_candidat; 61: 62: # ifndef OS2 63: unsigned char *instructions = "%s/bin/%s %s | " 64: "%s/bin/rpliconv `%s/bin/rplfile " 65: "-m %s/share/rplfiles -i %s | " 66: "%s/bin/rplawk " 67: "'{ print $3; }' | %s/bin/rplawk -F= " 68: "'{ if ($2 != \"\") printf(\"-f %%s\", " 69: "$2); }'` -t %s//IGNORE > %s"; 70: # else 71: unsigned char *instructions = BOURNE_SHELL " -c \"" 72: "%s/bin/%s %s | " 73: "%s/bin/rpliconv `%s/bin/rplfile " 74: "-m %s/share/rplfiles -i %s | " 75: "%s/bin/rplawk " 76: "'{ print $3; }' | %s/bin/rplawk -F= " 77: "'{ if ($2 != \\\"\\\") " 78: "printf(\\\"-f %%s\\\", " 79: "$2); }'` -t %s//IGNORE > %s\""; 80: # endif 81: 82: unsigned long unite_fichier; 83: 84: if ((*s_etat_processus).debug == d_vrai) 85: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0) 86: { 87: printf("\n"); 88: 89: if ((*s_etat_processus).langue == 'F') 90: { 91: printf("[%d] Appel au préprocesseur\n", (int) getpid()); 92: } 93: else 94: { 95: printf("[%d] Preprocessing\n", (int) getpid()); 96: } 97: 98: fflush(stdout); 99: } 100: 101: erreur = caracteristiques_fichier(s_etat_processus, 102: (*s_etat_processus).nom_fichier_source, &existence, 103: &ouverture, &unite_fichier); 104: 105: erreur_os = d_absence_erreur; 106: 107: if ((existence == d_vrai) && (erreur == 0)) 108: { 109: if ((nom_fichier_temporaire = creation_nom_fichier( 110: s_etat_processus, (*s_etat_processus) 111: .chemin_fichiers_temporaires)) == NULL) 112: { 113: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 114: return(d_erreur); 115: } 116: 117: // Avant d'exécuter la commande, on teste les sommes de hashage 118: // des utilitaires de la famille RPL/2. 119: 120: if ((*s_etat_processus).rpl_home == NULL) 121: { 122: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) + 123: (2 * strlen((*s_etat_processus).nom_fichier_source)) + 124: (6 * strlen(d_exec_path)) + strlen(d_locale) + 125: strlen(nom_fichier_temporaire) + strlen(instructions) - 21) 126: * sizeof(unsigned char))) == NULL) 127: { 128: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 129: 130: free(nom_fichier_temporaire); 131: return(d_erreur); 132: } 133: 134: sprintf(commande, instructions, 135: d_exec_path, ds_preprocesseur, 136: (*s_etat_processus).nom_fichier_source, 137: d_exec_path, d_exec_path, 138: d_exec_path, (*s_etat_processus).nom_fichier_source, 139: d_exec_path, d_exec_path, d_locale, nom_fichier_temporaire); 140: 141: if (alsprintf(&executable_candidat, "%s/bin/rpliconv", 142: d_exec_path) < 0) 143: { 144: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 145: return(d_erreur); 146: } 147: 148: if (controle(s_etat_processus, executable_candidat, "md5", 149: rpliconv_md5) != d_vrai) 150: { 151: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 152: return(d_erreur); 153: } 154: 155: if (controle(s_etat_processus, executable_candidat, "sha1", 156: rpliconv_sha1) != d_vrai) 157: { 158: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 159: return(d_erreur); 160: } 161: 162: free(executable_candidat); 163: 164: if (alsprintf(&executable_candidat, "%s/bin/rplfile", 165: d_exec_path) < 0) 166: { 167: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 168: return(d_erreur); 169: } 170: 171: if (controle(s_etat_processus, executable_candidat, "md5", 172: rplfile_md5) != d_vrai) 173: { 174: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 175: return(d_erreur); 176: } 177: 178: if (controle(s_etat_processus, executable_candidat, "sha1", 179: rplfile_sha1) != d_vrai) 180: { 181: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 182: return(d_erreur); 183: } 184: 185: free(executable_candidat); 186: 187: if (alsprintf(&executable_candidat, "%s/bin/rplpp", 188: d_exec_path) < 0) 189: { 190: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 191: return(d_erreur); 192: } 193: 194: if (controle(s_etat_processus, executable_candidat, "md5", 195: rplpp_md5) != d_vrai) 196: { 197: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 198: return(d_erreur); 199: } 200: 201: if (controle(s_etat_processus, executable_candidat, "sha1", 202: rplpp_sha1) != d_vrai) 203: { 204: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 205: return(d_erreur); 206: } 207: 208: free(executable_candidat); 209: 210: if (alsprintf(&executable_candidat, "%s/bin/rplawk", 211: d_exec_path) < 0) 212: { 213: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 214: return(d_erreur); 215: } 216: 217: if (controle(s_etat_processus, executable_candidat, "md5", 218: rplawk_md5) != d_vrai) 219: { 220: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 221: return(d_erreur); 222: } 223: 224: if (controle(s_etat_processus, executable_candidat, "sha1", 225: rplawk_sha1) != d_vrai) 226: { 227: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 228: return(d_erreur); 229: } 230: 231: free(executable_candidat); 232: } 233: else 234: { 235: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) + 236: (2 * strlen((*s_etat_processus).nom_fichier_source)) + 237: (6 * strlen((*s_etat_processus).rpl_home)) + 238: strlen(d_locale) + 239: strlen(nom_fichier_temporaire) + strlen(instructions) - 21) 240: * sizeof(unsigned char))) == NULL) 241: { 242: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 243: 244: free(nom_fichier_temporaire); 245: return(d_erreur); 246: } 247: 248: sprintf(commande, instructions, 249: (*s_etat_processus).rpl_home, ds_preprocesseur, 250: (*s_etat_processus).nom_fichier_source, 251: (*s_etat_processus).rpl_home, 252: (*s_etat_processus).rpl_home, 253: (*s_etat_processus).rpl_home, 254: (*s_etat_processus).nom_fichier_source, 255: (*s_etat_processus).rpl_home, 256: (*s_etat_processus).rpl_home, 257: d_locale, nom_fichier_temporaire); 258: 259: if (alsprintf(&executable_candidat, "%s/bin/rpliconv", 260: (*s_etat_processus).rpl_home) < 0) 261: { 262: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 263: return(d_erreur); 264: } 265: 266: if (controle(s_etat_processus, executable_candidat, "md5", 267: rpliconv_md5) != d_vrai) 268: { 269: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 270: return(d_erreur); 271: } 272: 273: if (controle(s_etat_processus, executable_candidat, "sha1", 274: rpliconv_sha1) != d_vrai) 275: { 276: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 277: return(d_erreur); 278: } 279: 280: free(executable_candidat); 281: 282: if (alsprintf(&executable_candidat, "%s/bin/rplfile", 283: (*s_etat_processus).rpl_home) < 0) 284: { 285: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 286: return(d_erreur); 287: } 288: 289: if (controle(s_etat_processus, executable_candidat, "md5", 290: rplfile_md5) != d_vrai) 291: { 292: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 293: return(d_erreur); 294: } 295: 296: if (controle(s_etat_processus, executable_candidat, "sha1", 297: rplfile_sha1) != d_vrai) 298: { 299: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 300: return(d_erreur); 301: } 302: 303: free(executable_candidat); 304: 305: if (alsprintf(&executable_candidat, "%s/bin/rplpp", 306: (*s_etat_processus).rpl_home) < 0) 307: { 308: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 309: return(d_erreur); 310: } 311: 312: if (controle(s_etat_processus, executable_candidat, "md5", 313: rplpp_md5) != d_vrai) 314: { 315: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 316: return(d_erreur); 317: } 318: 319: if (controle(s_etat_processus, executable_candidat, "sha1", 320: rplpp_sha1) != d_vrai) 321: { 322: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 323: return(d_erreur); 324: } 325: 326: free(executable_candidat); 327: 328: if (alsprintf(&executable_candidat, "%s/bin/rplawk", 329: (*s_etat_processus).rpl_home) < 0) 330: { 331: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 332: return(d_erreur); 333: } 334: 335: if (controle(s_etat_processus, executable_candidat, "md5", 336: rplawk_md5) != d_vrai) 337: { 338: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 339: return(d_erreur); 340: } 341: 342: if (controle(s_etat_processus, executable_candidat, "sha1", 343: rplawk_sha1) != d_vrai) 344: { 345: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 346: return(d_erreur); 347: } 348: 349: free(executable_candidat); 350: } 351: 352: if ((f_source = popen(commande, "r")) == NULL) 353: { 354: (*s_etat_processus).erreur_systeme = d_es_processus; 355: 356: free(nom_fichier_temporaire); 357: return(d_erreur); 358: } 359: 360: if (pclose(f_source) != EXIT_SUCCESS) 361: { 362: (*s_etat_processus).erreur_systeme = d_es_processus; 363: 364: free(nom_fichier_temporaire); 365: return(d_erreur); 366: } 367: 368: free(commande); 369: 370: if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL) 371: { 372: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 373: 374: if (destruction_fichier(nom_fichier_temporaire) == d_erreur) 375: { 376: free(nom_fichier_temporaire); 377: return(d_erreur); 378: } 379: 380: free(nom_fichier_temporaire); 381: return(d_erreur); 382: } 383: 384: nombre_caracteres_source = 0; 385: 386: while(getc(f_source) != EOF) 387: { 388: nombre_caracteres_source++; 389: } 390: 391: (*s_etat_processus).definitions_chainees = (unsigned char *) 392: malloc((nombre_caracteres_source + 1) * sizeof(unsigned char)); 393: 394: if ((*s_etat_processus).definitions_chainees == NULL) 395: { 396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 397: 398: if (destruction_fichier(nom_fichier_temporaire) == d_erreur) 399: { 400: free(nom_fichier_temporaire); 401: return(d_erreur); 402: } 403: 404: return(d_erreur); 405: } 406: else 407: { 408: rewind(f_source); 409: presence_chaine = d_faux; 410: 411: i = 0; 412: drapeau_fin = d_faux; 413: initialisation = d_vrai; 414: 415: /* 416: * Élimination du sharp-bang si nécessaire et des caractères 417: * inutiles. Conversion de caractères. 418: */ 419: 420: while(drapeau_fin == d_faux) 421: { 422: if ((caractere = getc(f_source)) != EOF) 423: { 424: if (initialisation == d_vrai) 425: { 426: if (caractere == '#') 427: { 428: if ((caractere = getc(f_source)) != EOF) 429: { 430: if (caractere == '!') 431: { 432: do 433: { 434: caractere = getc(f_source); 435: } while((caractere != EOF) && 436: (caractere != 437: d_code_retour_chariot)); 438: } 439: else 440: { 441: rewind(f_source); 442: caractere = getc(f_source); 443: } 444: } 445: } 446: 447: initialisation = d_faux; 448: } 449: 450: if ((caractere == d_code_retour_chariot) || 451: (caractere == d_code_tabulation) || 452: ((caractere == d_code_espace) && 453: (presence_chaine == d_faux))) 454: { 455: do 456: { 457: caractere = getc(f_source); 458: } while(((caractere == d_code_retour_chariot) || 459: (caractere == d_code_tabulation) || 460: ((caractere == d_code_espace) && 461: (presence_chaine == d_faux))) && 462: (caractere != EOF)); 463: 464: if (caractere != EOF) 465: { 466: ((*s_etat_processus).definitions_chainees)[i++] = 467: d_code_espace; 468: } 469: else 470: { 471: drapeau_fin = d_vrai; 472: } 473: } 474: 475: if ((((*s_etat_processus).definitions_chainees)[i] = 476: caractere) == '\"') 477: { 478: if (i > 0) 479: { 480: if (((*s_etat_processus).definitions_chainees) 481: [i - 1] != '\\') 482: { 483: presence_chaine = (presence_chaine == d_faux) 484: ? d_vrai : d_faux; 485: } 486: } 487: 488: i++; 489: } 490: else 491: { 492: i++; 493: } 494: } 495: else 496: { 497: drapeau_fin = d_vrai; 498: } 499: } 500: 501: if ((caractere == EOF) && (i > 0)) 502: { 503: i--; 504: } 505: 506: ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine; 507: 508: erreur_os = d_absence_erreur; 509: } 510: 511: (*s_etat_processus).longueur_definitions_chainees = 512: strlen((*s_etat_processus).definitions_chainees); 513: 514: if (fclose(f_source) != 0) 515: { 516: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 517: 518: if (destruction_fichier(nom_fichier_temporaire) == d_erreur) 519: { 520: free(nom_fichier_temporaire); 521: return(d_erreur); 522: } 523: 524: free(nom_fichier_temporaire); 525: return(d_erreur); 526: } 527: 528: if (destruction_fichier(nom_fichier_temporaire) == d_erreur) 529: { 530: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 531: 532: free(nom_fichier_temporaire); 533: return(d_erreur); 534: } 535: 536: free(nom_fichier_temporaire); 537: } 538: else 539: { 540: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 541: erreur_os = d_erreur; 542: } 543: 544: if (((*s_etat_processus).definitions_chainees = 545: realloc((*s_etat_processus).definitions_chainees, 546: ((*s_etat_processus).longueur_definitions_chainees + 1) * 547: sizeof(unsigned char))) == NULL) 548: { 549: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 550: return(d_erreur); 551: } 552: 553: return(erreur_os); 554: } 555: 556: 557: /* 558: ================================================================================ 559: Routine de compactage d'une chaîne de caractères 560: Tous les espaces et les retours à ligne surnuméraires sont enlevés. 561: ================================================================================ 562: Entrées: structure processus 563: -------------------------------------------------------------------------------- 564: Sortie: drapeau d'erreur 565: -------------------------------------------------------------------------------- 566: Effets de bord: néant 567: ================================================================================ 568: */ 569: 570: unsigned char * 571: compactage(unsigned char *chaine) 572: { 573: logical1 drapeau_fin; 574: logical1 presence_chaine; 575: 576: unsigned char caractere; 577: unsigned char *ptr_ecriture; 578: unsigned char *ptr_lecture; 579: 580: if (chaine == NULL) 581: { 582: return(NULL); 583: } 584: 585: presence_chaine = d_faux; 586: 587: drapeau_fin = d_faux; 588: ptr_lecture = chaine; 589: ptr_ecriture = chaine; 590: 591: while(drapeau_fin == d_faux) 592: { 593: if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine) 594: { 595: if ((caractere == d_code_retour_chariot) || 596: (caractere == d_code_tabulation) || 597: ((caractere == d_code_espace) && 598: (presence_chaine == d_faux))) 599: { 600: do 601: { 602: caractere = (*ptr_lecture++); 603: } while(((caractere == d_code_retour_chariot) || 604: (caractere == d_code_tabulation) || 605: ((caractere == d_code_espace) && 606: (presence_chaine == d_faux))) && 607: (caractere != d_code_fin_chaine)); 608: 609: if (caractere != d_code_fin_chaine) 610: { 611: (*ptr_ecriture++) = d_code_espace; 612: } 613: else 614: { 615: drapeau_fin = d_vrai; 616: } 617: } 618: 619: if (((*ptr_ecriture++) = caractere) == '\"') 620: { 621: presence_chaine = (presence_chaine == d_faux) 622: ? d_vrai : d_faux; 623: } 624: } 625: else 626: { 627: drapeau_fin = d_vrai; 628: } 629: } 630: 631: (*ptr_ecriture) = d_code_fin_chaine; 632: 633: return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char))); 634: } 635: 636: // vim: ts=4