![[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.14 bertrand 3: RPL/2 (R) version 4.0.18
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.1 bertrand 60: unsigned char *instructions = "sed -e '1,1s/^#!/\\/\\//g' %s | "
61: "%s/bin/%s | "
62: "%s/bin/rpliconv `%s/bin/rplfile "
63: "-m %s/share/rplfiles -i %s | awk "
64: "'{ print $3; }' | awk -F= "
65: "'{ if ($2 != \"\") printf(\"-f %%s\", "
1.10 bertrand 66: "$2); }'` -t %s//IGNORE > %s";
1.1 bertrand 67:
68: unsigned long unite_fichier;
69:
70: if ((*s_etat_processus).debug == d_vrai)
71: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
72: {
73: printf("\n");
74:
75: if ((*s_etat_processus).langue == 'F')
76: {
77: printf("[%d] Appel au préprocesseur\n", (int) getpid());
78: }
79: else
80: {
81: printf("[%d] Preprocessing\n", (int) getpid());
82: }
83:
84: fflush(stdout);
85: }
86:
87: erreur = caracteristiques_fichier(s_etat_processus,
88: (*s_etat_processus).nom_fichier_source, &existence,
89: &ouverture, &unite_fichier);
90:
91: erreur_os = d_absence_erreur;
92:
93: if ((existence == d_vrai) && (erreur == 0))
94: {
95: if ((nom_fichier_temporaire = creation_nom_fichier(
96: s_etat_processus, (*s_etat_processus)
97: .chemin_fichiers_temporaires)) == NULL)
98: {
99: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
100: return(d_erreur);
101: }
102:
1.6 bertrand 103: // Avant d'exécuter la commande, on teste les sommes de hashage
104: // des utilitaires de la famille RPL/2.
105:
1.5 bertrand 106: if ((*s_etat_processus).rpl_home == NULL)
1.1 bertrand 107: {
1.5 bertrand 108: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
109: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
1.10 bertrand 110: (4 * strlen(d_exec_path)) + strlen(d_locale) +
111: strlen(nom_fichier_temporaire) + strlen(instructions) - 13)
1.5 bertrand 112: * sizeof(unsigned char))) == NULL)
113: {
114: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
115:
116: free(nom_fichier_temporaire);
117: return(d_erreur);
118: }
1.1 bertrand 119:
1.5 bertrand 120: sprintf(commande, instructions,
121: (*s_etat_processus).nom_fichier_source,
122: d_exec_path, ds_preprocesseur, d_exec_path, d_exec_path,
123: d_exec_path, (*s_etat_processus).nom_fichier_source,
1.10 bertrand 124: d_locale, nom_fichier_temporaire);
1.6 bertrand 125:
126: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
127: d_exec_path) < 0)
128: {
129: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
130: return(d_erreur);
131: }
132:
133: if (controle(s_etat_processus, executable_candidat, "md5",
134: rpliconv_md5) != d_vrai)
135: {
136: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
137: return(d_erreur);
138: }
139:
140: if (controle(s_etat_processus, executable_candidat, "sha1",
141: rpliconv_sha1) != d_vrai)
142: {
143: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
144: return(d_erreur);
145: }
146:
147: free(executable_candidat);
148:
149: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
150: d_exec_path) < 0)
151: {
152: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
153: return(d_erreur);
154: }
155:
156: if (controle(s_etat_processus, executable_candidat, "md5",
157: rplfile_md5) != d_vrai)
158: {
159: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
160: return(d_erreur);
161: }
162:
163: if (controle(s_etat_processus, executable_candidat, "sha1",
164: rplfile_sha1) != d_vrai)
165: {
166: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
167: return(d_erreur);
168: }
169:
170: free(executable_candidat);
171:
172: if (alsprintf(&executable_candidat, "%s/bin/rplpp",
173: d_exec_path) < 0)
174: {
175: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
176: return(d_erreur);
177: }
178:
179: if (controle(s_etat_processus, executable_candidat, "md5",
180: rplpp_md5) != d_vrai)
181: {
182: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
183: return(d_erreur);
184: }
185:
186: if (controle(s_etat_processus, executable_candidat, "sha1",
187: rplpp_sha1) != d_vrai)
188: {
189: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
190: return(d_erreur);
191: }
192:
193: free(executable_candidat);
1.1 bertrand 194: }
1.5 bertrand 195: else
196: {
197: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
198: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
199: (4 * strlen((*s_etat_processus).rpl_home)) +
200: strlen(nom_fichier_temporaire) + strlen(instructions) - 11)
201: * sizeof(unsigned char))) == NULL)
202: {
203: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
204:
205: free(nom_fichier_temporaire);
206: return(d_erreur);
207: }
1.1 bertrand 208:
1.5 bertrand 209: sprintf(commande, instructions,
210: (*s_etat_processus).nom_fichier_source,
211: (*s_etat_processus).rpl_home, ds_preprocesseur,
212: (*s_etat_processus).rpl_home, (*s_etat_processus).rpl_home,
213: (*s_etat_processus).rpl_home,
214: (*s_etat_processus).nom_fichier_source,
215: nom_fichier_temporaire);
1.6 bertrand 216:
217: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
218: (*s_etat_processus).rpl_home) < 0)
219: {
220: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
221: return(d_erreur);
222: }
223:
224: if (controle(s_etat_processus, executable_candidat, "md5",
225: rpliconv_md5) != d_vrai)
226: {
227: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
228: return(d_erreur);
229: }
230:
231: if (controle(s_etat_processus, executable_candidat, "sha1",
232: rpliconv_sha1) != d_vrai)
233: {
234: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
235: return(d_erreur);
236: }
237:
238: free(executable_candidat);
239:
240: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
241: (*s_etat_processus).rpl_home) < 0)
242: {
243: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
244: return(d_erreur);
245: }
246:
247: if (controle(s_etat_processus, executable_candidat, "md5",
248: rplfile_md5) != d_vrai)
249: {
250: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
251: return(d_erreur);
252: }
253:
254: if (controle(s_etat_processus, executable_candidat, "sha1",
255: rplfile_sha1) != d_vrai)
256: {
257: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
258: return(d_erreur);
259: }
260:
261: free(executable_candidat);
262:
263: if (alsprintf(&executable_candidat, "%s/bin/rplpp",
264: (*s_etat_processus).rpl_home) < 0)
265: {
266: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
267: return(d_erreur);
268: }
269:
270: if (controle(s_etat_processus, executable_candidat, "md5",
271: rplpp_md5) != d_vrai)
272: {
273: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
274: return(d_erreur);
275: }
276:
277: if (controle(s_etat_processus, executable_candidat, "sha1",
278: rplpp_sha1) != d_vrai)
279: {
280: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
281: return(d_erreur);
282: }
283:
284: free(executable_candidat);
1.5 bertrand 285: }
1.1 bertrand 286:
287: if ((f_source = popen(commande, "r")) == NULL)
288: {
289: (*s_etat_processus).erreur_systeme = d_es_processus;
290:
291: free(nom_fichier_temporaire);
292: return(d_erreur);
293: }
294:
295: if (pclose(f_source) != EXIT_SUCCESS)
296: {
297: (*s_etat_processus).erreur_systeme = d_es_processus;
298:
299: free(nom_fichier_temporaire);
300: return(d_erreur);
301: }
302:
303: free(commande);
304:
305: if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL)
306: {
307: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
308:
309: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
310: {
311: free(nom_fichier_temporaire);
312: return(d_erreur);
313: }
314:
315: free(nom_fichier_temporaire);
316: return(d_erreur);
317: }
318:
319: nombre_caracteres_source = 0;
320:
321: while(getc(f_source) != EOF)
322: {
323: nombre_caracteres_source++;
324: }
325:
326: (*s_etat_processus).definitions_chainees = (unsigned char *)
327: malloc((nombre_caracteres_source + 1) * sizeof(unsigned char));
328:
329: if ((*s_etat_processus).definitions_chainees == NULL)
330: {
331: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
332:
333: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
334: {
335: free(nom_fichier_temporaire);
336: return(d_erreur);
337: }
338:
339: return(d_erreur);
340: }
341: else
342: {
343: rewind(f_source);
344: presence_chaine = d_faux;
345:
346: i = 0;
347: drapeau_fin = d_faux;
348:
349: while(drapeau_fin == d_faux)
350: {
351: if ((caractere = getc(f_source)) != EOF)
352: {
353: if ((caractere == d_code_retour_chariot) ||
354: (caractere == d_code_tabulation) ||
355: ((caractere == d_code_espace) &&
356: (presence_chaine == d_faux)))
357: {
358: do
359: {
360: caractere = getc(f_source);
361: } while(((caractere == d_code_retour_chariot) ||
362: (caractere == d_code_tabulation) ||
363: ((caractere == d_code_espace) &&
364: (presence_chaine == d_faux))) &&
365: (caractere != EOF));
366:
367: if (caractere != EOF)
368: {
369: ((*s_etat_processus).definitions_chainees)[i++] =
370: d_code_espace;
371: }
372: else
373: {
374: drapeau_fin = d_vrai;
375: }
376: }
377:
378: if ((((*s_etat_processus).definitions_chainees)[i] =
379: caractere) == '\"')
380: {
381: if (i > 0)
382: {
383: if (((*s_etat_processus).definitions_chainees)
384: [i - 1] != '\\')
385: {
386: presence_chaine = (presence_chaine == d_faux)
387: ? d_vrai : d_faux;
388: }
389: }
390:
391: i++;
392: }
393: else
394: {
395: i++;
396: }
397: }
398: else
399: {
400: drapeau_fin = d_vrai;
401: }
402: }
403:
404: if ((caractere == EOF) && (i > 0))
405: {
406: i--;
407: }
408:
409: ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
410:
411: erreur_os = d_absence_erreur;
412: }
413:
414: (*s_etat_processus).longueur_definitions_chainees =
415: strlen((*s_etat_processus).definitions_chainees);
416:
417: if (fclose(f_source) != 0)
418: {
419: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
420:
421: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
422: {
423: free(nom_fichier_temporaire);
424: return(d_erreur);
425: }
426:
427: free(nom_fichier_temporaire);
428: return(d_erreur);
429: }
430:
431: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
432: {
433: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
434:
435: free(nom_fichier_temporaire);
436: return(d_erreur);
437: }
438:
439: free(nom_fichier_temporaire);
440: }
441: else
442: {
443: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
444: erreur_os = d_erreur;
445: }
446:
447: if (((*s_etat_processus).definitions_chainees =
448: realloc((*s_etat_processus).definitions_chainees,
449: ((*s_etat_processus).longueur_definitions_chainees + 1) *
450: sizeof(unsigned char))) == NULL)
451: {
452: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
453: return(d_erreur);
454: }
455:
456: return(erreur_os);
457: }
458:
459:
460: /*
461: ================================================================================
462: Routine de compactage d'une chaîne de caractères
463: Tous les espaces et les retours à ligne surnuméraires sont enlevés.
464: ================================================================================
465: Entrées: structure processus
466: --------------------------------------------------------------------------------
467: Sortie: drapeau d'erreur
468: --------------------------------------------------------------------------------
469: Effets de bord: néant
470: ================================================================================
471: */
472:
473: unsigned char *
474: compactage(unsigned char *chaine)
475: {
476: logical1 drapeau_fin;
477: logical1 presence_chaine;
478:
479: unsigned char caractere;
480: unsigned char *ptr_ecriture;
481: unsigned char *ptr_lecture;
482:
483: if (chaine == NULL)
484: {
485: return(NULL);
486: }
487:
488: presence_chaine = d_faux;
489:
490: drapeau_fin = d_faux;
491: ptr_lecture = chaine;
492: ptr_ecriture = chaine;
493:
494: while(drapeau_fin == d_faux)
495: {
496: if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
497: {
498: if ((caractere == d_code_retour_chariot) ||
499: (caractere == d_code_tabulation) ||
500: ((caractere == d_code_espace) &&
501: (presence_chaine == d_faux)))
502: {
503: do
504: {
505: caractere = (*ptr_lecture++);
506: } while(((caractere == d_code_retour_chariot) ||
507: (caractere == d_code_tabulation) ||
508: ((caractere == d_code_espace) &&
509: (presence_chaine == d_faux))) &&
510: (caractere != d_code_fin_chaine));
511:
512: if (caractere != d_code_fin_chaine)
513: {
514: (*ptr_ecriture++) = d_code_espace;
515: }
516: else
517: {
518: drapeau_fin = d_vrai;
519: }
520: }
521:
522: if (((*ptr_ecriture++) = caractere) == '\"')
523: {
524: presence_chaine = (presence_chaine == d_faux)
525: ? d_vrai : d_faux;
526: }
527: }
528: else
529: {
530: drapeau_fin = d_vrai;
531: }
532: }
533:
534: (*ptr_ecriture) = d_code_fin_chaine;
535:
536: return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
537: }
538:
539: // vim: ts=4