![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to formateur_flux.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to formateur_flux.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.13 bertrand 3: RPL/2 (R) version 4.1.4
1.1 bertrand 4: Copyright (C) 1989-2011 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 formation des données pour l'envoi de flux binaires
29: ================================================================================
30: Entrées : structure sur l'état du processus et objet à afficher
31: --------------------------------------------------------------------------------
32: Sorties : chaine de caractères
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: unsigned char *
39: formateur_flux(struct_processus *s_etat_processus, unsigned char *donnees,
40: long *longueur)
41: {
42: unsigned char *chaine;
43:
44: unsigned char *ptr_ecriture;
45: unsigned char *ptr_lecture;
46:
47: if ((chaine = malloc((strlen(donnees) + 1) * sizeof(unsigned char)))
48: == NULL)
49: {
50: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
51: return(NULL);
52: }
53:
54: ptr_lecture = donnees;
55: ptr_ecriture = chaine;
56:
57: while((*ptr_lecture) != d_code_fin_chaine)
58: {
59: (*ptr_ecriture) = (*ptr_lecture);
60:
61: // Début de la séquence d'échappement
62:
63: if ((*ptr_lecture) == '\\')
64: {
65: if ((*(ptr_lecture + 1)) == '"')
66: {
67: ptr_lecture++;
68: (*ptr_ecriture) = '\"';
69: }
70: else if ((*(ptr_lecture + 1)) == 'b')
71: {
72: ptr_lecture++;
73: (*ptr_ecriture) = '\b';
74: }
75: else if ((*(ptr_lecture + 1)) == 'n')
76: {
77: ptr_lecture++;
78: (*ptr_ecriture) = '\n';
79: }
80: else if ((*(ptr_lecture + 1)) == 't')
81: {
82: ptr_lecture++;
83: (*ptr_ecriture) = '\t';
84: }
85: else if ((*(ptr_lecture + 1)) == 'x')
86: {
87: ptr_lecture += 2;
88:
89: if ((*ptr_lecture) != d_code_fin_chaine)
90: {
91: if ((*(ptr_lecture + 1)) != d_code_fin_chaine)
92: {
93: logical1 erreur;
94: unsigned char ec;
95:
96: erreur = d_faux;
97:
98: switch(*ptr_lecture)
99: {
100: case '0':
101: case '1':
102: case '2':
103: case '3':
104: case '4':
105: case '5':
106: case '6':
107: case '7':
108: case '8':
109: case '9':
110: ec = (*ptr_lecture) - '0';
111: break;
112:
113: case 'A':
114: case 'B':
115: case 'C':
116: case 'D':
117: case 'E':
118: case 'F':
119: ec = ((*ptr_lecture) - 'A') + 10;
120: break;
121:
122: default:
123: ec = 0;
124: erreur = d_vrai;
125: break;
126: }
127:
128: ec *= 0x10;
129: ptr_lecture++;
130:
131: switch(*ptr_lecture)
132: {
133: case '0':
134: case '1':
135: case '2':
136: case '3':
137: case '4':
138: case '5':
139: case '6':
140: case '7':
141: case '8':
142: case '9':
143: ec += (*ptr_lecture) - '0';
144: break;
145:
146: case 'A':
147: case 'B':
148: case 'C':
149: case 'D':
150: case 'E':
151: case 'F':
152: ec += ((*ptr_lecture) - 'A') + 10;
153: break;
154:
155: default:
156: erreur = d_vrai;
157: break;
158: }
159:
160: (*ptr_ecriture) = ec;
161:
162: if (erreur == d_vrai)
163: {
164: if ((*s_etat_processus).langue == 'F')
165: {
166: printf("+++Information : "
167: "Séquence d'échappement "
168: "inconnue [%d]\n",
169: (int) getpid());
170: }
171: else
172: {
173: printf("+++Warning : Unknown "
174: "escape code "
175: "[%d]\n", (int) getpid());
176: }
177: }
178: }
179: else
180: {
181: if ((*s_etat_processus).langue == 'F')
182: {
183: printf("+++Information : "
184: "Séquence d'échappement "
185: "inconnue [%d]\n", (int) getpid());
186: }
187: else
188: {
189: printf("+++Warning : Unknown escape code "
190: "[%d]\n", (int) getpid());
191: }
192: }
193: }
194: else
195: {
196: if ((*s_etat_processus).langue == 'F')
197: {
198: printf("+++Information : "
199: "Séquence d'échappement "
200: "inconnue [%d]\n", (int) getpid());
201: }
202: else
203: {
204: printf("+++Warning : Unknown escape code "
205: "[%d]\n", (int) getpid());
206: }
207: }
208: }
209: else if ((*(ptr_lecture + 1)) == '\\')
210: {
211: ptr_lecture++;
212: }
213: else
214: {
215: if ((*s_etat_processus).langue == 'F')
216: {
217: printf("+++Information : Séquence d'échappement "
218: "inconnue [%d]\n", (int) getpid());
219: }
220: else
221: {
222: printf("+++Warning : Unknown escape code "
223: "[%d]\n", (int) getpid());
224: }
225: }
226: }
227:
228: ptr_ecriture++;
229: ptr_lecture++;
230: }
231:
232: (*ptr_ecriture) = d_code_fin_chaine;
233:
234: if ((chaine = realloc(chaine, ((((*longueur) = ptr_ecriture - chaine)) + 1)
235: * sizeof(unsigned char))) == NULL)
236: {
237: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
238: return(NULL);
239: }
240:
241: return(chaine);
242: }
243:
1.14 ! bertrand 244:
! 245: /*
! 246: ================================================================================
! 247: Routine permettant de trouver le caractère suivant dans une chaîne
! 248: ================================================================================
! 249: Entrées : structure sur l'état du processus et chaîne courante
! 250: --------------------------------------------------------------------------------
! 251: Sorties : pointeur sur le caractère suivant
! 252: --------------------------------------------------------------------------------
! 253: Effets de bord : néant
! 254: ================================================================================
! 255: */
! 256:
! 257: static inline unsigned char *
! 258: prochain_caractere(struct_processus *s_etat_processus, unsigned char *chaine)
! 259: {
! 260: unsigned char *suivant;
! 261:
! 262: if ((*chaine) == '\\')
! 263: {
! 264: if ((*(chaine + 1)) == '"')
! 265: {
! 266: suivant = chaine + 2;
! 267: }
! 268: else if ((*(chaine + 1)) == 'b')
! 269: {
! 270: suivant = chaine + 2;
! 271: }
! 272: else if ((*(chaine + 1)) == 'n')
! 273: {
! 274: suivant = chaine + 2;
! 275: }
! 276: else if ((*(chaine + 1)) == 't')
! 277: {
! 278: suivant = chaine + 2;
! 279: }
! 280: else if ((*(chaine + 1)) == 'x')
! 281: {
! 282: if ((*(chaine + 2)) != d_code_fin_chaine)
! 283: {
! 284: if ((*(chaine + 3)) != d_code_fin_chaine)
! 285: {
! 286: logical1 erreur;
! 287:
! 288: erreur = d_faux;
! 289:
! 290: switch(*(chaine + 2))
! 291: {
! 292: case '0':
! 293: case '1':
! 294: case '2':
! 295: case '3':
! 296: case '4':
! 297: case '5':
! 298: case '6':
! 299: case '7':
! 300: case '8':
! 301: case '9':
! 302: case 'A':
! 303: case 'B':
! 304: case 'C':
! 305: case 'D':
! 306: case 'E':
! 307: case 'F':
! 308: break;
! 309:
! 310: default:
! 311: erreur = d_vrai;
! 312: break;
! 313: }
! 314:
! 315: switch(*(chaine + 3))
! 316: {
! 317: case '0':
! 318: case '1':
! 319: case '2':
! 320: case '3':
! 321: case '4':
! 322: case '5':
! 323: case '6':
! 324: case '7':
! 325: case '8':
! 326: case '9':
! 327: case 'A':
! 328: case 'B':
! 329: case 'C':
! 330: case 'D':
! 331: case 'E':
! 332: case 'F':
! 333: break;
! 334:
! 335: default:
! 336: erreur = d_vrai;
! 337: break;
! 338: }
! 339:
! 340: if (erreur == d_vrai)
! 341: {
! 342: if ((*s_etat_processus).langue == 'F')
! 343: {
! 344: printf("+++Information : "
! 345: "Séquence d'échappement "
! 346: "inconnue [%d]\n",
! 347: (int) getpid());
! 348: }
! 349: else
! 350: {
! 351: printf("+++Warning : Unknown "
! 352: "escape code "
! 353: "[%d]\n", (int) getpid());
! 354: }
! 355:
! 356: return(NULL);
! 357: }
! 358:
! 359: suivant = chaine + 4;
! 360: }
! 361: else
! 362: {
! 363: if ((*s_etat_processus).langue == 'F')
! 364: {
! 365: printf("+++Information : "
! 366: "Séquence d'échappement "
! 367: "inconnue [%d]\n", (int) getpid());
! 368: }
! 369: else
! 370: {
! 371: printf("+++Warning : Unknown escape code "
! 372: "[%d]\n", (int) getpid());
! 373: }
! 374:
! 375: return(NULL);
! 376: }
! 377: }
! 378: else
! 379: {
! 380: if ((*s_etat_processus).langue == 'F')
! 381: {
! 382: printf("+++Information : "
! 383: "Séquence d'échappement "
! 384: "inconnue [%d]\n", (int) getpid());
! 385: }
! 386: else
! 387: {
! 388: printf("+++Warning : Unknown escape code "
! 389: "[%d]\n", (int) getpid());
! 390: }
! 391:
! 392: return(NULL);
! 393: }
! 394: }
! 395: else if ((*(chaine + 1)) == '\\')
! 396: {
! 397: suivant = chaine + 1;
! 398: }
! 399: else
! 400: {
! 401: if ((*s_etat_processus).langue == 'F')
! 402: {
! 403: printf("+++Information : Séquence d'échappement "
! 404: "inconnue [%d]\n", (int) getpid());
! 405: }
! 406: else
! 407: {
! 408: printf("+++Warning : Unknown escape code "
! 409: "[%d]\n", (int) getpid());
! 410: }
! 411:
! 412: return(NULL);
! 413: }
! 414: }
! 415: else
! 416: {
! 417: suivant = chaine + 1;
! 418: }
! 419:
! 420: return(suivant);
! 421: }
! 422:
! 423:
! 424: /*
! 425: ================================================================================
! 426: Routine donnant la longueur d'une chaîne de caractères
! 427: ================================================================================
! 428: Entrées : structure sur l'état du processus et chaîne
! 429: --------------------------------------------------------------------------------
! 430: Sorties : longueur de la chaîne
! 431: --------------------------------------------------------------------------------
! 432: Effets de bord : néant
! 433: ================================================================================
! 434: */
! 435:
! 436: integer8
! 437: longueur_chaine(struct_processus *s_etat_processus, unsigned char *chaine)
! 438: {
! 439: integer8 nombre_caracteres;
! 440:
! 441: unsigned char *pointeur;
! 442:
! 443: pointeur = chaine;
! 444: nombre_caracteres = 0;
! 445:
! 446: if ((*pointeur) == '\0')
! 447: {
! 448: return(0);
! 449: }
! 450:
! 451: do
! 452: {
! 453: if ((pointeur = prochain_caractere(s_etat_processus, pointeur)) == NULL)
! 454: {
! 455: return(0);
! 456: }
! 457:
! 458: nombre_caracteres++;
! 459: } while((*pointeur) != 0);
! 460:
! 461: return(nombre_caracteres);
! 462: }
! 463:
1.1 bertrand 464: // vim: ts=4