![[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.38 bertrand 3: RPL/2 (R) version 4.1.5
1.40 ! bertrand 4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
1.1 bertrand 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;
1.19 bertrand 52: logical1 initialisation;
1.1 bertrand 53: logical1 ouverture;
54: logical1 presence_chaine;
55:
56: long i;
57: long nombre_caracteres_source;
58:
59: unsigned char *commande;
1.6 bertrand 60: unsigned char *executable_candidat;
1.17 bertrand 61:
62: # ifndef OS2
1.19 bertrand 63: unsigned char *instructions = "%s/bin/%s %s | "
1.1 bertrand 64: "%s/bin/rpliconv `%s/bin/rplfile "
1.20 bertrand 65: "-m %s/share/rplfiles -i %s | "
66: "%s/bin/rplawk "
67: "'{ print $3; }' | %s/bin/rplawk -F= "
1.1 bertrand 68: "'{ if ($2 != \"\") printf(\"-f %%s\", "
1.10 bertrand 69: "$2); }'` -t %s//IGNORE > %s";
1.17 bertrand 70: # else
1.21 bertrand 71: unsigned char *instructions = BOURNE_SHELL " -c \""
1.19 bertrand 72: "%s/bin/%s %s | "
1.17 bertrand 73: "%s/bin/rpliconv `%s/bin/rplfile "
1.22 bertrand 74: "-m %s/share/rplfiles -i %s | "
75: "%s/bin/rplawk "
1.20 bertrand 76: "'{ print $3; }' | %s/bin/rplawk -F= "
1.17 bertrand 77: "'{ if ($2 != \\\"\\\") "
78: "printf(\\\"-f %%s\\\", "
1.22 bertrand 79: "$2); }'` -t %s//IGNORE > %s\"";
1.17 bertrand 80: # endif
1.1 bertrand 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:
1.6 bertrand 117: // Avant d'exécuter la commande, on teste les sommes de hashage
118: // des utilitaires de la famille RPL/2.
119:
1.5 bertrand 120: if ((*s_etat_processus).rpl_home == NULL)
1.1 bertrand 121: {
1.5 bertrand 122: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
123: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
1.20 bertrand 124: (6 * strlen(d_exec_path)) + strlen(d_locale) +
125: strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
1.5 bertrand 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: }
1.1 bertrand 133:
1.5 bertrand 134: sprintf(commande, instructions,
1.19 bertrand 135: d_exec_path, ds_preprocesseur,
1.5 bertrand 136: (*s_etat_processus).nom_fichier_source,
1.19 bertrand 137: d_exec_path, d_exec_path,
1.5 bertrand 138: d_exec_path, (*s_etat_processus).nom_fichier_source,
1.20 bertrand 139: d_exec_path, d_exec_path, d_locale, nom_fichier_temporaire);
1.6 bertrand 140:
141: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
142: d_exec_path) < 0)
143: {
144: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
145: return(d_erreur);
146: }
147:
1.39 bertrand 148: if (controle_integrite(s_etat_processus, executable_candidat,
149: "rpliconv") != d_vrai)
1.6 bertrand 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(&executable_candidat, "%s/bin/rplfile",
158: d_exec_path) < 0)
159: {
160: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
161: return(d_erreur);
162: }
163:
1.39 bertrand 164: if (controle_integrite(s_etat_processus, executable_candidat,
165: "rplfile") != d_vrai)
1.6 bertrand 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(&executable_candidat, "%s/bin/rplpp",
174: d_exec_path) < 0)
175: {
176: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
177: return(d_erreur);
178: }
179:
1.39 bertrand 180: if (controle_integrite(s_etat_processus, executable_candidat,
181: "rplpp") != d_vrai)
1.6 bertrand 182: {
183: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
184: return(d_erreur);
185: }
186:
187: free(executable_candidat);
1.20 bertrand 188:
189: if (alsprintf(&executable_candidat, "%s/bin/rplawk",
190: d_exec_path) < 0)
191: {
192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
193: return(d_erreur);
194: }
195:
1.39 bertrand 196: if (controle_integrite(s_etat_processus, executable_candidat,
197: "rplawk") != d_vrai)
1.20 bertrand 198: {
199: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
200: return(d_erreur);
201: }
202:
203: free(executable_candidat);
1.1 bertrand 204: }
1.5 bertrand 205: else
206: {
207: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
208: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
1.20 bertrand 209: (6 * strlen((*s_etat_processus).rpl_home)) +
210: strlen(d_locale) +
211: strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
1.5 bertrand 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: }
1.1 bertrand 219:
1.5 bertrand 220: sprintf(commande, instructions,
1.20 bertrand 221: (*s_etat_processus).rpl_home, ds_preprocesseur,
1.5 bertrand 222: (*s_etat_processus).nom_fichier_source,
1.20 bertrand 223: (*s_etat_processus).rpl_home,
224: (*s_etat_processus).rpl_home,
1.5 bertrand 225: (*s_etat_processus).rpl_home,
226: (*s_etat_processus).nom_fichier_source,
1.20 bertrand 227: (*s_etat_processus).rpl_home,
228: (*s_etat_processus).rpl_home,
229: d_locale, nom_fichier_temporaire);
1.6 bertrand 230:
231: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
232: (*s_etat_processus).rpl_home) < 0)
233: {
234: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
235: return(d_erreur);
236: }
237:
1.39 bertrand 238: if (controle_integrite(s_etat_processus, executable_candidat,
239: "rpliconv") != d_vrai)
1.6 bertrand 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(&executable_candidat, "%s/bin/rplfile",
248: (*s_etat_processus).rpl_home) < 0)
249: {
250: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
251: return(d_erreur);
252: }
253:
1.39 bertrand 254: if (controle_integrite(s_etat_processus, executable_candidat,
255: "rplfile") != d_vrai)
1.6 bertrand 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:
1.39 bertrand 270: if (controle_integrite(s_etat_processus, executable_candidat,
271: "rplpp") != d_vrai)
1.6 bertrand 272: {
273: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
274: return(d_erreur);
275: }
276:
277: free(executable_candidat);
1.20 bertrand 278:
279: if (alsprintf(&executable_candidat, "%s/bin/rplawk",
280: (*s_etat_processus).rpl_home) < 0)
281: {
282: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
283: return(d_erreur);
284: }
285:
1.39 bertrand 286: if (controle_integrite(s_etat_processus, executable_candidat,
287: "rplawk") != d_vrai)
1.20 bertrand 288: {
289: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
290: return(d_erreur);
291: }
292:
293: free(executable_candidat);
1.5 bertrand 294: }
1.1 bertrand 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((nombre_caracteres_source + 1) * sizeof(unsigned char));
337:
338: if ((*s_etat_processus).definitions_chainees == NULL)
339: {
340: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
341:
342: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
343: {
344: free(nom_fichier_temporaire);
345: return(d_erreur);
346: }
347:
348: return(d_erreur);
349: }
350: else
351: {
352: rewind(f_source);
353: presence_chaine = d_faux;
354:
355: i = 0;
356: drapeau_fin = d_faux;
1.19 bertrand 357: initialisation = d_vrai;
358:
359: /*
360: * Élimination du sharp-bang si nécessaire et des caractères
361: * inutiles. Conversion de caractères.
362: */
1.1 bertrand 363:
364: while(drapeau_fin == d_faux)
365: {
366: if ((caractere = getc(f_source)) != EOF)
367: {
1.19 bertrand 368: if (initialisation == d_vrai)
369: {
370: if (caractere == '#')
371: {
372: if ((caractere = getc(f_source)) != EOF)
373: {
374: if (caractere == '!')
375: {
376: do
377: {
378: caractere = getc(f_source);
379: } while((caractere != EOF) &&
380: (caractere !=
381: d_code_retour_chariot));
382: }
383: else
384: {
385: rewind(f_source);
386: caractere = getc(f_source);
387: }
388: }
389: }
390:
391: initialisation = d_faux;
392: }
393:
1.1 bertrand 394: if ((caractere == d_code_retour_chariot) ||
395: (caractere == d_code_tabulation) ||
396: ((caractere == d_code_espace) &&
397: (presence_chaine == d_faux)))
398: {
399: do
400: {
401: caractere = getc(f_source);
402: } while(((caractere == d_code_retour_chariot) ||
403: (caractere == d_code_tabulation) ||
404: ((caractere == d_code_espace) &&
405: (presence_chaine == d_faux))) &&
406: (caractere != EOF));
407:
408: if (caractere != EOF)
409: {
410: ((*s_etat_processus).definitions_chainees)[i++] =
411: d_code_espace;
412: }
413: else
414: {
415: drapeau_fin = d_vrai;
416: }
417: }
418:
419: if ((((*s_etat_processus).definitions_chainees)[i] =
420: caractere) == '\"')
421: {
422: if (i > 0)
423: {
424: if (((*s_etat_processus).definitions_chainees)
425: [i - 1] != '\\')
426: {
427: presence_chaine = (presence_chaine == d_faux)
428: ? d_vrai : d_faux;
429: }
430: }
431:
432: i++;
433: }
434: else
435: {
436: i++;
437: }
438: }
439: else
440: {
441: drapeau_fin = d_vrai;
442: }
443: }
444:
445: if ((caractere == EOF) && (i > 0))
446: {
447: i--;
448: }
449:
450: ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
451:
452: erreur_os = d_absence_erreur;
453: }
454:
455: (*s_etat_processus).longueur_definitions_chainees =
456: strlen((*s_etat_processus).definitions_chainees);
457:
458: if (fclose(f_source) != 0)
459: {
460: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
461:
462: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
463: {
464: free(nom_fichier_temporaire);
465: return(d_erreur);
466: }
467:
468: free(nom_fichier_temporaire);
469: return(d_erreur);
470: }
471:
472: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
473: {
474: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
475:
476: free(nom_fichier_temporaire);
477: return(d_erreur);
478: }
479:
480: free(nom_fichier_temporaire);
481: }
482: else
483: {
484: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
485: erreur_os = d_erreur;
486: }
487:
488: if (((*s_etat_processus).definitions_chainees =
489: realloc((*s_etat_processus).definitions_chainees,
490: ((*s_etat_processus).longueur_definitions_chainees + 1) *
491: sizeof(unsigned char))) == NULL)
492: {
493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
494: return(d_erreur);
495: }
496:
497: return(erreur_os);
498: }
499:
500:
501: /*
502: ================================================================================
503: Routine de compactage d'une chaîne de caractères
504: Tous les espaces et les retours à ligne surnuméraires sont enlevés.
505: ================================================================================
506: Entrées: structure processus
507: --------------------------------------------------------------------------------
508: Sortie: drapeau d'erreur
509: --------------------------------------------------------------------------------
510: Effets de bord: néant
511: ================================================================================
512: */
513:
514: unsigned char *
515: compactage(unsigned char *chaine)
516: {
517: logical1 drapeau_fin;
518: logical1 presence_chaine;
519:
520: unsigned char caractere;
521: unsigned char *ptr_ecriture;
522: unsigned char *ptr_lecture;
523:
524: if (chaine == NULL)
525: {
526: return(NULL);
527: }
528:
529: presence_chaine = d_faux;
530:
531: drapeau_fin = d_faux;
532: ptr_lecture = chaine;
533: ptr_ecriture = chaine;
534:
535: while(drapeau_fin == d_faux)
536: {
537: if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
538: {
539: if ((caractere == d_code_retour_chariot) ||
540: (caractere == d_code_tabulation) ||
541: ((caractere == d_code_espace) &&
542: (presence_chaine == d_faux)))
543: {
544: do
545: {
546: caractere = (*ptr_lecture++);
547: } while(((caractere == d_code_retour_chariot) ||
548: (caractere == d_code_tabulation) ||
549: ((caractere == d_code_espace) &&
550: (presence_chaine == d_faux))) &&
551: (caractere != d_code_fin_chaine));
552:
553: if (caractere != d_code_fin_chaine)
554: {
555: (*ptr_ecriture++) = d_code_espace;
556: }
557: else
558: {
559: drapeau_fin = d_vrai;
560: }
561: }
562:
563: if (((*ptr_ecriture++) = caractere) == '\"')
564: {
565: presence_chaine = (presence_chaine == d_faux)
566: ? d_vrai : d_faux;
567: }
568: }
569: else
570: {
571: drapeau_fin = d_vrai;
572: }
573: }
574:
575: (*ptr_ecriture) = d_code_fin_chaine;
576:
577: return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
578: }
579:
580: // vim: ts=4