![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chainage.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to chainage.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.35 ! bertrand 3: RPL/2 (R) version 4.1.2
1.24 bertrand 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
1.1 bertrand 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:
1.15 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
1.8 bertrand 28: Routine de chaînage du programme (lecture du fichier puis constitution
29: de la chaîne exécutable)
1.1 bertrand 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;
1.19 bertrand 52: logical1 initialisation;
1.1 bertrand 53: logical1 ouverture;
54: logical1 presence_chaine;
55:
56: long i;
57: long nombre_caracteres_source;
58:
59: unsigned char *commande;
1.6 bertrand 60: unsigned char *executable_candidat;
1.17 bertrand 61:
62: # ifndef OS2
1.19 bertrand 63: unsigned char *instructions = "%s/bin/%s %s | "
1.1 bertrand 64: "%s/bin/rpliconv `%s/bin/rplfile "
1.20 bertrand 65: "-m %s/share/rplfiles -i %s | "
66: "%s/bin/rplawk "
67: "'{ print $3; }' | %s/bin/rplawk -F= "
1.1 bertrand 68: "'{ if ($2 != \"\") printf(\"-f %%s\", "
1.10 bertrand 69: "$2); }'` -t %s//IGNORE > %s";
1.17 bertrand 70: # else
1.21 bertrand 71: unsigned char *instructions = BOURNE_SHELL " -c \""
1.19 bertrand 72: "%s/bin/%s %s | "
1.17 bertrand 73: "%s/bin/rpliconv `%s/bin/rplfile "
1.22 bertrand 74: "-m %s/share/rplfiles -i %s | "
75: "%s/bin/rplawk "
1.20 bertrand 76: "'{ print $3; }' | %s/bin/rplawk -F= "
1.17 bertrand 77: "'{ if ($2 != \\\"\\\") "
78: "printf(\\\"-f %%s\\\", "
1.22 bertrand 79: "$2); }'` -t %s//IGNORE > %s\"";
1.17 bertrand 80: # endif
1.1 bertrand 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:
1.6 bertrand 117: // Avant d'exécuter la commande, on teste les sommes de hashage
118: // des utilitaires de la famille RPL/2.
119:
1.5 bertrand 120: if ((*s_etat_processus).rpl_home == NULL)
1.1 bertrand 121: {
1.5 bertrand 122: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
123: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
1.20 bertrand 124: (6 * strlen(d_exec_path)) + strlen(d_locale) +
125: strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
1.5 bertrand 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: }
1.1 bertrand 133:
1.5 bertrand 134: sprintf(commande, instructions,
1.19 bertrand 135: d_exec_path, ds_preprocesseur,
1.5 bertrand 136: (*s_etat_processus).nom_fichier_source,
1.19 bertrand 137: d_exec_path, d_exec_path,
1.5 bertrand 138: d_exec_path, (*s_etat_processus).nom_fichier_source,
1.20 bertrand 139: d_exec_path, d_exec_path, d_locale, nom_fichier_temporaire);
1.6 bertrand 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);
1.20 bertrand 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);
1.1 bertrand 232: }
1.5 bertrand 233: else
234: {
235: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
236: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
1.20 bertrand 237: (6 * strlen((*s_etat_processus).rpl_home)) +
238: strlen(d_locale) +
239: strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
1.5 bertrand 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: }
1.1 bertrand 247:
1.5 bertrand 248: sprintf(commande, instructions,
1.20 bertrand 249: (*s_etat_processus).rpl_home, ds_preprocesseur,
1.5 bertrand 250: (*s_etat_processus).nom_fichier_source,
1.20 bertrand 251: (*s_etat_processus).rpl_home,
252: (*s_etat_processus).rpl_home,
1.5 bertrand 253: (*s_etat_processus).rpl_home,
254: (*s_etat_processus).nom_fichier_source,
1.20 bertrand 255: (*s_etat_processus).rpl_home,
256: (*s_etat_processus).rpl_home,
257: d_locale, nom_fichier_temporaire);
1.6 bertrand 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);
1.20 bertrand 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);
1.5 bertrand 350: }
1.1 bertrand 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;
1.19 bertrand 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: */
1.1 bertrand 419:
420: while(drapeau_fin == d_faux)
421: {
422: if ((caractere = getc(f_source)) != EOF)
423: {
1.19 bertrand 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:
1.1 bertrand 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