![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_r4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_r4.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.18 bertrand 3: RPL/2 (R) version 4.0.18
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:
1.19 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'r->b'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_r_vers_b(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_argument;
42: struct_objet *s_objet_resultat;
43:
44: (*s_etat_processus).erreur_execution = d_ex;
45:
46: if ((*s_etat_processus).affichage_arguments == 'Y')
47: {
48: printf("\n R->B ");
49:
50: if ((*s_etat_processus).langue == 'F')
51: {
52: printf("(réel vers binaire)\n\n");
53: }
54: else
55: {
56: printf("(real to binary)\n\n");
57: }
58:
59: printf(" 1: %s\n", d_INT);
60: printf("-> 1: %s\n", d_BIN);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet_argument) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if ((*s_objet_argument).type == INT)
86: {
87: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
88: {
89: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
90: return;
91: }
92:
93: if ((*((integer8 *) (*s_objet_argument).objet)) < 0)
94: {
95: (*((logical8 *) (*s_objet_resultat).objet)) = 0;
96: }
97: else
98: {
99: (*((logical8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
100: (*s_objet_argument).objet));
101: }
102: }
103: else
104: {
105: liberation(s_etat_processus, s_objet_argument);
106:
107: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
108: return;
109: }
110:
111: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
112: s_objet_resultat) == d_erreur)
113: {
114: return;
115: }
116:
117: liberation(s_etat_processus, s_objet_argument);
118: return;
119: }
120:
121:
122: /*
123: ================================================================================
124: Fonction 'rl'
125: ================================================================================
126: Entrées : pointeur sur une structure struct_processus
127: --------------------------------------------------------------------------------
128: Sorties :
129: --------------------------------------------------------------------------------
130: Effets de bord : néant
131: ================================================================================
132: */
133:
134: void
135: instruction_rl(struct_processus *s_etat_processus)
136: {
137: logical8 masque;
138: logical8 tampon;
139:
140: struct_objet *s_copie;
141: struct_objet *s_objet;
142:
143: unsigned long i;
144: unsigned long j;
145: unsigned long longueur;
146:
147: (*s_etat_processus).erreur_execution = d_ex;
148:
149: if ((*s_etat_processus).affichage_arguments == 'Y')
150: {
151: printf("\n RL ");
152:
153: if ((*s_etat_processus).langue == 'F')
154: {
155: printf("(rotation à gauche)\n\n");
156: }
157: else
158: {
159: printf("(rotate left)\n\n");
160: }
161:
162: printf(" 1: %s\n", d_BIN);
163: printf("-> 1: %s\n", d_BIN);
164:
165: return;
166: }
167: else if ((*s_etat_processus).test_instruction == 'Y')
168: {
169: (*s_etat_processus).nombre_arguments = -1;
170: return;
171: }
172:
173: if (test_cfsf(s_etat_processus, 31) == d_vrai)
174: {
175: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
176: {
177: return;
178: }
179: }
180:
181: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
182: &s_objet) == d_erreur)
183: {
184: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
185: return;
186: }
187:
188: if ((*s_objet).type == BIN)
189: {
190: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
191: {
192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
193: return;
194: }
195:
196: longueur = 1;
197: j = 1;
198:
199: for(i = 37; i <= 42; i++)
200: {
201: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
202: == d_vrai) ? j : 0;
203: j *= 2;
204: }
205:
206: tampon = (*((logical8 *) (*s_copie).objet));
207: masque = ((logical8) 1) << (longueur - 1);
208:
209: if ((tampon & masque) == 0)
210: {
211: tampon <<= 1;
212: }
213: else
214: {
215: tampon <<= 1;
216: tampon |= (logical8) 1;
217: }
218:
219: for(masque = 0, i = 0; i < longueur; i++)
220: {
221: masque <<= 1;
222: masque |= (logical8) 1;
223: }
224:
225: tampon &= masque;
226: (*((logical8 *) (*s_copie).objet)) = tampon;
227:
228: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
229: s_copie) == d_erreur)
230: {
231: return;
232: }
233: }
234: else
235: {
236: liberation(s_etat_processus, s_objet);
237:
238: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
239: return;
240: }
241:
242: liberation(s_etat_processus, s_objet);
243:
244: return;
245: }
246:
247:
248: /*
249: ================================================================================
250: Fonction 'rlb'
251: ================================================================================
252: Entrées : pointeur sur une structure struct_processus
253: --------------------------------------------------------------------------------
254: Sorties :
255: --------------------------------------------------------------------------------
256: Effets de bord : néant
257: ================================================================================
258: */
259:
260: void
261: instruction_rlb(struct_processus *s_etat_processus)
262: {
263: struct_liste_chainee *l_base_pile;
264:
265: unsigned long i;
266:
267: (*s_etat_processus).erreur_execution = d_ex;
268:
269: if ((*s_etat_processus).affichage_arguments == 'Y')
270: {
271: printf("\n RLB ");
272:
273: if ((*s_etat_processus).langue == 'F')
274: {
275: printf("(rotation d'un octet vers la gauche)\n\n");
276: }
277: else
278: {
279: printf("(rotate left byte)\n\n");
280: }
281:
282: printf(" 1: %s\n", d_BIN);
283: printf("-> 1: %s\n", d_BIN);
284:
285: return;
286: }
287: else if ((*s_etat_processus).test_instruction == 'Y')
288: {
289: (*s_etat_processus).nombre_arguments = -1;
290: return;
291: }
292:
293: if (test_cfsf(s_etat_processus, 31) == d_vrai)
294: {
295: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
296: {
297: return;
298: }
299: }
300:
301: l_base_pile = (*s_etat_processus).l_base_pile_last;
302: (*s_etat_processus).l_base_pile_last = NULL;
303:
304: for(i = 0; i < 8; i++)
305: {
306: instruction_rl(s_etat_processus);
307:
308: if (((*s_etat_processus).erreur_systeme != d_es) ||
309: ((*s_etat_processus).erreur_execution != d_ex))
310: {
311: break;
312: }
313: }
314:
315: if (test_cfsf(s_etat_processus, 31) == d_vrai)
316: {
317: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
318: {
319: return;
320: }
321: }
322:
323: (*s_etat_processus).l_base_pile_last = l_base_pile;
324: return;
325: }
326:
327:
328: /*
329: ================================================================================
330: Fonction 'rr'
331: ================================================================================
332: Entrées : pointeur sur une structure struct_processus
333: --------------------------------------------------------------------------------
334: Sorties :
335: --------------------------------------------------------------------------------
336: Effets de bord : néant
337: ================================================================================
338: */
339:
340: void
341: instruction_rr(struct_processus *s_etat_processus)
342: {
343: logical8 masque;
344: logical8 tampon;
345:
346: struct_objet *s_copie;
347: struct_objet *s_objet;
348:
349: unsigned long i;
350: unsigned long j;
351: unsigned long longueur;
352:
353: (*s_etat_processus).erreur_execution = d_ex;
354:
355: if ((*s_etat_processus).affichage_arguments == 'Y')
356: {
357: printf("\n RR ");
358:
359: if ((*s_etat_processus).langue == 'F')
360: {
361: printf("(rotation à droite)\n\n");
362: }
363: else
364: {
365: printf("(rotate right)\n\n");
366: }
367:
368: printf(" 1: %s\n", d_BIN);
369: printf("-> 1: %s\n", d_BIN);
370:
371: return;
372: }
373: else if ((*s_etat_processus).test_instruction == 'Y')
374: {
375: (*s_etat_processus).nombre_arguments = -1;
376: return;
377: }
378:
379: if (test_cfsf(s_etat_processus, 31) == d_vrai)
380: {
381: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
382: {
383: return;
384: }
385: }
386:
387: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
388: &s_objet) == d_erreur)
389: {
390: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
391: return;
392: }
393:
394: if ((*s_objet).type == BIN)
395: {
396: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
397: {
398: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
399: return;
400: }
401:
402: longueur = 1;
403: j = 1;
404:
405: for(i = 37; i <= 42; i++)
406: {
407: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
408: == d_vrai) ? j : 0;
409: j *= 2;
410: }
411:
412: tampon = (*((logical8 *) (*s_copie).objet));
413: masque = (logical8) 1;
414:
415: if ((tampon & masque) == 0)
416: {
417: tampon >>= 1;
418: }
419: else
420: {
421: tampon >>= 1;
422: tampon |= (((logical8) 1) << (longueur - 1));
423: }
424:
425: for(masque = 0, i = 0; i < longueur; i++)
426: {
427: masque <<= 1;
428: masque |= 1;
429: }
430:
431: tampon &= masque;
432: (*((logical8 *) (*s_copie).objet)) = tampon;
433:
434: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
435: s_copie) == d_erreur)
436: {
437: return;
438: }
439: }
440: else
441: {
442: liberation(s_etat_processus, s_objet);
443:
444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
445: return;
446: }
447:
448: liberation(s_etat_processus, s_objet);
449:
450: return;
451: }
452:
453:
454: /*
455: ================================================================================
456: Fonction 'rrb'
457: ================================================================================
458: Entrées : pointeur sur une structure struct_processus
459: --------------------------------------------------------------------------------
460: Sorties :
461: --------------------------------------------------------------------------------
462: Effets de bord : néant
463: ================================================================================
464: */
465:
466: void
467: instruction_rrb(struct_processus *s_etat_processus)
468: {
469: struct_liste_chainee *l_base_pile;
470:
471: unsigned long i;
472:
473: (*s_etat_processus).erreur_execution = d_ex;
474:
475: if ((*s_etat_processus).affichage_arguments == 'Y')
476: {
477: printf("\n RRB ");
478:
479: if ((*s_etat_processus).langue == 'F')
480: {
481: printf("(rotation d'un octet vers la droite)\n\n");
482: }
483: else
484: {
485: printf("(rotate right byte)\n\n");
486: }
487:
488: printf(" 1: %s\n", d_BIN);
489: printf("-> 1: %s\n", d_BIN);
490:
491: return;
492: }
493: else if ((*s_etat_processus).test_instruction == 'Y')
494: {
495: (*s_etat_processus).nombre_arguments = -1;
496: return;
497: }
498:
499: if (test_cfsf(s_etat_processus, 31) == d_vrai)
500: {
501: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
502: {
503: return;
504: }
505: }
506:
507: l_base_pile = (*s_etat_processus).l_base_pile_last;
508: (*s_etat_processus).l_base_pile_last = NULL;
509:
510: for(i = 0; i < 8; i++)
511: {
512: instruction_rr(s_etat_processus);
513:
514: if (((*s_etat_processus).erreur_systeme != d_es) ||
515: ((*s_etat_processus).erreur_execution != d_ex))
516: {
517: break;
518: }
519: }
520:
521: if (test_cfsf(s_etat_processus, 31) == d_vrai)
522: {
523: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
524: {
525: return;
526: }
527: }
528:
529: (*s_etat_processus).l_base_pile_last = l_base_pile;
530: return;
531: }
532:
533:
534: /*
535: ================================================================================
536: Fonction 'redraw'
537: ================================================================================
538: Entrées : pointeur sur une structure struct_processus
539: --------------------------------------------------------------------------------
540: Sorties :
541: --------------------------------------------------------------------------------
542: Effets de bord : néant
543: ================================================================================
544: */
545:
546: void
547: instruction_redraw(struct_processus *s_etat_processus)
548: {
549: (*s_etat_processus).erreur_execution = d_ex;
550:
551: if ((*s_etat_processus).affichage_arguments == 'Y')
552: {
553: printf("\n REDRAW ");
554:
555: if ((*s_etat_processus).langue == 'F')
556: {
557: printf("(redessine une courbe)\n\n");
558: printf(" Aucun argument\n");
559: }
560: else
561: {
562: printf("(redraw a graphic)\n\n");
563: printf(" No argument\n");
564: }
565:
566: return;
567: }
568: else if ((*s_etat_processus).test_instruction == 'Y')
569: {
570: (*s_etat_processus).nombre_arguments = -1;
571: return;
572: }
573:
574: if (test_cfsf(s_etat_processus, 31) == d_vrai)
575: {
576: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
577: {
578: return;
579: }
580: }
581:
582: if ((*s_etat_processus).mise_a_jour_trace_requise == d_vrai)
583: {
584: (*s_etat_processus).erreur_execution = d_ex_graphique_memorise;
585: return;
586: }
587:
588: if ((*s_etat_processus).fichiers_graphiques != NULL)
589: {
590: appel_gnuplot(s_etat_processus, 'N');
591: }
592:
593: return;
594: }
595:
596:
597: /*
598: ================================================================================
599: Fonction 'remove'
600: ================================================================================
601: Entrées : pointeur sur une structure struct_processus
602: --------------------------------------------------------------------------------
603: Sorties :
604: --------------------------------------------------------------------------------
605: Effets de bord : néant
606: ================================================================================
607: */
608:
609: void
610: instruction_remove(struct_processus *s_etat_processus)
611: {
612: struct_objet *s_objet_argument;
613:
614: (*s_etat_processus).erreur_execution = d_ex;
615:
616: if ((*s_etat_processus).affichage_arguments == 'Y')
617: {
618: printf("\n REMOVE ");
619:
620: if ((*s_etat_processus).langue == 'F')
621: {
622: printf("(retrait d'une bibliothèque dynamique)\n\n");
623: }
624: else
625: {
626: printf("(remove a shared library)\n\n");
627: }
628:
629: printf(" 1: %s\n", d_SLB);
630:
631: return;
632: }
633: else if ((*s_etat_processus).test_instruction == 'Y')
634: {
635: (*s_etat_processus).nombre_arguments = -1;
636: return;
637: }
638:
639: if (test_cfsf(s_etat_processus, 31) == d_vrai)
640: {
641: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
642: {
643: return;
644: }
645: }
646:
647: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
648: &s_objet_argument) == d_erreur)
649: {
650: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
651: return;
652: }
653:
654: if ((*s_objet_argument).type == SLB)
655: {
656: /*
657: * On ne décharge que les bibliothèques qui ont été chargées dans
658: * le couple pid/tid courant.
659: */
660:
661: if (((*((struct_bibliotheque *) (*s_objet_argument).objet)).pid ==
662: getpid()) && (pthread_equal((*((struct_bibliotheque *)
663: (*s_objet_argument).objet)).tid, pthread_self()) != 0))
664: {
665: if (retrait_bibliotheque(s_etat_processus,
666: (*s_objet_argument).objet) == d_erreur)
667: {
668: liberation(s_etat_processus, s_objet_argument);
669:
670: return;
671: }
672: }
673: }
674: else
675: {
676: liberation(s_etat_processus, s_objet_argument);
677:
678: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
679: return;
680: }
681:
682: liberation(s_etat_processus, s_objet_argument);
683:
684: return;
685: }
686:
687:
688: /*
689: ================================================================================
690: Fonction 'relax'
691: ================================================================================
692: Entrées : pointeur sur une structure struct_processus
693: --------------------------------------------------------------------------------
694: Sorties :
695: --------------------------------------------------------------------------------
696: Effets de bord : néant
697: ================================================================================
698: */
699:
700: void
701: instruction_relax(struct_processus *s_etat_processus)
702: {
703: (*s_etat_processus).erreur_execution = d_ex;
704:
705: if ((*s_etat_processus).affichage_arguments == 'Y')
706: {
707: printf("\n RELAX ");
708:
709: if ((*s_etat_processus).langue == 'F')
710: {
711: printf("(ne fait rien)\n\n");
712: printf(" Aucun argument\n");
713: }
714: else
715: {
716: printf("(do nothing)\n\n");
717: printf(" No argument\n");
718: }
719:
720: return;
721: }
722: else if ((*s_etat_processus).test_instruction == 'Y')
723: {
724: (*s_etat_processus).nombre_arguments = 1;
725: return;
726: }
727:
728: /*
729: * Cette instruction ne fait rien. Elle existe pour être symétrique
730: * à l'instruction CHS et permet de traiter les équations de façon
731: * simple (Ex : '+pi'). En principe, elle n'a pas a être appelée
732: * directement par l'utilisateur.
733: */
734:
735: return;
736: }
737:
738:
739: /*
740: ================================================================================
741: Fonction 'rewind'
742: ================================================================================
743: Entrées : pointeur sur une structure struct_processus
744: --------------------------------------------------------------------------------
745: Sorties :
746: --------------------------------------------------------------------------------
747: Effets de bord : néant
748: ================================================================================
749: */
750:
751: void
752: instruction_rewind(struct_processus *s_etat_processus)
753: {
1.5 bertrand 754: struct_descripteur_fichier *descripteur;
1.1 bertrand 755:
756: struct_objet *s_objet_argument;
757:
758: (*s_etat_processus).erreur_execution = d_ex;
759:
760: if ((*s_etat_processus).affichage_arguments == 'Y')
761: {
762: printf("\n REWIND ");
763:
764: if ((*s_etat_processus).langue == 'F')
765: {
766: printf("(retour au début d'un fichier)\n\n");
767: }
768: else
769: {
770: printf("(rewind a file)\n\n");
771: }
772:
773: printf(" 1: %s\n", d_FCH);
774:
775: return;
776: }
777: else if ((*s_etat_processus).test_instruction == 'Y')
778: {
779: (*s_etat_processus).nombre_arguments = -1;
780: return;
781: }
782:
783: if (test_cfsf(s_etat_processus, 31) == d_vrai)
784: {
785: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
786: {
787: return;
788: }
789: }
790:
791: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
792: &s_objet_argument) == d_erreur)
793: {
794: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
795: return;
796: }
797:
798: if ((*s_objet_argument).type == FCH)
799: {
800: if ((descripteur = descripteur_fichier(s_etat_processus,
801: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
802: {
803: return;
804: }
805:
1.5 bertrand 806: if ((*descripteur).type == 'C')
807: {
808: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0)
809: {
810: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
811: return;
812: }
813: }
814: else
1.1 bertrand 815: {
816: liberation(s_etat_processus, s_objet_argument);
817:
1.5 bertrand 818: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
1.1 bertrand 819: return;
820: }
821: }
822: else
823: {
824: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
825: return;
826: }
827:
828: liberation(s_etat_processus, s_objet_argument);
829:
830: return;
831: }
832:
833:
834: /*
835: ================================================================================
836: Fonction 'read'
837: ================================================================================
838: Entrées : pointeur sur une structure struct_processus
839: --------------------------------------------------------------------------------
840: Sorties :
841: --------------------------------------------------------------------------------
842: Effets de bord : néant
843: ================================================================================
844: */
845:
846: void
847: instruction_read(struct_processus *s_etat_processus)
848: {
1.6 bertrand 849: const char *queue;
850:
1.8 bertrand 851: int ios;
852:
853: integer8 element;
854: integer8 id;
855: integer8 position_clef;
856:
1.1 bertrand 857: logical1 indicateur_48;
858: logical1 presence_chaine;
859: logical1 presence_indicateur;
860:
861: long longueur_effective;
862: long longueur_enregistrement;
863: long longueur_questure;
864: long niveau;
865: long pointeur;
866: long position_finale;
867: long position_initiale;
868:
869: socklen_t longueur_adresse;
870:
1.6 bertrand 871: sqlite3_stmt *ppStmt;
872:
1.1 bertrand 873: struct flock lock;
874:
875: struct sockaddr_un adresse_unix;
876: struct sockaddr_in adresse_ipv4;
1.19 bertrand 877: # ifdef IPV6
1.1 bertrand 878: struct sockaddr_in6 adresse_ipv6;
1.19 bertrand 879: # endif
1.1 bertrand 880:
881: struct timespec attente;
882:
1.5 bertrand 883: struct_descripteur_fichier *descripteur;
884:
1.8 bertrand 885: struct_liste_chainee *l_element_courant;
886: struct_liste_chainee *l_element_inclus;
887:
1.1 bertrand 888: struct_objet *s_objet_adresse;
1.6 bertrand 889: struct_objet *s_objet_argument_1;
890: struct_objet *s_objet_argument_2;
1.1 bertrand 891: struct_objet *s_objet_resultat;
892: struct_objet *s_objet_type;
893:
894: unsigned char caractere;
1.8 bertrand 895: unsigned char *clef_utf8;
1.6 bertrand 896: unsigned char *commande;
1.1 bertrand 897: unsigned char *tampon_lecture;
898: unsigned char *tampon;
1.8 bertrand 899: unsigned char *tampon2;
1.1 bertrand 900:
901: unsigned long i;
902:
903: (*s_etat_processus).erreur_execution = d_ex;
904:
905: attente.tv_sec = 0;
906: attente.tv_nsec = GRANULARITE_us * 1000;
907:
908: if ((*s_etat_processus).affichage_arguments == 'Y')
909: {
910: printf("\n READ ");
911:
912: if ((*s_etat_processus).langue == 'F')
913: {
914: printf("(lecture d'un enregistrement d'un fichier)\n\n");
915: }
916: else
917: {
918: printf("(read a record of a file)\n\n");
919: }
920:
1.6 bertrand 921: printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
1.1 bertrand 922:
1.8 bertrand 923: printf(" 2: %s, %s\n", d_INT, d_CHN);
1.6 bertrand 924: printf(" 1: %s\n", d_FCH);
1.1 bertrand 925: return;
926: }
927: else if ((*s_etat_processus).test_instruction == 'Y')
928: {
929: (*s_etat_processus).nombre_arguments = -1;
930: return;
931: }
932:
933: if (test_cfsf(s_etat_processus, 31) == d_vrai)
934: {
1.6 bertrand 935: if ((*s_etat_processus).l_base_pile == NULL)
1.1 bertrand 936: {
1.6 bertrand 937: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1.1 bertrand 938: return;
939: }
1.6 bertrand 940:
941: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
942: {
943: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
944: .donnee).objet)).acces == 'S')
945: {
946: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
947: {
948: return;
949: }
950: }
951: else
952: {
953: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
954: {
955: return;
956: }
957: }
958: }
959: else
960: {
961: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
962: {
963: return;
964: }
965: }
1.1 bertrand 966: }
967:
968: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1.6 bertrand 969: &s_objet_argument_1) == d_erreur)
1.1 bertrand 970: {
971: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
972: return;
973: }
974:
1.6 bertrand 975: if ((*s_objet_argument_1).type == FCH)
1.1 bertrand 976: {
1.5 bertrand 977: if ((descripteur = descripteur_fichier(s_etat_processus,
1.6 bertrand 978: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
1.5 bertrand 979: {
980: return;
981: }
982:
1.1 bertrand 983: /*
984: * Vérification des verrous
985: */
986:
987: lock.l_type = F_RDLCK;
988: lock.l_whence = SEEK_SET;
989: lock.l_start = 0;
990: lock.l_len = 0;
991: lock.l_pid = getpid();
992:
1.5 bertrand 993: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
994: == -1)
1.1 bertrand 995: {
1.6 bertrand 996: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 997:
998: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
999: return;
1000: }
1001:
1002: if (lock.l_type != F_UNLCK)
1003: {
1.6 bertrand 1004: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1005:
1006: (*s_etat_processus).erreur_execution =
1007: d_ex_fichier_verrouille;
1008: return;
1009: }
1010:
1011: /*
1012: * Vérification de l'autorisation de lecture
1013: */
1014:
1.6 bertrand 1015: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1016: == 'W')
1.1 bertrand 1017: {
1.6 bertrand 1018: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1019:
1020: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1021: return;
1022: }
1.6 bertrand 1023: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1.1 bertrand 1024: == 'N')
1025: {
1.5 bertrand 1026: if ((*descripteur).type == 'C')
1.1 bertrand 1027: {
1.5 bertrand 1028: if (fflush((*descripteur).descripteur_c) != 0)
1029: {
1030: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1031: return;
1032: }
1.1 bertrand 1033: }
1034: }
1035:
1.6 bertrand 1036: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
1.1 bertrand 1037: {
1038: /*
1039: * Fichiers formatés
1040: */
1041:
1.6 bertrand 1042: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1043: == 'S')
1.1 bertrand 1044: {
1045: /*
1046: * Fichiers séquentiels
1047: */
1048:
1049: longueur_questure = 256;
1050:
1051: if ((tampon_lecture = malloc(longueur_questure *
1052: sizeof(unsigned char))) == NULL)
1053: {
1054: (*s_etat_processus).erreur_systeme =
1055: d_es_allocation_memoire;
1056: return;
1057: }
1058:
1.5 bertrand 1059: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1060:
1061: if ((position_initiale = ftell((*descripteur).descripteur_c))
1062: == -1)
1.1 bertrand 1063: {
1064: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1065: return;
1066: }
1067:
1068: do
1069: {
1070: longueur_effective = fread(tampon_lecture,
1071: (size_t) sizeof(unsigned char), longueur_questure,
1.5 bertrand 1072: (*descripteur).descripteur_c);
1.1 bertrand 1073:
1074: pointeur = 0;
1075: presence_indicateur = d_faux;
1076:
1077: while(pointeur < longueur_effective)
1078: {
1079: if (tampon_lecture[pointeur] == '{')
1080: {
1081: presence_indicateur = d_vrai;
1082: break;
1083: }
1084:
1085: position_initiale++;
1086: pointeur++;
1087: }
1088:
1089: if (presence_indicateur == d_vrai)
1090: {
1091: break;
1092: }
1093: } while(longueur_effective == longueur_questure);
1094:
1095: if (presence_indicateur == d_faux)
1096: {
1.6 bertrand 1097: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1098: free(tampon_lecture);
1099:
1100: (*s_etat_processus).erreur_execution =
1101: d_ex_fin_de_fichier_atteinte;
1102: return;
1103: }
1104:
1105: position_finale = position_initiale + 1;
1106: presence_chaine = d_faux;
1107: niveau = 1;
1108:
1.5 bertrand 1109: if (fseek((*descripteur).descripteur_c, position_finale,
1110: SEEK_SET) != 0)
1.1 bertrand 1111: {
1.6 bertrand 1112: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1113: free(tampon_lecture);
1114:
1115: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1116: return;
1117: }
1118:
1119: do
1120: {
1121: longueur_effective = fread(tampon_lecture,
1122: (size_t) sizeof(unsigned char), longueur_questure,
1.5 bertrand 1123: (*descripteur).descripteur_c);
1.1 bertrand 1124:
1125: pointeur = 0;
1126: presence_indicateur = d_faux;
1127:
1128: while(pointeur < longueur_effective)
1129: {
1130: if (tampon_lecture[pointeur] == '"')
1131: {
1.7 bertrand 1132: if (pointeur > 0)
1133: {
1134: if (tampon_lecture[pointeur - 1] != '\\')
1135: {
1136: presence_chaine = (presence_chaine ==
1137: d_vrai) ? d_faux : d_vrai;
1138: }
1139: }
1140: else
1141: {
1142: presence_chaine = (presence_chaine == d_vrai)
1143: ? d_faux : d_vrai;
1144: }
1.1 bertrand 1145: }
1146: else
1147: {
1148: if (presence_chaine == d_faux)
1149: {
1150: if (tampon_lecture[pointeur] == '{')
1151: {
1152: niveau++;
1153: }
1154: else if (tampon_lecture[pointeur] == '}')
1155: {
1156: niveau--;
1157: }
1158: }
1159: }
1160:
1161: position_finale++;
1162: pointeur++;
1163:
1164: if (niveau == 0)
1165: {
1166: presence_indicateur = d_vrai;
1167: break;
1168: }
1169: }
1170:
1171: if (presence_indicateur == d_vrai)
1172: {
1173: break;
1174: }
1175: } while(longueur_effective == longueur_questure);
1176:
1177: if (presence_indicateur == d_faux)
1178: {
1.6 bertrand 1179: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1180: free(tampon_lecture);
1181:
1182: (*s_etat_processus).erreur_execution =
1183: d_ex_fin_de_fichier_atteinte;
1184: return;
1185: }
1186:
1187: free(tampon_lecture);
1188: longueur_enregistrement = position_finale - position_initiale;
1189:
1190: if ((tampon_lecture = malloc((longueur_enregistrement + 1) *
1191: sizeof(unsigned char))) == NULL)
1192: {
1193: (*s_etat_processus).erreur_systeme =
1194: d_es_allocation_memoire;
1195: return;
1196: }
1197:
1.5 bertrand 1198: if (fseek((*descripteur).descripteur_c, position_initiale,
1199: SEEK_SET) != 0)
1.1 bertrand 1200: {
1.6 bertrand 1201: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1202: free(tampon_lecture);
1203:
1204: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1205: return;
1206: }
1207:
1208: longueur_effective = fread(tampon_lecture,
1209: (size_t) sizeof(unsigned char),
1210: (size_t) longueur_enregistrement,
1.5 bertrand 1211: (*descripteur).descripteur_c);
1.1 bertrand 1212:
1213: if (longueur_effective != longueur_enregistrement)
1214: {
1215: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1216: return;
1217: }
1218:
1219: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
1220: tampon = (*s_etat_processus).instruction_courante;
1.5 bertrand 1221:
1222: if (((*s_etat_processus).instruction_courante =
1223: transliteration(s_etat_processus, tampon_lecture,
1224: "UTF-8", d_locale)) == NULL)
1225: {
1.6 bertrand 1226: (*s_etat_processus).instruction_courante = tampon;
1227: liberation(s_etat_processus, s_objet_argument_1);
1.5 bertrand 1228: free(tampon_lecture);
1229: return;
1230: }
1.1 bertrand 1231:
1232: indicateur_48 = test_cfsf(s_etat_processus, 48);
1233: cf(s_etat_processus, 48);
1234:
1235: recherche_type(s_etat_processus);
1.5 bertrand 1236: free((*s_etat_processus).instruction_courante);
1.1 bertrand 1237:
1238: if ((*s_etat_processus).erreur_execution != d_ex)
1239: {
1.6 bertrand 1240: if (indicateur_48 == d_vrai)
1241: {
1242: sf(s_etat_processus, 48);
1243: }
1244: else
1245: {
1246: cf(s_etat_processus, 48);
1247: }
1248:
1.1 bertrand 1249: (*s_etat_processus).instruction_courante = tampon;
1250: free(tampon_lecture);
1251:
1.6 bertrand 1252: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1253: return;
1254: }
1255:
1256: if (indicateur_48 == d_vrai)
1257: {
1258: sf(s_etat_processus, 48);
1259: }
1260: else
1261: {
1262: cf(s_etat_processus, 48);
1263: }
1264:
1265: (*s_etat_processus).instruction_courante = tampon;
1266: free(tampon_lecture);
1267: }
1.6 bertrand 1268: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1.1 bertrand 1269: == 'D')
1270: {
1.6 bertrand 1271: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1272:
1273: if (depilement(s_etat_processus, &((*s_etat_processus)
1274: .l_base_pile), &s_objet_argument_2) == d_erreur)
1275: {
1276: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1277: return;
1278: }
1279:
1280: if ((*s_objet_argument_2).type != INT)
1281: {
1282: liberation(s_etat_processus, s_objet_argument_1);
1283: liberation(s_etat_processus, s_objet_argument_2);
1284:
1285: (*s_etat_processus).erreur_execution =
1286: d_ex_erreur_type_argument;
1287: return;
1288: }
1289:
1290: if (alsprintf(&commande, "select data from data where "
1291: "id = %lld", (*((integer8 *) (*s_objet_argument_2)
1292: .objet))) < 0)
1293: {
1294: (*s_etat_processus).erreur_systeme =
1295: d_es_allocation_memoire;
1296: return;
1297: }
1298:
1299: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1300: commande, strlen(commande), &ppStmt, &queue)
1301: != SQLITE_OK)
1302: {
1303: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1304: return;
1305: }
1306:
1307: switch(sqlite3_step(ppStmt))
1308: {
1309: case SQLITE_ROW:
1310: {
1311: // Résultat attendu
1312: break;
1313: }
1314:
1315: case SQLITE_DONE:
1316: {
1317: // Aucun enregistrement
1318: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1319: {
1320: (*s_etat_processus).erreur_systeme =
1321: d_es_erreur_fichier;
1322: return;
1323: }
1324:
1325: free(commande);
1326:
1327: liberation(s_etat_processus, s_objet_argument_1);
1328: liberation(s_etat_processus, s_objet_argument_2);
1329:
1330: (*s_etat_processus).erreur_execution =
1331: d_ex_enregistrement_inexistant;
1332: return;
1333: }
1334:
1335: default:
1336: {
1337: (*s_etat_processus).erreur_systeme =
1338: d_es_erreur_fichier;
1339: return;
1340: }
1341: }
1342:
1343: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1344: {
1345: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1346: return;
1347: }
1348:
1349: tampon = (*s_etat_processus).instruction_courante;
1350:
1351: if ((tampon_lecture = (unsigned char *)
1352: sqlite3_column_text(ppStmt, 0)) == NULL)
1353: {
1354: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1355: return;
1356: }
1357:
1358: if (((*s_etat_processus).instruction_courante =
1359: transliteration(s_etat_processus, tampon_lecture,
1360: "UTF-8", d_locale)) == NULL)
1361: {
1362: (*s_etat_processus).instruction_courante = tampon;
1363:
1364: liberation(s_etat_processus, s_objet_argument_1);
1365: liberation(s_etat_processus, s_objet_argument_2);
1366: free(commande);
1367: return;
1368: }
1369:
1370: indicateur_48 = test_cfsf(s_etat_processus, 48);
1371: cf(s_etat_processus, 48);
1372:
1373: recherche_type(s_etat_processus);
1374:
1375: if ((*s_etat_processus).erreur_execution != d_ex)
1376: {
1377: if (indicateur_48 == d_vrai)
1378: {
1379: sf(s_etat_processus, 48);
1380: }
1381: else
1382: {
1383: cf(s_etat_processus, 48);
1384: }
1385:
1386: liberation(s_etat_processus, s_objet_argument_1);
1387: liberation(s_etat_processus, s_objet_argument_2);
1388:
1389: free((*s_etat_processus).instruction_courante);
1390: free(commande);
1.8 bertrand 1391:
1392: (*s_etat_processus).instruction_courante = tampon;
1.6 bertrand 1393: return;
1394: }
1395:
1396: if (indicateur_48 == d_vrai)
1397: {
1398: sf(s_etat_processus, 48);
1399: }
1400: else
1401: {
1402: cf(s_etat_processus, 48);
1403: }
1404:
1405: free((*s_etat_processus).instruction_courante);
1406: liberation(s_etat_processus, s_objet_argument_2);
1407: (*s_etat_processus).instruction_courante = tampon;
1408:
1409: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1410: {
1411: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1412: return;
1413: }
1414:
1415: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1416: {
1417: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1418: return;
1419: }
1420:
1421: free(commande);
1.1 bertrand 1422: }
1423: else
1424: {
1.8 bertrand 1425: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1426:
1427: if (depilement(s_etat_processus, &((*s_etat_processus)
1428: .l_base_pile), &s_objet_argument_2) == d_erreur)
1429: {
1430: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1431: return;
1432: }
1433:
1434: if ((*s_objet_argument_2).type != CHN)
1435: {
1436: liberation(s_etat_processus, s_objet_argument_1);
1437: liberation(s_etat_processus, s_objet_argument_2);
1438:
1439: (*s_etat_processus).erreur_execution =
1440: d_ex_erreur_type_argument;
1441: return;
1442: }
1443:
1444: // Récupération de la position de la clef
1445:
1446: if (alsprintf(&commande, "select key from control "
1447: "where id = 1") < 0)
1448: {
1449: (*s_etat_processus).erreur_systeme =
1450: d_es_allocation_memoire;
1451: return;
1452: }
1453:
1454: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1455: commande, strlen(commande), &ppStmt, &queue)
1456: != SQLITE_OK)
1457: {
1458: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1459: return;
1460: }
1461:
1462: if (sqlite3_step(ppStmt) != SQLITE_ROW)
1463: {
1464: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1465: return;
1466: }
1467:
1468: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1469: {
1470: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1471: return;
1472: }
1473:
1474: position_clef = sqlite3_column_int64(ppStmt, 0);
1475:
1476: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1477: {
1478: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1479: return;
1480: }
1481:
1482: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1483: {
1484: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1485: return;
1486: }
1487:
1488: free(commande);
1489:
1490: if ((clef_utf8 = transliteration(s_etat_processus,
1491: (unsigned char *) (*s_objet_argument_2).objet,
1492: d_locale, "UTF-8")) == NULL)
1493: {
1494: liberation(s_etat_processus, s_objet_argument_1);
1495: liberation(s_etat_processus, s_objet_argument_2);
1496:
1497: return;
1498: }
1499:
1500: // Récupération de l'identifiant de la clef
1501:
1502: if (alsprintf(&commande, "select id from key where key = "
1503: "'{ \"%s\" }'", clef_utf8) < 0)
1504: {
1505: (*s_etat_processus).erreur_systeme =
1506: d_es_allocation_memoire;
1507: return;
1508: }
1509:
1510: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1511: commande, strlen(commande), &ppStmt, &queue)
1512: != SQLITE_OK)
1513: {
1514: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1515: return;
1516: }
1517:
1518: switch(sqlite3_step(ppStmt))
1519: {
1520: case SQLITE_ROW:
1521: {
1522: // Résultat attendu : une clef correspond.
1523: break;
1524: }
1525:
1526: case SQLITE_DONE:
1527: {
1528: // Aucun enregistrement
1529: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1530: {
1531: (*s_etat_processus).erreur_systeme =
1532: d_es_erreur_fichier;
1533: return;
1534: }
1535:
1536: free(clef_utf8);
1537: free(commande);
1538:
1539: liberation(s_etat_processus, s_objet_argument_1);
1540: liberation(s_etat_processus, s_objet_argument_2);
1541:
1542: (*s_etat_processus).erreur_execution =
1543: d_ex_enregistrement_inexistant;
1544: return;
1545: }
1546:
1547: default:
1548: {
1549: (*s_etat_processus).erreur_systeme =
1550: d_es_erreur_fichier;
1551: return;
1552: }
1553: }
1554:
1555: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1556: {
1557: free(clef_utf8);
1558: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1559: return;
1560: }
1561:
1562: id = sqlite3_column_int64(ppStmt, 0);
1563:
1564: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1565: {
1566: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1567: return;
1568: }
1569:
1570: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1571: {
1572: (*s_etat_processus).erreur_systeme =
1573: d_es_erreur_fichier;
1574: return;
1575: }
1576:
1577: free(commande);
1578:
1579: if (alsprintf(&commande, "select data from data where "
1580: "key_id = %lld order by sequence asc", id) < 0)
1581: {
1582: (*s_etat_processus).erreur_systeme =
1583: d_es_allocation_memoire;
1584: return;
1585: }
1586:
1587: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1588: commande, strlen(commande), &ppStmt, &queue)
1589: != SQLITE_OK)
1590: {
1591: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1592: return;
1593: }
1594:
1595: element = 1;
1596:
1597: do
1598: {
1599: switch(ios = sqlite3_step(ppStmt))
1600: {
1601: case SQLITE_ROW:
1602: {
1603: // Donnée supplémentaire
1604:
1605: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1606: {
1607: (*s_etat_processus).erreur_systeme =
1608: d_es_erreur_fichier;
1609: return;
1610: }
1611:
1612: tampon = (*s_etat_processus).instruction_courante;
1613:
1614: if ((tampon_lecture = (unsigned char *)
1615: sqlite3_column_text(ppStmt, 0)) == NULL)
1616: {
1617: (*s_etat_processus).erreur_systeme =
1618: d_es_erreur_fichier;
1619: return;
1620: }
1621:
1622: if (((*s_etat_processus).instruction_courante =
1623: transliteration(s_etat_processus,
1624: tampon_lecture,
1625: "UTF-8", d_locale)) == NULL)
1626: {
1627: (*s_etat_processus).instruction_courante =
1628: tampon;
1629:
1630: liberation(s_etat_processus,
1631: s_objet_argument_1);
1632: liberation(s_etat_processus,
1633: s_objet_argument_2);
1634:
1635: free(commande);
1636: free(clef_utf8);
1637: return;
1638: }
1639:
1640: indicateur_48 = test_cfsf(s_etat_processus, 48);
1641: cf(s_etat_processus, 48);
1642:
1643: recherche_type(s_etat_processus);
1644:
1645: if ((*s_etat_processus).erreur_execution != d_ex)
1646: {
1647: if (indicateur_48 == d_vrai)
1648: {
1649: sf(s_etat_processus, 48);
1650: }
1651: else
1652: {
1653: cf(s_etat_processus, 48);
1654: }
1655:
1656: liberation(s_etat_processus,
1657: s_objet_argument_1);
1658: liberation(s_etat_processus,
1659: s_objet_argument_2);
1660:
1661: free((*s_etat_processus).instruction_courante);
1662: free(commande);
1663: free(clef_utf8);
1664:
1665: (*s_etat_processus).instruction_courante =
1666: tampon;
1667: return;
1668: }
1669:
1670: if (indicateur_48 == d_vrai)
1671: {
1672: sf(s_etat_processus, 48);
1673: }
1674: else
1675: {
1676: cf(s_etat_processus, 48);
1677: }
1678:
1679: free((*s_etat_processus).instruction_courante);
1680: (*s_etat_processus).instruction_courante = tampon;
1681:
1682: element++;
1683:
1684: // Inscription de la clef
1685:
1686: if (element == position_clef)
1687: {
1688: if (((*s_etat_processus).instruction_courante =
1689: transliteration(s_etat_processus,
1690: clef_utf8, "UTF-8", d_locale)) == NULL)
1691: {
1692: (*s_etat_processus).instruction_courante =
1693: tampon;
1694:
1695: liberation(s_etat_processus,
1696: s_objet_argument_1);
1697: liberation(s_etat_processus,
1698: s_objet_argument_2);
1699:
1700: free(commande);
1701: free(clef_utf8);
1702: return;
1703: }
1704:
1705: if (alsprintf(&tampon2, "{ \"%s\" }",
1706: (*s_etat_processus)
1707: .instruction_courante) < 0)
1708: {
1709: (*s_etat_processus).erreur_systeme =
1710: d_es_allocation_memoire;
1711: return;
1712: }
1713:
1714: free((*s_etat_processus).instruction_courante);
1715: (*s_etat_processus).instruction_courante
1716: = tampon2;
1717:
1718: indicateur_48 = test_cfsf(s_etat_processus, 48);
1719: cf(s_etat_processus, 48);
1720:
1721: recherche_type(s_etat_processus);
1722:
1723: if ((*s_etat_processus).erreur_execution
1724: != d_ex)
1725: {
1726: if (indicateur_48 == d_vrai)
1727: {
1728: sf(s_etat_processus, 48);
1729: }
1730: else
1731: {
1732: cf(s_etat_processus, 48);
1733: }
1734:
1735: liberation(s_etat_processus,
1736: s_objet_argument_1);
1737: liberation(s_etat_processus,
1738: s_objet_argument_2);
1739:
1740: free((*s_etat_processus)
1741: .instruction_courante);
1742: free(commande);
1743: free(clef_utf8);
1744:
1745: (*s_etat_processus).instruction_courante =
1746: tampon;
1747: return;
1748: }
1749:
1750: if (indicateur_48 == d_vrai)
1751: {
1752: sf(s_etat_processus, 48);
1753: }
1754: else
1755: {
1756: cf(s_etat_processus, 48);
1757: }
1758:
1759: free((*s_etat_processus).instruction_courante);
1760: (*s_etat_processus).instruction_courante =
1761: tampon;
1762:
1763: element++;
1764: }
1765:
1766: break;
1767: }
1768:
1769: case SQLITE_DONE:
1770: {
1771: // Fin de la liste
1772: break;
1773: }
1774:
1775: default:
1776: {
1777: (*s_etat_processus).erreur_systeme =
1778: d_es_erreur_fichier;
1779: return;
1780: }
1781: }
1782:
1783: } while(ios != SQLITE_DONE);
1784:
1785: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1786: {
1787: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1788: return;
1789: }
1790:
1791: free(commande);
1792: free(clef_utf8);
1793:
1794: liberation(s_etat_processus, s_objet_argument_2);
1795:
1796: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1797: == NULL)
1798: {
1799: (*s_etat_processus).erreur_systeme =
1800: d_es_allocation_memoire;
1801: return;
1802: }
1803:
1804: l_element_courant = NULL;
1.9 bertrand 1805: l_element_inclus = NULL;
1.8 bertrand 1806:
1807: for(element--; element > 0; element--)
1808: {
1809: if (depilement(s_etat_processus, &((*s_etat_processus)
1810: .l_base_pile), &s_objet_argument_2) == d_erreur)
1811: {
1812: (*s_etat_processus).erreur_systeme =
1813: d_es_erreur_fichier;
1814: return;
1815: }
1816:
1817: if ((*s_objet_argument_2).type != LST)
1818: {
1819: (*s_etat_processus).erreur_systeme =
1820: d_es_erreur_fichier;
1821: return;
1822: }
1823:
1824: l_element_inclus = (*s_objet_argument_2).objet;
1825:
1826: if (l_element_inclus != NULL)
1827: {
1828: while(l_element_inclus != NULL)
1829: {
1830: if ((*l_element_inclus).suivant == NULL)
1831: {
1832: (*l_element_inclus).suivant = l_element_courant;
1833: break;
1834: }
1835:
1836: l_element_inclus = (*l_element_inclus).suivant;
1837: }
1838:
1839: l_element_courant = (*s_objet_argument_2).objet;
1840: (*s_objet_argument_2).objet = NULL;
1841: }
1842:
1843: liberation(s_etat_processus, s_objet_argument_2);
1844: }
1845:
1846: (*s_objet_resultat).objet = l_element_inclus;
1847:
1848: if (empilement(s_etat_processus,
1849: &((*s_etat_processus).l_base_pile),
1850: s_objet_resultat) == d_erreur)
1851: {
1852: return;
1853: }
1.1 bertrand 1854: }
1855: }
1.6 bertrand 1856: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1.1 bertrand 1857: == 'Y')
1858: {
1859: /*
1860: * Fichiers non formatés
1861: */
1862: }
1863: else
1864: {
1865: /*
1866: * Fichiers de type FLOW
1867: */
1868: }
1869: }
1.6 bertrand 1870: else if ((*s_objet_argument_1).type == SCK)
1.1 bertrand 1871: {
1872: /*
1873: * Vérification de l'autorisation de lecture
1874: */
1875:
1.6 bertrand 1876: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
1877: == 'W')
1.1 bertrand 1878: {
1.6 bertrand 1879: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1880:
1881: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1882: return;
1883: }
1884:
1885: /*
1886: * Vérification de l'écoute de la socket si celle-ci est connectée
1887: */
1888:
1.6 bertrand 1889: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1.1 bertrand 1890: "STREAM") == 0) || (strcmp((*((struct_socket *)
1.6 bertrand 1891: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
1892: == 0))
1.1 bertrand 1893: {
1.6 bertrand 1894: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 1895: .socket_en_ecoute == 'Y')
1896: {
1.6 bertrand 1897: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1898:
1899: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
1900: return;
1901: }
1902: }
1903:
1.6 bertrand 1904: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
1.1 bertrand 1905: { // Socket formatée
1906: longueur_questure = 256;
1907:
1908: do
1909: {
1910: if ((tampon_lecture = malloc((longueur_questure + 1) *
1911: sizeof(unsigned char))) == NULL)
1912: {
1913: (*s_etat_processus).erreur_systeme =
1914: d_es_allocation_memoire;
1915: return;
1916: }
1917:
1.12 bertrand 1918: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 1919: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1920: {
1921: (*s_etat_processus).erreur_systeme = d_es_processus;
1922: return;
1923: }
1.12 bertrand 1924: # else
1925: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1926: {
1927: (*s_etat_processus).erreur_systeme = d_es_processus;
1928: return;
1929: }
1930: # endif
1.1 bertrand 1931:
1932: for(;;)
1933: {
1.6 bertrand 1934: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1935: .domaine == PF_UNIX)
1.1 bertrand 1936: {
1937: longueur_adresse = sizeof(adresse_unix);
1938: longueur_effective = recvfrom((*((struct_socket *)
1.6 bertrand 1939: (*s_objet_argument_1).objet)).socket,
1.1 bertrand 1940: tampon_lecture, longueur_questure,
1941: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1942: &adresse_unix, &longueur_adresse);
1943: }
1.6 bertrand 1944: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 1945: .domaine == PF_INET)
1946: {
1947: longueur_adresse = sizeof(adresse_ipv4);
1948: longueur_effective = recvfrom((*((struct_socket *)
1.6 bertrand 1949: (*s_objet_argument_1).objet)).socket,
1.1 bertrand 1950: tampon_lecture, longueur_questure,
1951: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1952: &adresse_ipv4, &longueur_adresse);
1953: }
1.6 bertrand 1954: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 1955: .domaine == PF_INET6)
1956: {
1.19 bertrand 1957: # ifdef IPV6
1.1 bertrand 1958: longueur_adresse = sizeof(adresse_ipv6);
1959: longueur_effective = recvfrom((*((struct_socket *)
1.6 bertrand 1960: (*s_objet_argument_1).objet)).socket,
1.1 bertrand 1961: tampon_lecture, longueur_questure,
1962: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1963: &adresse_ipv6, &longueur_adresse);
1.19 bertrand 1964: # else
1965: # endif
1.1 bertrand 1966: }
1967: else
1968: {
1969: free(tampon_lecture);
1.6 bertrand 1970: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1971:
1.12 bertrand 1972: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 1973: while(sem_wait(&((*s_etat_processus)
1974: .semaphore_fork)) == -1)
1.12 bertrand 1975: # else
1976: while(sem_wait((*s_etat_processus)
1977: .semaphore_fork) == -1)
1978: # endif
1.1 bertrand 1979: {
1980: if (errno != EINTR)
1981: {
1982: (*s_etat_processus).erreur_systeme =
1983: d_es_processus;
1984: return;
1985: }
1986: }
1987:
1988: (*s_etat_processus).erreur_execution =
1989: d_ex_erreur_acces_fichier;
1990: return;
1991: }
1992:
1993: if (longueur_effective < 0)
1994: {
1995: nanosleep(&attente, NULL);
1996: scrutation_injection(s_etat_processus);
1997: }
1998:
1999: if (((*s_etat_processus).var_volatile_requete_arret == -1)
2000: || (longueur_effective >= 0))
2001: {
2002: break;
2003: }
2004: }
2005:
1.12 bertrand 2006: # ifndef SEMAPHORES_NOMMES
2007: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
2008: # else
2009: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
2010: # endif
1.1 bertrand 2011: {
2012: if (errno != EINTR)
2013: {
2014: (*s_etat_processus).erreur_systeme = d_es_processus;
2015: return;
2016: }
2017: }
2018:
2019: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2020: {
2021:
2022: /*
2023: * Si le père tue le processus courant grâce au signal
2024: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
2025: * correspond à l'utilisation de STOP sur le processus
2026: * en cours. La variable longueur_effective vaut '-1'.
2027: */
2028:
2029: free(tampon_lecture);
1.6 bertrand 2030: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2031: return;
2032: }
2033:
2034: if (longueur_effective == -1)
2035: {
2036: free(tampon_lecture);
1.6 bertrand 2037: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2038:
2039: (*s_etat_processus).erreur_execution =
2040: d_ex_erreur_acces_fichier;
2041: return;
2042: }
2043:
2044: position_initiale = 0;
2045: presence_indicateur = d_faux;
2046:
2047: do
2048: {
2049: if (tampon_lecture[position_initiale] == '{')
2050: {
2051: presence_indicateur = d_vrai;
2052: break;
2053: }
2054:
2055: position_initiale++;
2056: } while(position_initiale < longueur_effective);
2057:
2058:
2059: if (presence_indicateur == d_vrai)
2060: {
2061: position_finale = position_initiale + 1;
2062: presence_chaine = d_faux;
2063: presence_indicateur = d_faux;
2064: niveau = 1;
2065:
2066: while(position_finale < longueur_effective)
2067: {
2068: caractere = tampon_lecture[position_finale];
2069:
2070: if (caractere == '"')
2071: {
2072: presence_chaine = (presence_chaine == d_vrai)
2073: ? d_faux : d_vrai;
2074: }
2075: else
2076: {
2077: if (presence_chaine == d_faux)
2078: {
2079: if (caractere == '{')
2080: {
2081: niveau++;
2082: }
2083: else if (caractere == '}')
2084: {
2085: niveau--;
2086: }
2087: }
2088: }
2089:
2090: if (niveau == 0)
2091: {
2092: presence_indicateur = d_vrai;
2093: break;
2094: }
2095:
2096: position_finale++;
2097: }
2098: }
2099:
2100: if (presence_indicateur == d_faux)
2101: {
2102: if (longueur_effective < longueur_questure)
2103: {
1.6 bertrand 2104: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2105: free(tampon_lecture);
2106:
2107: (*s_etat_processus).erreur_execution =
2108: d_ex_fin_de_fichier_atteinte;
2109: return;
2110: }
2111:
2112: free(tampon_lecture);
2113: longueur_questure *= 2;
2114: }
2115: } while(presence_indicateur == d_faux);
2116:
2117: tampon_lecture[++position_finale] = d_code_fin_chaine;
2118: tampon = (*s_etat_processus).instruction_courante;
2119: (*s_etat_processus).instruction_courante = &(tampon_lecture
2120: [position_initiale]);
2121:
2122: indicateur_48 = test_cfsf(s_etat_processus, 48);
2123: cf(s_etat_processus, 48);
2124:
2125: recherche_type(s_etat_processus);
2126:
2127: if ((*s_etat_processus).erreur_execution != d_ex)
2128: {
2129: (*s_etat_processus).instruction_courante = tampon;
2130: free(tampon_lecture);
2131:
1.6 bertrand 2132: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2133: return;
2134: }
2135:
2136: if (indicateur_48 == d_vrai)
2137: {
2138: sf(s_etat_processus, 48);
2139: }
2140: else
2141: {
2142: cf(s_etat_processus, 48);
2143: }
2144:
2145: (*s_etat_processus).instruction_courante = tampon;
2146:
2147: /*
2148: * Création de la liste de sortie
2149: */
2150:
2151: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2152: &s_objet_type) == d_erreur)
2153: {
2154: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2155: return;
2156: }
2157:
2158: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2159: == NULL)
2160: {
2161: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2162: return;
2163: }
2164:
2165: if (((*s_objet_resultat).objet =
2166: allocation_maillon(s_etat_processus)) == NULL)
2167: {
2168: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2169: return;
2170: }
2171:
2172: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
2173: .donnee = s_objet_type;
2174:
2175: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
2176: .suivant = allocation_maillon(s_etat_processus)) == NULL)
2177: {
2178: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2179: return;
2180: }
2181:
2182: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2183: .suivant = NULL;
2184:
2185: if ((s_objet_adresse = allocation(s_etat_processus, LST))
2186: == NULL)
2187: {
2188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2189: return;
2190: }
2191:
2192: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2193: .donnee = s_objet_adresse;
2194:
2195: /*
2196: * Les informations concernant la cible sont valides si
2197: * la socket est non connectée et des domaines INET ou INET6.
2198: * Dans tous les autres cas, on renvoie une liste vide.
2199: */
2200:
1.6 bertrand 2201: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
1.1 bertrand 2202: == PF_UNIX) || (strcmp((*((struct_socket *)
1.6 bertrand 2203: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
2204: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2205: .type, "SEQUENTIAL DATAGRAM") == 0))
2206: {
2207: longueur_adresse = 0;
2208: recvfrom((*((struct_socket *)
1.6 bertrand 2209: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1.1 bertrand 2210: position_finale, MSG_DONTWAIT,
2211: NULL, &longueur_adresse);
2212:
2213: (*s_objet_adresse).objet = NULL;
2214: }
1.6 bertrand 2215: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2216: .domaine == PF_INET)
2217: {
2218: longueur_adresse = sizeof(adresse_ipv4);
2219: recvfrom((*((struct_socket *)
1.6 bertrand 2220: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1.1 bertrand 2221: position_finale, MSG_DONTWAIT,
2222: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
2223:
2224: if (((*s_objet_adresse).objet =
2225: allocation_maillon(s_etat_processus)) == NULL)
2226: {
2227: (*s_etat_processus).erreur_systeme =
2228: d_es_allocation_memoire;
2229: return;
2230: }
2231:
2232: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2233: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2234: {
2235: (*s_etat_processus).erreur_systeme =
2236: d_es_allocation_memoire;
2237: return;
2238: }
2239:
2240: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2241: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
2242:
2243: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2244: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2245: malloc(4 * sizeof(integer8))) == NULL)
2246: {
2247: (*s_etat_processus).erreur_systeme =
2248: d_es_allocation_memoire;
2249: return;
2250: }
2251:
2252: ((integer8 *) (*((struct_vecteur *)
2253: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2254: .objet)).donnee).objet)).tableau)[0] =
2255: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
2256: ((integer8 *) (*((struct_vecteur *)
2257: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2258: .objet)).donnee).objet)).tableau)[1] =
2259: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
2260: ((integer8 *) (*((struct_vecteur *)
2261: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2262: .objet)).donnee).objet)).tableau)[2] =
2263: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
2264: ((integer8 *) (*((struct_vecteur *)
2265: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2266: .objet)).donnee).objet)).tableau)[3] =
2267: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
2268:
2269: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2270: .suivant = allocation_maillon(s_etat_processus))
2271: == NULL)
2272: {
2273: (*s_etat_processus).erreur_systeme =
2274: d_es_allocation_memoire;
2275: return;
2276: }
2277:
2278: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2279: .suivant).donnee = allocation(s_etat_processus, INT))
2280: == NULL)
2281: {
2282: (*s_etat_processus).erreur_systeme =
2283: d_es_allocation_memoire;
2284: return;
2285: }
2286:
2287: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1.6 bertrand 2288: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1.1 bertrand 2289: (integer8) ntohs(adresse_ipv4.sin_port);
2290:
2291: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2292: .suivant).suivant = NULL;
2293: }
1.6 bertrand 2294: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2295: .domaine == PF_INET6)
2296: {
1.19 bertrand 2297: # ifdef IPV6
1.1 bertrand 2298: longueur_adresse = sizeof(adresse_ipv6);
2299: recvfrom((*((struct_socket *)
1.6 bertrand 2300: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1.1 bertrand 2301: position_finale, MSG_DONTWAIT,
2302: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
2303:
2304: if (((*s_objet_adresse).objet =
2305: allocation_maillon(s_etat_processus)) == NULL)
2306: {
2307: (*s_etat_processus).erreur_systeme =
2308: d_es_allocation_memoire;
2309: return;
2310: }
2311:
2312: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2313: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2314: {
2315: (*s_etat_processus).erreur_systeme =
2316: d_es_allocation_memoire;
2317: return;
2318: }
2319:
2320: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2321: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
2322:
2323: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2324: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2325: malloc(16 * sizeof(integer8))) == NULL)
2326: {
2327: (*s_etat_processus).erreur_systeme =
2328: d_es_allocation_memoire;
2329: return;
2330: }
2331:
2332: for(i = 0; i < 16; i++)
2333: {
2334: ((integer8 *) (*((struct_vecteur *)
2335: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2336: .objet)).donnee).objet)).tableau)[0] =
2337: adresse_ipv6.sin6_addr.s6_addr[i];
2338: }
2339:
2340: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2341: .suivant = allocation_maillon(s_etat_processus))
2342: == NULL)
2343: {
2344: (*s_etat_processus).erreur_systeme =
2345: d_es_allocation_memoire;
2346: return;
2347: }
2348:
2349: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2350: .suivant).donnee = allocation(s_etat_processus, INT))
2351: == NULL)
2352: {
2353: (*s_etat_processus).erreur_systeme =
2354: d_es_allocation_memoire;
2355: return;
2356: }
2357:
2358: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1.6 bertrand 2359: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1.1 bertrand 2360: (integer8) ntohs(adresse_ipv6.sin6_port);
2361:
2362: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2363: .suivant).suivant = NULL;
1.19 bertrand 2364: # else
2365: # endif
1.1 bertrand 2366: }
2367: else
2368: {
2369: longueur_adresse = 0;
2370: recvfrom((*((struct_socket *)
1.6 bertrand 2371: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1.1 bertrand 2372: position_finale, MSG_DONTWAIT,
2373: NULL, &longueur_adresse);
2374: }
2375:
2376: free(tampon_lecture);
2377:
2378: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2379: s_objet_resultat) == d_erreur)
2380: {
2381: return;
2382: }
2383: }
2384: else
2385: {
2386: /* FLOW ou UNFORMATTED */
2387: }
2388: }
2389: else
2390: {
2391: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2392: return;
2393: }
2394:
1.6 bertrand 2395: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2396:
2397: return;
2398: }
2399:
2400: // vim: ts=4