![[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.4 bertrand 3: RPL/2 (R) version 4.0.12
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:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Routine de chainage du programme (lecture du fichier puis constitution
29: de la chaine executable)
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;
59: unsigned char *instructions = "sed -e '1,1s/^#!/\\/\\//g' %s | "
60: "%s/bin/%s | "
61: "%s/bin/rpliconv `%s/bin/rplfile "
62: "-m %s/share/rplfiles -i %s | awk "
63: "'{ print $3; }' | awk -F= "
64: "'{ if ($2 != \"\") printf(\"-f %%s\", "
65: "$2); }'` -t `locale charmap`//IGNORE > %s";
66:
67: unsigned long unite_fichier;
68:
69: if ((*s_etat_processus).debug == d_vrai)
70: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
71: {
72: printf("\n");
73:
74: if ((*s_etat_processus).langue == 'F')
75: {
76: printf("[%d] Appel au préprocesseur\n", (int) getpid());
77: }
78: else
79: {
80: printf("[%d] Preprocessing\n", (int) getpid());
81: }
82:
83: fflush(stdout);
84: }
85:
86: erreur = caracteristiques_fichier(s_etat_processus,
87: (*s_etat_processus).nom_fichier_source, &existence,
88: &ouverture, &unite_fichier);
89:
90: erreur_os = d_absence_erreur;
91:
92: if ((existence == d_vrai) && (erreur == 0))
93: {
94: if ((nom_fichier_temporaire = creation_nom_fichier(
95: s_etat_processus, (*s_etat_processus)
96: .chemin_fichiers_temporaires)) == NULL)
97: {
98: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
99: return(d_erreur);
100: }
101:
1.5 ! bertrand 102: if ((*s_etat_processus).rpl_home == NULL)
1.1 bertrand 103: {
1.5 ! bertrand 104: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
! 105: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
! 106: (4 * strlen(d_exec_path)) +
! 107: strlen(nom_fichier_temporaire) + strlen(instructions) - 11)
! 108: * sizeof(unsigned char))) == NULL)
! 109: {
! 110: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 111:
! 112: free(nom_fichier_temporaire);
! 113: return(d_erreur);
! 114: }
1.1 bertrand 115:
1.5 ! bertrand 116: sprintf(commande, instructions,
! 117: (*s_etat_processus).nom_fichier_source,
! 118: d_exec_path, ds_preprocesseur, d_exec_path, d_exec_path,
! 119: d_exec_path, (*s_etat_processus).nom_fichier_source,
! 120: nom_fichier_temporaire);
1.1 bertrand 121: }
1.5 ! bertrand 122: else
! 123: {
! 124: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
! 125: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
! 126: (4 * strlen((*s_etat_processus).rpl_home)) +
! 127: strlen(nom_fichier_temporaire) + strlen(instructions) - 11)
! 128: * sizeof(unsigned char))) == NULL)
! 129: {
! 130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 131:
! 132: free(nom_fichier_temporaire);
! 133: return(d_erreur);
! 134: }
1.1 bertrand 135:
1.5 ! bertrand 136: sprintf(commande, instructions,
! 137: (*s_etat_processus).nom_fichier_source,
! 138: (*s_etat_processus).rpl_home, ds_preprocesseur,
! 139: (*s_etat_processus).rpl_home, (*s_etat_processus).rpl_home,
! 140: (*s_etat_processus).rpl_home,
! 141: (*s_etat_processus).nom_fichier_source,
! 142: nom_fichier_temporaire);
! 143: }
1.1 bertrand 144:
145: if ((f_source = popen(commande, "r")) == NULL)
146: {
147: (*s_etat_processus).erreur_systeme = d_es_processus;
148:
149: free(nom_fichier_temporaire);
150: return(d_erreur);
151: }
152:
153: if (pclose(f_source) != EXIT_SUCCESS)
154: {
155: (*s_etat_processus).erreur_systeme = d_es_processus;
156:
157: free(nom_fichier_temporaire);
158: return(d_erreur);
159: }
160:
161: free(commande);
162:
163: if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL)
164: {
165: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
166:
167: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
168: {
169: free(nom_fichier_temporaire);
170: return(d_erreur);
171: }
172:
173: free(nom_fichier_temporaire);
174: return(d_erreur);
175: }
176:
177: nombre_caracteres_source = 0;
178:
179: while(getc(f_source) != EOF)
180: {
181: nombre_caracteres_source++;
182: }
183:
184: (*s_etat_processus).definitions_chainees = (unsigned char *)
185: malloc((nombre_caracteres_source + 1) * sizeof(unsigned char));
186:
187: if ((*s_etat_processus).definitions_chainees == NULL)
188: {
189: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
190:
191: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
192: {
193: free(nom_fichier_temporaire);
194: return(d_erreur);
195: }
196:
197: return(d_erreur);
198: }
199: else
200: {
201: rewind(f_source);
202: presence_chaine = d_faux;
203:
204: i = 0;
205: drapeau_fin = d_faux;
206:
207: while(drapeau_fin == d_faux)
208: {
209: if ((caractere = getc(f_source)) != EOF)
210: {
211: if ((caractere == d_code_retour_chariot) ||
212: (caractere == d_code_tabulation) ||
213: ((caractere == d_code_espace) &&
214: (presence_chaine == d_faux)))
215: {
216: do
217: {
218: caractere = getc(f_source);
219: } while(((caractere == d_code_retour_chariot) ||
220: (caractere == d_code_tabulation) ||
221: ((caractere == d_code_espace) &&
222: (presence_chaine == d_faux))) &&
223: (caractere != EOF));
224:
225: if (caractere != EOF)
226: {
227: ((*s_etat_processus).definitions_chainees)[i++] =
228: d_code_espace;
229: }
230: else
231: {
232: drapeau_fin = d_vrai;
233: }
234: }
235:
236: if ((((*s_etat_processus).definitions_chainees)[i] =
237: caractere) == '\"')
238: {
239: if (i > 0)
240: {
241: if (((*s_etat_processus).definitions_chainees)
242: [i - 1] != '\\')
243: {
244: presence_chaine = (presence_chaine == d_faux)
245: ? d_vrai : d_faux;
246: }
247: }
248:
249: i++;
250: }
251: else
252: {
253: i++;
254: }
255: }
256: else
257: {
258: drapeau_fin = d_vrai;
259: }
260: }
261:
262: if ((caractere == EOF) && (i > 0))
263: {
264: i--;
265: }
266:
267: ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
268:
269: erreur_os = d_absence_erreur;
270: }
271:
272: (*s_etat_processus).longueur_definitions_chainees =
273: strlen((*s_etat_processus).definitions_chainees);
274:
275: if (fclose(f_source) != 0)
276: {
277: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
278:
279: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
280: {
281: free(nom_fichier_temporaire);
282: return(d_erreur);
283: }
284:
285: free(nom_fichier_temporaire);
286: return(d_erreur);
287: }
288:
289: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
290: {
291: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
292:
293: free(nom_fichier_temporaire);
294: return(d_erreur);
295: }
296:
297: free(nom_fichier_temporaire);
298: }
299: else
300: {
301: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
302: erreur_os = d_erreur;
303: }
304:
305: if (((*s_etat_processus).definitions_chainees =
306: realloc((*s_etat_processus).definitions_chainees,
307: ((*s_etat_processus).longueur_definitions_chainees + 1) *
308: sizeof(unsigned char))) == NULL)
309: {
310: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
311: return(d_erreur);
312: }
313:
314: return(erreur_os);
315: }
316:
317:
318: /*
319: ================================================================================
320: Routine de compactage d'une chaîne de caractères
321: Tous les espaces et les retours à ligne surnuméraires sont enlevés.
322: ================================================================================
323: Entrées: structure processus
324: --------------------------------------------------------------------------------
325: Sortie: drapeau d'erreur
326: --------------------------------------------------------------------------------
327: Effets de bord: néant
328: ================================================================================
329: */
330:
331: unsigned char *
332: compactage(unsigned char *chaine)
333: {
334: logical1 drapeau_fin;
335: logical1 presence_chaine;
336:
337: unsigned char caractere;
338: unsigned char *ptr_ecriture;
339: unsigned char *ptr_lecture;
340:
341: if (chaine == NULL)
342: {
343: return(NULL);
344: }
345:
346: presence_chaine = d_faux;
347:
348: drapeau_fin = d_faux;
349: ptr_lecture = chaine;
350: ptr_ecriture = chaine;
351:
352: while(drapeau_fin == d_faux)
353: {
354: if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
355: {
356: if ((caractere == d_code_retour_chariot) ||
357: (caractere == d_code_tabulation) ||
358: ((caractere == d_code_espace) &&
359: (presence_chaine == d_faux)))
360: {
361: do
362: {
363: caractere = (*ptr_lecture++);
364: } while(((caractere == d_code_retour_chariot) ||
365: (caractere == d_code_tabulation) ||
366: ((caractere == d_code_espace) &&
367: (presence_chaine == d_faux))) &&
368: (caractere != d_code_fin_chaine));
369:
370: if (caractere != d_code_fin_chaine)
371: {
372: (*ptr_ecriture++) = d_code_espace;
373: }
374: else
375: {
376: drapeau_fin = d_vrai;
377: }
378: }
379:
380: if (((*ptr_ecriture++) = caractere) == '\"')
381: {
382: presence_chaine = (presence_chaine == d_faux)
383: ? d_vrai : d_faux;
384: }
385: }
386: else
387: {
388: drapeau_fin = d_vrai;
389: }
390: }
391:
392: (*ptr_ecriture) = d_code_fin_chaine;
393:
394: return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
395: }
396:
397: // vim: ts=4