![[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.3 ! bertrand 3: RPL/2 (R) version 4.0.11
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:
102: if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
103: (2 * strlen((*s_etat_processus).nom_fichier_source)) +
104: (4 * strlen(d_exec_path)) +
105: strlen(nom_fichier_temporaire) + strlen(instructions) - 11) *
106: sizeof(unsigned char))) == NULL)
107: {
108: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
109:
110: free(nom_fichier_temporaire);
111: return(d_erreur);
112: }
113:
114: sprintf(commande, instructions, (*s_etat_processus).nom_fichier_source,
115: d_exec_path, ds_preprocesseur, d_exec_path, d_exec_path,
116: d_exec_path, (*s_etat_processus).nom_fichier_source,
117: nom_fichier_temporaire);
118:
119: if ((f_source = popen(commande, "r")) == NULL)
120: {
121: (*s_etat_processus).erreur_systeme = d_es_processus;
122:
123: free(nom_fichier_temporaire);
124: return(d_erreur);
125: }
126:
127: if (pclose(f_source) != EXIT_SUCCESS)
128: {
129: (*s_etat_processus).erreur_systeme = d_es_processus;
130:
131: free(nom_fichier_temporaire);
132: return(d_erreur);
133: }
134:
135: free(commande);
136:
137: if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL)
138: {
139: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
140:
141: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
142: {
143: free(nom_fichier_temporaire);
144: return(d_erreur);
145: }
146:
147: free(nom_fichier_temporaire);
148: return(d_erreur);
149: }
150:
151: nombre_caracteres_source = 0;
152:
153: while(getc(f_source) != EOF)
154: {
155: nombre_caracteres_source++;
156: }
157:
158: (*s_etat_processus).definitions_chainees = (unsigned char *)
159: malloc((nombre_caracteres_source + 1) * sizeof(unsigned char));
160:
161: if ((*s_etat_processus).definitions_chainees == NULL)
162: {
163: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
164:
165: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
166: {
167: free(nom_fichier_temporaire);
168: return(d_erreur);
169: }
170:
171: return(d_erreur);
172: }
173: else
174: {
175: rewind(f_source);
176: presence_chaine = d_faux;
177:
178: i = 0;
179: drapeau_fin = d_faux;
180:
181: while(drapeau_fin == d_faux)
182: {
183: if ((caractere = getc(f_source)) != EOF)
184: {
185: if ((caractere == d_code_retour_chariot) ||
186: (caractere == d_code_tabulation) ||
187: ((caractere == d_code_espace) &&
188: (presence_chaine == d_faux)))
189: {
190: do
191: {
192: caractere = getc(f_source);
193: } while(((caractere == d_code_retour_chariot) ||
194: (caractere == d_code_tabulation) ||
195: ((caractere == d_code_espace) &&
196: (presence_chaine == d_faux))) &&
197: (caractere != EOF));
198:
199: if (caractere != EOF)
200: {
201: ((*s_etat_processus).definitions_chainees)[i++] =
202: d_code_espace;
203: }
204: else
205: {
206: drapeau_fin = d_vrai;
207: }
208: }
209:
210: if ((((*s_etat_processus).definitions_chainees)[i] =
211: caractere) == '\"')
212: {
213: if (i > 0)
214: {
215: if (((*s_etat_processus).definitions_chainees)
216: [i - 1] != '\\')
217: {
218: presence_chaine = (presence_chaine == d_faux)
219: ? d_vrai : d_faux;
220: }
221: }
222:
223: i++;
224: }
225: else
226: {
227: i++;
228: }
229: }
230: else
231: {
232: drapeau_fin = d_vrai;
233: }
234: }
235:
236: if ((caractere == EOF) && (i > 0))
237: {
238: i--;
239: }
240:
241: ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
242:
243: erreur_os = d_absence_erreur;
244: }
245:
246: (*s_etat_processus).longueur_definitions_chainees =
247: strlen((*s_etat_processus).definitions_chainees);
248:
249: if (fclose(f_source) != 0)
250: {
251: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
252:
253: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
254: {
255: free(nom_fichier_temporaire);
256: return(d_erreur);
257: }
258:
259: free(nom_fichier_temporaire);
260: return(d_erreur);
261: }
262:
263: if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
264: {
265: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
266:
267: free(nom_fichier_temporaire);
268: return(d_erreur);
269: }
270:
271: free(nom_fichier_temporaire);
272: }
273: else
274: {
275: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
276: erreur_os = d_erreur;
277: }
278:
279: if (((*s_etat_processus).definitions_chainees =
280: realloc((*s_etat_processus).definitions_chainees,
281: ((*s_etat_processus).longueur_definitions_chainees + 1) *
282: sizeof(unsigned char))) == NULL)
283: {
284: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
285: return(d_erreur);
286: }
287:
288: return(erreur_os);
289: }
290:
291:
292: /*
293: ================================================================================
294: Routine de compactage d'une chaîne de caractères
295: Tous les espaces et les retours à ligne surnuméraires sont enlevés.
296: ================================================================================
297: Entrées: structure processus
298: --------------------------------------------------------------------------------
299: Sortie: drapeau d'erreur
300: --------------------------------------------------------------------------------
301: Effets de bord: néant
302: ================================================================================
303: */
304:
305: unsigned char *
306: compactage(unsigned char *chaine)
307: {
308: logical1 drapeau_fin;
309: logical1 presence_chaine;
310:
311: unsigned char caractere;
312: unsigned char *ptr_ecriture;
313: unsigned char *ptr_lecture;
314:
315: if (chaine == NULL)
316: {
317: return(NULL);
318: }
319:
320: presence_chaine = d_faux;
321:
322: drapeau_fin = d_faux;
323: ptr_lecture = chaine;
324: ptr_ecriture = chaine;
325:
326: while(drapeau_fin == d_faux)
327: {
328: if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
329: {
330: if ((caractere == d_code_retour_chariot) ||
331: (caractere == d_code_tabulation) ||
332: ((caractere == d_code_espace) &&
333: (presence_chaine == d_faux)))
334: {
335: do
336: {
337: caractere = (*ptr_lecture++);
338: } while(((caractere == d_code_retour_chariot) ||
339: (caractere == d_code_tabulation) ||
340: ((caractere == d_code_espace) &&
341: (presence_chaine == d_faux))) &&
342: (caractere != d_code_fin_chaine));
343:
344: if (caractere != d_code_fin_chaine)
345: {
346: (*ptr_ecriture++) = d_code_espace;
347: }
348: else
349: {
350: drapeau_fin = d_vrai;
351: }
352: }
353:
354: if (((*ptr_ecriture++) = caractere) == '\"')
355: {
356: presence_chaine = (presence_chaine == d_faux)
357: ? d_vrai : d_faux;
358: }
359: }
360: else
361: {
362: drapeau_fin = d_vrai;
363: }
364: }
365:
366: (*ptr_ecriture) = d_code_fin_chaine;
367:
368: return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
369: }
370:
371: // vim: ts=4