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