![[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.18 ! bertrand 3: RPL/2 (R) version 4.0.19
1.1 bertrand 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:
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;
52: logical1 ouverture;
53: logical1 presence_chaine;
54:
55: long i;
56: long nombre_caracteres_source;
57:
58: unsigned char *commande;
1.6 bertrand 59: unsigned char *executable_candidat;
1.17 bertrand 60:
61: # ifndef OS2
1.1 bertrand 62: unsigned char *instructions = "sed -e '1,1s/^#!/\\/\\//g' %s | "
63: "%s/bin/%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\", "
1.10 bertrand 68: "$2); }'` -t %s//IGNORE > %s";
1.17 bertrand 69: # else
70: unsigned char *instructions = "sh -c \""
71: "sed -e '1,1s/^#!/\\/\\//g' %s | "
72: "%s/bin/%s | "
73: "%s/bin/rpliconv `%s/bin/rplfile "
74: "-m %s/share/rplfiles -i %s | awk "
75: "'{ print $3; }' | awk -F= "
76: "'{ if ($2 != \\\"\\\") "
77: "printf(\\\"-f %%s\\\", "
78: "$2); }'` -t %s//IGNORE\" > %s";
79: # endif
1.1 bertrand 80:
81: unsigned long unite_fichier;
82:
83: if ((*s_etat_processus).debug == d_vrai)
84: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
85: {
86: printf("\n");
87:
88: if ((*s_etat_processus).langue == 'F')
89: {
90: printf("[%d] Appel au préprocesseur\n", (int) getpid());
91: }
92: else
93: {
94: printf("[%d] Preprocessing\n", (int) getpid());
95: }
96:
97: fflush(stdout);
98: }
99:
100: erreur = caracteristiques_fichier(s_etat_processus,
101: (*s_etat_processus).nom_fichier_source, &existence,
102: &ouverture, &unite_fichier);
103:
104: erreur_os = d_absence_erreur;
105:
106: if ((existence == d_vrai) && (erreur == 0))
107: {
108: if ((nom_fichier_temporaire = creation_nom_fichier(
109: s_etat_processus, (*s_etat_processus)
110: .chemin_fichiers_temporaires)) == NULL)
111: {
112: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
113: return(d_erreur);
114: }
115:
1.6 bertrand 116: // Avant d'exécuter la commande, on teste les sommes de hashage
117: // des utilitaires de la famille RPL/2.
118:
1.5 bertrand 119: if ((*s_etat_processus).rpl_home == NULL)
1.1 bertrand 120: {
1.5 bertrand 121: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
122: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
1.10 bertrand 123: (4 * strlen(d_exec_path)) + strlen(d_locale) +
124: strlen(nom_fichier_temporaire) + strlen(instructions) - 13)
1.5 bertrand 125: * sizeof(unsigned char))) == NULL)
126: {
127: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
128:
129: free(nom_fichier_temporaire);
130: return(d_erreur);
131: }
1.1 bertrand 132:
1.5 bertrand 133: sprintf(commande, instructions,
134: (*s_etat_processus).nom_fichier_source,
135: d_exec_path, ds_preprocesseur, d_exec_path, d_exec_path,
136: d_exec_path, (*s_etat_processus).nom_fichier_source,
1.10 bertrand 137: d_locale, nom_fichier_temporaire);
1.6 bertrand 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);
1.1 bertrand 207: }
1.5 bertrand 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: }
1.1 bertrand 221:
1.5 bertrand 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);
1.6 bertrand 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);
1.5 bertrand 298: }
1.1 bertrand 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:
362: while(drapeau_fin == d_faux)
363: {
364: if ((caractere = getc(f_source)) != EOF)
365: {
366: if ((caractere == d_code_retour_chariot) ||
367: (caractere == d_code_tabulation) ||
368: ((caractere == d_code_espace) &&
369: (presence_chaine == d_faux)))
370: {
371: do
372: {
373: caractere = getc(f_source);
374: } while(((caractere == d_code_retour_chariot) ||
375: (caractere == d_code_tabulation) ||
376: ((caractere == d_code_espace) &&
377: (presence_chaine == d_faux))) &&
378: (caractere != EOF));
379:
380: if (caractere != EOF)
381: {
382: ((*s_etat_processus).definitions_chainees)[i++] =
383: d_code_espace;
384: }
385: else
386: {
387: drapeau_fin = d_vrai;
388: }
389: }
390:
391: if ((((*s_etat_processus).definitions_chainees)[i] =
392: caractere) == '\"')
393: {
394: if (i > 0)
395: {
396: if (((*s_etat_processus).definitions_chainees)
397: [i - 1] != '\\')
398: {
399: presence_chaine = (presence_chaine == d_faux)
400: ? d_vrai : d_faux;
401: }
402: }
403:
404: i++;
405: }
406: else
407: {
408: i++;
409: }
410: }
411: else
412: {
413: drapeau_fin = d_vrai;
414: }
415: }
416:
417: if ((caractere == EOF) && (i > 0))
418: {
419: i--;
420: }
421:
422: ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
423:
424: erreur_os = d_absence_erreur;
425: }
426:
427: (*s_etat_processus).longueur_definitions_chainees =
428: strlen((*s_etat_processus).definitions_chainees);
429:
430: if (fclose(f_source) != 0)
431: {
432: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
433:
434: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
435: {
436: free(nom_fichier_temporaire);
437: return(d_erreur);
438: }
439:
440: free(nom_fichier_temporaire);
441: return(d_erreur);
442: }
443:
444: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
445: {
446: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
447:
448: free(nom_fichier_temporaire);
449: return(d_erreur);
450: }
451:
452: free(nom_fichier_temporaire);
453: }
454: else
455: {
456: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
457: erreur_os = d_erreur;
458: }
459:
460: if (((*s_etat_processus).definitions_chainees =
461: realloc((*s_etat_processus).definitions_chainees,
462: ((*s_etat_processus).longueur_definitions_chainees + 1) *
463: sizeof(unsigned char))) == NULL)
464: {
465: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
466: return(d_erreur);
467: }
468:
469: return(erreur_os);
470: }
471:
472:
473: /*
474: ================================================================================
475: Routine de compactage d'une chaîne de caractères
476: Tous les espaces et les retours à ligne surnuméraires sont enlevés.
477: ================================================================================
478: Entrées: structure processus
479: --------------------------------------------------------------------------------
480: Sortie: drapeau d'erreur
481: --------------------------------------------------------------------------------
482: Effets de bord: néant
483: ================================================================================
484: */
485:
486: unsigned char *
487: compactage(unsigned char *chaine)
488: {
489: logical1 drapeau_fin;
490: logical1 presence_chaine;
491:
492: unsigned char caractere;
493: unsigned char *ptr_ecriture;
494: unsigned char *ptr_lecture;
495:
496: if (chaine == NULL)
497: {
498: return(NULL);
499: }
500:
501: presence_chaine = d_faux;
502:
503: drapeau_fin = d_faux;
504: ptr_lecture = chaine;
505: ptr_ecriture = chaine;
506:
507: while(drapeau_fin == d_faux)
508: {
509: if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
510: {
511: if ((caractere == d_code_retour_chariot) ||
512: (caractere == d_code_tabulation) ||
513: ((caractere == d_code_espace) &&
514: (presence_chaine == d_faux)))
515: {
516: do
517: {
518: caractere = (*ptr_lecture++);
519: } while(((caractere == d_code_retour_chariot) ||
520: (caractere == d_code_tabulation) ||
521: ((caractere == d_code_espace) &&
522: (presence_chaine == d_faux))) &&
523: (caractere != d_code_fin_chaine));
524:
525: if (caractere != d_code_fin_chaine)
526: {
527: (*ptr_ecriture++) = d_code_espace;
528: }
529: else
530: {
531: drapeau_fin = d_vrai;
532: }
533: }
534:
535: if (((*ptr_ecriture++) = caractere) == '\"')
536: {
537: presence_chaine = (presence_chaine == d_faux)
538: ? d_vrai : d_faux;
539: }
540: }
541: else
542: {
543: drapeau_fin = d_vrai;
544: }
545: }
546:
547: (*ptr_ecriture) = d_code_fin_chaine;
548:
549: return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
550: }
551:
552: // vim: ts=4