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