1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.19
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: 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 | awk "
66: "'{ print $3; }' | awk -F= "
67: "'{ if ($2 != \"\") printf(\"-f %%s\", "
68: "$2); }'` -t %s//IGNORE > %s";
69: # else
70: unsigned char *instructions = "sh -c \""
71: "%s/bin/%s %s | "
72: "%s/bin/rpliconv `%s/bin/rplfile "
73: "-m %s/share/rplfiles -i %s | awk "
74: "'{ print $3; }' | awk -F= "
75: "'{ if ($2 != \\\"\\\") "
76: "printf(\\\"-f %%s\\\", "
77: "$2); }'` -t %s//IGNORE\" > %s";
78: # endif
79:
80: unsigned long unite_fichier;
81:
82: if ((*s_etat_processus).debug == d_vrai)
83: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
84: {
85: printf("\n");
86:
87: if ((*s_etat_processus).langue == 'F')
88: {
89: printf("[%d] Appel au préprocesseur\n", (int) getpid());
90: }
91: else
92: {
93: printf("[%d] Preprocessing\n", (int) getpid());
94: }
95:
96: fflush(stdout);
97: }
98:
99: erreur = caracteristiques_fichier(s_etat_processus,
100: (*s_etat_processus).nom_fichier_source, &existence,
101: &ouverture, &unite_fichier);
102:
103: erreur_os = d_absence_erreur;
104:
105: if ((existence == d_vrai) && (erreur == 0))
106: {
107: if ((nom_fichier_temporaire = creation_nom_fichier(
108: s_etat_processus, (*s_etat_processus)
109: .chemin_fichiers_temporaires)) == NULL)
110: {
111: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
112: return(d_erreur);
113: }
114:
115: // Avant d'exécuter la commande, on teste les sommes de hashage
116: // des utilitaires de la famille RPL/2.
117:
118: if ((*s_etat_processus).rpl_home == NULL)
119: {
120: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
121: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
122: (4 * strlen(d_exec_path)) + strlen(d_locale) +
123: strlen(nom_fichier_temporaire) + strlen(instructions) - 13)
124: * sizeof(unsigned char))) == NULL)
125: {
126: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
127:
128: free(nom_fichier_temporaire);
129: return(d_erreur);
130: }
131:
132: sprintf(commande, instructions,
133: d_exec_path, ds_preprocesseur,
134: (*s_etat_processus).nom_fichier_source,
135: d_exec_path, d_exec_path,
136: d_exec_path, (*s_etat_processus).nom_fichier_source,
137: d_locale, nom_fichier_temporaire);
138:
139: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
140: d_exec_path) < 0)
141: {
142: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
143: return(d_erreur);
144: }
145:
146: if (controle(s_etat_processus, executable_candidat, "md5",
147: rpliconv_md5) != d_vrai)
148: {
149: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
150: return(d_erreur);
151: }
152:
153: if (controle(s_etat_processus, executable_candidat, "sha1",
154: rpliconv_sha1) != d_vrai)
155: {
156: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
157: return(d_erreur);
158: }
159:
160: free(executable_candidat);
161:
162: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
163: d_exec_path) < 0)
164: {
165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
166: return(d_erreur);
167: }
168:
169: if (controle(s_etat_processus, executable_candidat, "md5",
170: rplfile_md5) != d_vrai)
171: {
172: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
173: return(d_erreur);
174: }
175:
176: if (controle(s_etat_processus, executable_candidat, "sha1",
177: rplfile_sha1) != d_vrai)
178: {
179: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
180: return(d_erreur);
181: }
182:
183: free(executable_candidat);
184:
185: if (alsprintf(&executable_candidat, "%s/bin/rplpp",
186: d_exec_path) < 0)
187: {
188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
189: return(d_erreur);
190: }
191:
192: if (controle(s_etat_processus, executable_candidat, "md5",
193: rplpp_md5) != d_vrai)
194: {
195: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
196: return(d_erreur);
197: }
198:
199: if (controle(s_etat_processus, executable_candidat, "sha1",
200: rplpp_sha1) != d_vrai)
201: {
202: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
203: return(d_erreur);
204: }
205:
206: free(executable_candidat);
207: }
208: else
209: {
210: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
211: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
212: (4 * strlen((*s_etat_processus).rpl_home)) +
213: strlen(nom_fichier_temporaire) + strlen(instructions) - 11)
214: * sizeof(unsigned char))) == NULL)
215: {
216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
217:
218: free(nom_fichier_temporaire);
219: return(d_erreur);
220: }
221:
222: sprintf(commande, instructions,
223: (*s_etat_processus).nom_fichier_source,
224: (*s_etat_processus).rpl_home, ds_preprocesseur,
225: (*s_etat_processus).rpl_home, (*s_etat_processus).rpl_home,
226: (*s_etat_processus).rpl_home,
227: (*s_etat_processus).nom_fichier_source,
228: nom_fichier_temporaire);
229:
230: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
231: (*s_etat_processus).rpl_home) < 0)
232: {
233: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
234: return(d_erreur);
235: }
236:
237: if (controle(s_etat_processus, executable_candidat, "md5",
238: rpliconv_md5) != d_vrai)
239: {
240: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
241: return(d_erreur);
242: }
243:
244: if (controle(s_etat_processus, executable_candidat, "sha1",
245: rpliconv_sha1) != d_vrai)
246: {
247: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
248: return(d_erreur);
249: }
250:
251: free(executable_candidat);
252:
253: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
254: (*s_etat_processus).rpl_home) < 0)
255: {
256: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
257: return(d_erreur);
258: }
259:
260: if (controle(s_etat_processus, executable_candidat, "md5",
261: rplfile_md5) != d_vrai)
262: {
263: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
264: return(d_erreur);
265: }
266:
267: if (controle(s_etat_processus, executable_candidat, "sha1",
268: rplfile_sha1) != d_vrai)
269: {
270: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
271: return(d_erreur);
272: }
273:
274: free(executable_candidat);
275:
276: if (alsprintf(&executable_candidat, "%s/bin/rplpp",
277: (*s_etat_processus).rpl_home) < 0)
278: {
279: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
280: return(d_erreur);
281: }
282:
283: if (controle(s_etat_processus, executable_candidat, "md5",
284: rplpp_md5) != d_vrai)
285: {
286: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
287: return(d_erreur);
288: }
289:
290: if (controle(s_etat_processus, executable_candidat, "sha1",
291: rplpp_sha1) != d_vrai)
292: {
293: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
294: return(d_erreur);
295: }
296:
297: free(executable_candidat);
298: }
299:
300: if ((f_source = popen(commande, "r")) == NULL)
301: {
302: (*s_etat_processus).erreur_systeme = d_es_processus;
303:
304: free(nom_fichier_temporaire);
305: return(d_erreur);
306: }
307:
308: if (pclose(f_source) != EXIT_SUCCESS)
309: {
310: (*s_etat_processus).erreur_systeme = d_es_processus;
311:
312: free(nom_fichier_temporaire);
313: return(d_erreur);
314: }
315:
316: free(commande);
317:
318: if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL)
319: {
320: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
321:
322: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
323: {
324: free(nom_fichier_temporaire);
325: return(d_erreur);
326: }
327:
328: free(nom_fichier_temporaire);
329: return(d_erreur);
330: }
331:
332: nombre_caracteres_source = 0;
333:
334: while(getc(f_source) != EOF)
335: {
336: nombre_caracteres_source++;
337: }
338:
339: (*s_etat_processus).definitions_chainees = (unsigned char *)
340: malloc((nombre_caracteres_source + 1) * sizeof(unsigned char));
341:
342: if ((*s_etat_processus).definitions_chainees == NULL)
343: {
344: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
345:
346: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
347: {
348: free(nom_fichier_temporaire);
349: return(d_erreur);
350: }
351:
352: return(d_erreur);
353: }
354: else
355: {
356: rewind(f_source);
357: presence_chaine = d_faux;
358:
359: i = 0;
360: drapeau_fin = d_faux;
361: initialisation = d_vrai;
362:
363: /*
364: * Élimination du sharp-bang si nécessaire et des caractères
365: * inutiles. Conversion de caractères.
366: */
367:
368: while(drapeau_fin == d_faux)
369: {
370: if ((caractere = getc(f_source)) != EOF)
371: {
372: if (initialisation == d_vrai)
373: {
374: if (caractere == '#')
375: {
376: if ((caractere = getc(f_source)) != EOF)
377: {
378: if (caractere == '!')
379: {
380: do
381: {
382: caractere = getc(f_source);
383: } while((caractere != EOF) &&
384: (caractere !=
385: d_code_retour_chariot));
386: }
387: else
388: {
389: rewind(f_source);
390: caractere = getc(f_source);
391: }
392: }
393: }
394:
395: initialisation = d_faux;
396: }
397:
398: if ((caractere == d_code_retour_chariot) ||
399: (caractere == d_code_tabulation) ||
400: ((caractere == d_code_espace) &&
401: (presence_chaine == d_faux)))
402: {
403: do
404: {
405: caractere = getc(f_source);
406: } while(((caractere == d_code_retour_chariot) ||
407: (caractere == d_code_tabulation) ||
408: ((caractere == d_code_espace) &&
409: (presence_chaine == d_faux))) &&
410: (caractere != EOF));
411:
412: if (caractere != EOF)
413: {
414: ((*s_etat_processus).definitions_chainees)[i++] =
415: d_code_espace;
416: }
417: else
418: {
419: drapeau_fin = d_vrai;
420: }
421: }
422:
423: if ((((*s_etat_processus).definitions_chainees)[i] =
424: caractere) == '\"')
425: {
426: if (i > 0)
427: {
428: if (((*s_etat_processus).definitions_chainees)
429: [i - 1] != '\\')
430: {
431: presence_chaine = (presence_chaine == d_faux)
432: ? d_vrai : d_faux;
433: }
434: }
435:
436: i++;
437: }
438: else
439: {
440: i++;
441: }
442: }
443: else
444: {
445: drapeau_fin = d_vrai;
446: }
447: }
448:
449: if ((caractere == EOF) && (i > 0))
450: {
451: i--;
452: }
453:
454: ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
455:
456: erreur_os = d_absence_erreur;
457: }
458:
459: (*s_etat_processus).longueur_definitions_chainees =
460: strlen((*s_etat_processus).definitions_chainees);
461:
462: if (fclose(f_source) != 0)
463: {
464: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
465:
466: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
467: {
468: free(nom_fichier_temporaire);
469: return(d_erreur);
470: }
471:
472: free(nom_fichier_temporaire);
473: return(d_erreur);
474: }
475:
476: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
477: {
478: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
479:
480: free(nom_fichier_temporaire);
481: return(d_erreur);
482: }
483:
484: free(nom_fichier_temporaire);
485: }
486: else
487: {
488: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
489: erreur_os = d_erreur;
490: }
491:
492: if (((*s_etat_processus).definitions_chainees =
493: realloc((*s_etat_processus).definitions_chainees,
494: ((*s_etat_processus).longueur_definitions_chainees + 1) *
495: sizeof(unsigned char))) == NULL)
496: {
497: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
498: return(d_erreur);
499: }
500:
501: return(erreur_os);
502: }
503:
504:
505: /*
506: ================================================================================
507: Routine de compactage d'une chaîne de caractères
508: Tous les espaces et les retours à ligne surnuméraires sont enlevés.
509: ================================================================================
510: Entrées: structure processus
511: --------------------------------------------------------------------------------
512: Sortie: drapeau d'erreur
513: --------------------------------------------------------------------------------
514: Effets de bord: néant
515: ================================================================================
516: */
517:
518: unsigned char *
519: compactage(unsigned char *chaine)
520: {
521: logical1 drapeau_fin;
522: logical1 presence_chaine;
523:
524: unsigned char caractere;
525: unsigned char *ptr_ecriture;
526: unsigned char *ptr_lecture;
527:
528: if (chaine == NULL)
529: {
530: return(NULL);
531: }
532:
533: presence_chaine = d_faux;
534:
535: drapeau_fin = d_faux;
536: ptr_lecture = chaine;
537: ptr_ecriture = chaine;
538:
539: while(drapeau_fin == d_faux)
540: {
541: if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
542: {
543: if ((caractere == d_code_retour_chariot) ||
544: (caractere == d_code_tabulation) ||
545: ((caractere == d_code_espace) &&
546: (presence_chaine == d_faux)))
547: {
548: do
549: {
550: caractere = (*ptr_lecture++);
551: } while(((caractere == d_code_retour_chariot) ||
552: (caractere == d_code_tabulation) ||
553: ((caractere == d_code_espace) &&
554: (presence_chaine == d_faux))) &&
555: (caractere != d_code_fin_chaine));
556:
557: if (caractere != d_code_fin_chaine)
558: {
559: (*ptr_ecriture++) = d_code_espace;
560: }
561: else
562: {
563: drapeau_fin = d_vrai;
564: }
565: }
566:
567: if (((*ptr_ecriture++) = caractere) == '\"')
568: {
569: presence_chaine = (presence_chaine == d_faux)
570: ? d_vrai : d_faux;
571: }
572: }
573: else
574: {
575: drapeau_fin = d_vrai;
576: }
577: }
578:
579: (*ptr_ecriture) = d_code_fin_chaine;
580:
581: return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
582: }
583:
584: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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