1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.10
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: 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: {
754: file *descripteur;
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:
806: if (fseek(descripteur, (long) 0, SEEK_SET) != 0)
807: {
808: liberation(s_etat_processus, s_objet_argument);
809:
810: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
811: return;
812: }
813: }
814: else
815: {
816: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
817: return;
818: }
819:
820: liberation(s_etat_processus, s_objet_argument);
821:
822: return;
823: }
824:
825:
826: /*
827: ================================================================================
828: Fonction 'read'
829: ================================================================================
830: Entrées : pointeur sur une structure struct_processus
831: --------------------------------------------------------------------------------
832: Sorties :
833: --------------------------------------------------------------------------------
834: Effets de bord : néant
835: ================================================================================
836: */
837:
838: void
839: instruction_read(struct_processus *s_etat_processus)
840: {
841: file *descripteur;
842:
843: logical1 indicateur_48;
844: logical1 presence_chaine;
845: logical1 presence_indicateur;
846:
847: long longueur_effective;
848: long longueur_enregistrement;
849: long longueur_questure;
850: long niveau;
851: long pointeur;
852: long position_finale;
853: long position_initiale;
854:
855: socklen_t longueur_adresse;
856:
857: struct flock lock;
858:
859: struct sockaddr_un adresse_unix;
860: struct sockaddr_in adresse_ipv4;
861: struct sockaddr_in6 adresse_ipv6;
862:
863: struct timespec attente;
864:
865: struct_objet *s_objet_adresse;
866: struct_objet *s_objet_argument;
867: struct_objet *s_objet_resultat;
868: struct_objet *s_objet_type;
869:
870: unsigned char caractere;
871: unsigned char *tampon_lecture;
872: unsigned char *tampon;
873:
874: unsigned long i;
875:
876: (*s_etat_processus).erreur_execution = d_ex;
877:
878: attente.tv_sec = 0;
879: attente.tv_nsec = GRANULARITE_us * 1000;
880:
881: if ((*s_etat_processus).affichage_arguments == 'Y')
882: {
883: printf("\n READ ");
884:
885: if ((*s_etat_processus).langue == 'F')
886: {
887: printf("(lecture d'un enregistrement d'un fichier)\n\n");
888: }
889: else
890: {
891: printf("(read a record of a file)\n\n");
892: }
893:
894: printf(" 1: %s, %s\n", d_FCH, d_SCK);
895: printf(" To be fixed !\n");
896:
897: return;
898: }
899: else if ((*s_etat_processus).test_instruction == 'Y')
900: {
901: (*s_etat_processus).nombre_arguments = -1;
902: return;
903: }
904:
905: if (test_cfsf(s_etat_processus, 31) == d_vrai)
906: {
907: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
908: {
909: return;
910: }
911: }
912:
913: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
914: &s_objet_argument) == d_erreur)
915: {
916: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
917: return;
918: }
919:
920: if ((*s_objet_argument).type == FCH)
921: {
922: /*
923: * Vérification des verrous
924: */
925:
926: lock.l_type = F_RDLCK;
927: lock.l_whence = SEEK_SET;
928: lock.l_start = 0;
929: lock.l_len = 0;
930: lock.l_pid = getpid();
931:
932: if ((descripteur = descripteur_fichier(s_etat_processus,
933: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
934: {
935: return;
936: }
937:
938: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
939: {
940: liberation(s_etat_processus, s_objet_argument);
941:
942: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
943: return;
944: }
945:
946: if (lock.l_type != F_UNLCK)
947: {
948: liberation(s_etat_processus, s_objet_argument);
949:
950: (*s_etat_processus).erreur_execution =
951: d_ex_fichier_verrouille;
952: return;
953: }
954:
955: /*
956: * Vérification de l'autorisation de lecture
957: */
958:
959: if ((*((struct_fichier *) (*s_objet_argument).objet)).protection == 'W')
960: {
961: liberation(s_etat_processus, s_objet_argument);
962:
963: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
964: return;
965: }
966: else if ((*((struct_fichier *) (*s_objet_argument).objet)).protection
967: == 'N')
968: {
969: if (fflush(descripteur) != 0)
970: {
971: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
972: return;
973: }
974: }
975:
976: if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire == 'N')
977: {
978: /*
979: * Fichiers formatés
980: */
981:
982: if ((*((struct_fichier *) (*s_objet_argument).objet)).acces == 'S')
983: {
984: /*
985: * Fichiers séquentiels
986: */
987:
988: longueur_questure = 256;
989:
990: if ((tampon_lecture = malloc(longueur_questure *
991: sizeof(unsigned char))) == NULL)
992: {
993: (*s_etat_processus).erreur_systeme =
994: d_es_allocation_memoire;
995: return;
996: }
997:
998: if ((position_initiale = ftell(descripteur)) == -1)
999: {
1000: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1001: return;
1002: }
1003:
1004: do
1005: {
1006: longueur_effective = fread(tampon_lecture,
1007: (size_t) sizeof(unsigned char), longueur_questure,
1008: descripteur);
1009:
1010: pointeur = 0;
1011: presence_indicateur = d_faux;
1012:
1013: while(pointeur < longueur_effective)
1014: {
1015: if (tampon_lecture[pointeur] == '{')
1016: {
1017: presence_indicateur = d_vrai;
1018: break;
1019: }
1020:
1021: position_initiale++;
1022: pointeur++;
1023: }
1024:
1025: if (presence_indicateur == d_vrai)
1026: {
1027: break;
1028: }
1029: } while(longueur_effective == longueur_questure);
1030:
1031: if (presence_indicateur == d_faux)
1032: {
1033: liberation(s_etat_processus, s_objet_argument);
1034: free(tampon_lecture);
1035:
1036: (*s_etat_processus).erreur_execution =
1037: d_ex_fin_de_fichier_atteinte;
1038: return;
1039: }
1040:
1041: position_finale = position_initiale + 1;
1042: presence_chaine = d_faux;
1043: niveau = 1;
1044:
1045: if (fseek(descripteur, position_finale, SEEK_SET) != 0)
1046: {
1047: liberation(s_etat_processus, s_objet_argument);
1048: free(tampon_lecture);
1049:
1050: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1051: return;
1052: }
1053:
1054: do
1055: {
1056: longueur_effective = fread(tampon_lecture,
1057: (size_t) sizeof(unsigned char), longueur_questure,
1058: descripteur);
1059:
1060: pointeur = 0;
1061: presence_indicateur = d_faux;
1062:
1063: while(pointeur < longueur_effective)
1064: {
1065: if (tampon_lecture[pointeur] == '"')
1066: {
1067: presence_chaine = (presence_chaine == d_vrai)
1068: ? d_faux : d_vrai;
1069: }
1070: else
1071: {
1072: if (presence_chaine == d_faux)
1073: {
1074: if (tampon_lecture[pointeur] == '{')
1075: {
1076: niveau++;
1077: }
1078: else if (tampon_lecture[pointeur] == '}')
1079: {
1080: niveau--;
1081: }
1082: }
1083: }
1084:
1085: position_finale++;
1086: pointeur++;
1087:
1088: if (niveau == 0)
1089: {
1090: presence_indicateur = d_vrai;
1091: break;
1092: }
1093: }
1094:
1095: if (presence_indicateur == d_vrai)
1096: {
1097: break;
1098: }
1099: } while(longueur_effective == longueur_questure);
1100:
1101: if (presence_indicateur == d_faux)
1102: {
1103: liberation(s_etat_processus, s_objet_argument);
1104: free(tampon_lecture);
1105:
1106: (*s_etat_processus).erreur_execution =
1107: d_ex_fin_de_fichier_atteinte;
1108: return;
1109: }
1110:
1111: free(tampon_lecture);
1112: longueur_enregistrement = position_finale - position_initiale;
1113:
1114: if ((tampon_lecture = malloc((longueur_enregistrement + 1) *
1115: sizeof(unsigned char))) == NULL)
1116: {
1117: (*s_etat_processus).erreur_systeme =
1118: d_es_allocation_memoire;
1119: return;
1120: }
1121:
1122: if (fseek(descripteur, position_initiale, SEEK_SET) != 0)
1123: {
1124: liberation(s_etat_processus, s_objet_argument);
1125: free(tampon_lecture);
1126:
1127: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1128: return;
1129: }
1130:
1131: longueur_effective = fread(tampon_lecture,
1132: (size_t) sizeof(unsigned char),
1133: (size_t) longueur_enregistrement,
1134: descripteur);
1135:
1136: if (longueur_effective != longueur_enregistrement)
1137: {
1138: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1139: return;
1140: }
1141:
1142: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
1143: tampon = (*s_etat_processus).instruction_courante;
1144: (*s_etat_processus).instruction_courante = tampon_lecture;
1145:
1146: indicateur_48 = test_cfsf(s_etat_processus, 48);
1147: cf(s_etat_processus, 48);
1148:
1149: recherche_type(s_etat_processus);
1150:
1151: if ((*s_etat_processus).erreur_execution != d_ex)
1152: {
1153: (*s_etat_processus).instruction_courante = tampon;
1154: free(tampon_lecture);
1155:
1156: liberation(s_etat_processus, s_objet_argument);
1157:
1158: return;
1159: }
1160:
1161: if (indicateur_48 == d_vrai)
1162: {
1163: sf(s_etat_processus, 48);
1164: }
1165: else
1166: {
1167: cf(s_etat_processus, 48);
1168: }
1169:
1170: (*s_etat_processus).instruction_courante = tampon;
1171: free(tampon_lecture);
1172: }
1173: else if ((*((struct_fichier *) (*s_objet_argument).objet)).acces
1174: == 'D')
1175: {
1176: }
1177: else
1178: {
1179: }
1180: }
1181: else if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire
1182: == 'Y')
1183: {
1184: /*
1185: * Fichiers non formatés
1186: */
1187: }
1188: else
1189: {
1190: /*
1191: * Fichiers de type FLOW
1192: */
1193: }
1194: }
1195: else if ((*s_objet_argument).type == SCK)
1196: {
1197: /*
1198: * Vérification de l'autorisation de lecture
1199: */
1200:
1201: if ((*((struct_socket *) (*s_objet_argument).objet)).protection == 'W')
1202: {
1203: liberation(s_etat_processus, s_objet_argument);
1204:
1205: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1206: return;
1207: }
1208:
1209: /*
1210: * Vérification de l'écoute de la socket si celle-ci est connectée
1211: */
1212:
1213: if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type,
1214: "STREAM") == 0) || (strcmp((*((struct_socket *)
1215: (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") == 0))
1216: {
1217: if ((*((struct_socket *) (*s_objet_argument).objet))
1218: .socket_en_ecoute == 'Y')
1219: {
1220: liberation(s_etat_processus, s_objet_argument);
1221:
1222: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
1223: return;
1224: }
1225: }
1226:
1227: if ((*((struct_socket *) (*s_objet_argument).objet)).binaire == 'N')
1228: { // Socket formatée
1229: longueur_questure = 256;
1230:
1231: do
1232: {
1233: if ((tampon_lecture = malloc((longueur_questure + 1) *
1234: sizeof(unsigned char))) == NULL)
1235: {
1236: (*s_etat_processus).erreur_systeme =
1237: d_es_allocation_memoire;
1238: return;
1239: }
1240:
1241: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1242: {
1243: (*s_etat_processus).erreur_systeme = d_es_processus;
1244: return;
1245: }
1246:
1247: for(;;)
1248: {
1249: if ((*((struct_socket *) (*s_objet_argument).objet)).domaine
1250: == PF_UNIX)
1251: {
1252: longueur_adresse = sizeof(adresse_unix);
1253: longueur_effective = recvfrom((*((struct_socket *)
1254: (*s_objet_argument).objet)).socket,
1255: tampon_lecture, longueur_questure,
1256: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1257: &adresse_unix, &longueur_adresse);
1258: }
1259: else if ((*((struct_socket *) (*s_objet_argument).objet))
1260: .domaine == PF_INET)
1261: {
1262: longueur_adresse = sizeof(adresse_ipv4);
1263: longueur_effective = recvfrom((*((struct_socket *)
1264: (*s_objet_argument).objet)).socket,
1265: tampon_lecture, longueur_questure,
1266: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1267: &adresse_ipv4, &longueur_adresse);
1268: }
1269: else if ((*((struct_socket *) (*s_objet_argument).objet))
1270: .domaine == PF_INET6)
1271: {
1272: longueur_adresse = sizeof(adresse_ipv6);
1273: longueur_effective = recvfrom((*((struct_socket *)
1274: (*s_objet_argument).objet)).socket,
1275: tampon_lecture, longueur_questure,
1276: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1277: &adresse_ipv6, &longueur_adresse);
1278: }
1279: else
1280: {
1281: free(tampon_lecture);
1282: liberation(s_etat_processus, s_objet_argument);
1283:
1284: while(sem_wait(&((*s_etat_processus)
1285: .semaphore_fork)) == -1)
1286: {
1287: if (errno != EINTR)
1288: {
1289: (*s_etat_processus).erreur_systeme =
1290: d_es_processus;
1291: return;
1292: }
1293: }
1294:
1295: (*s_etat_processus).erreur_execution =
1296: d_ex_erreur_acces_fichier;
1297: return;
1298: }
1299:
1300: if (longueur_effective < 0)
1301: {
1302: nanosleep(&attente, NULL);
1303: scrutation_injection(s_etat_processus);
1304: }
1305:
1306: if (((*s_etat_processus).var_volatile_requete_arret == -1)
1307: || (longueur_effective >= 0))
1308: {
1309: break;
1310: }
1311: }
1312:
1313: while(sem_wait(&((*s_etat_processus).semaphore_fork))
1314: == -1)
1315: {
1316: if (errno != EINTR)
1317: {
1318: (*s_etat_processus).erreur_systeme = d_es_processus;
1319: return;
1320: }
1321: }
1322:
1323: if ((*s_etat_processus).var_volatile_requete_arret == -1)
1324: {
1325:
1326: /*
1327: * Si le père tue le processus courant grâce au signal
1328: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
1329: * correspond à l'utilisation de STOP sur le processus
1330: * en cours. La variable longueur_effective vaut '-1'.
1331: */
1332:
1333: free(tampon_lecture);
1334: liberation(s_etat_processus, s_objet_argument);
1335: return;
1336: }
1337:
1338: if (longueur_effective == -1)
1339: {
1340: free(tampon_lecture);
1341: liberation(s_etat_processus, s_objet_argument);
1342:
1343: (*s_etat_processus).erreur_execution =
1344: d_ex_erreur_acces_fichier;
1345: return;
1346: }
1347:
1348: position_initiale = 0;
1349: presence_indicateur = d_faux;
1350:
1351: do
1352: {
1353: if (tampon_lecture[position_initiale] == '{')
1354: {
1355: presence_indicateur = d_vrai;
1356: break;
1357: }
1358:
1359: position_initiale++;
1360: } while(position_initiale < longueur_effective);
1361:
1362:
1363: if (presence_indicateur == d_vrai)
1364: {
1365: position_finale = position_initiale + 1;
1366: presence_chaine = d_faux;
1367: presence_indicateur = d_faux;
1368: niveau = 1;
1369:
1370: while(position_finale < longueur_effective)
1371: {
1372: caractere = tampon_lecture[position_finale];
1373:
1374: if (caractere == '"')
1375: {
1376: presence_chaine = (presence_chaine == d_vrai)
1377: ? d_faux : d_vrai;
1378: }
1379: else
1380: {
1381: if (presence_chaine == d_faux)
1382: {
1383: if (caractere == '{')
1384: {
1385: niveau++;
1386: }
1387: else if (caractere == '}')
1388: {
1389: niveau--;
1390: }
1391: }
1392: }
1393:
1394: if (niveau == 0)
1395: {
1396: presence_indicateur = d_vrai;
1397: break;
1398: }
1399:
1400: position_finale++;
1401: }
1402: }
1403:
1404: if (presence_indicateur == d_faux)
1405: {
1406: if (longueur_effective < longueur_questure)
1407: {
1408: liberation(s_etat_processus, s_objet_argument);
1409: free(tampon_lecture);
1410:
1411: (*s_etat_processus).erreur_execution =
1412: d_ex_fin_de_fichier_atteinte;
1413: return;
1414: }
1415:
1416: free(tampon_lecture);
1417: longueur_questure *= 2;
1418: }
1419: } while(presence_indicateur == d_faux);
1420:
1421: tampon_lecture[++position_finale] = d_code_fin_chaine;
1422: tampon = (*s_etat_processus).instruction_courante;
1423: (*s_etat_processus).instruction_courante = &(tampon_lecture
1424: [position_initiale]);
1425:
1426: indicateur_48 = test_cfsf(s_etat_processus, 48);
1427: cf(s_etat_processus, 48);
1428:
1429: recherche_type(s_etat_processus);
1430:
1431: if ((*s_etat_processus).erreur_execution != d_ex)
1432: {
1433: (*s_etat_processus).instruction_courante = tampon;
1434: free(tampon_lecture);
1435:
1436: liberation(s_etat_processus, s_objet_argument);
1437:
1438: return;
1439: }
1440:
1441: if (indicateur_48 == d_vrai)
1442: {
1443: sf(s_etat_processus, 48);
1444: }
1445: else
1446: {
1447: cf(s_etat_processus, 48);
1448: }
1449:
1450: (*s_etat_processus).instruction_courante = tampon;
1451:
1452: /*
1453: * Création de la liste de sortie
1454: */
1455:
1456: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1457: &s_objet_type) == d_erreur)
1458: {
1459: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1460: return;
1461: }
1462:
1463: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1464: == NULL)
1465: {
1466: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1467: return;
1468: }
1469:
1470: if (((*s_objet_resultat).objet =
1471: allocation_maillon(s_etat_processus)) == NULL)
1472: {
1473: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1474: return;
1475: }
1476:
1477: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
1478: .donnee = s_objet_type;
1479:
1480: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
1481: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1482: {
1483: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1484: return;
1485: }
1486:
1487: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
1488: .suivant = NULL;
1489:
1490: if ((s_objet_adresse = allocation(s_etat_processus, LST))
1491: == NULL)
1492: {
1493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1494: return;
1495: }
1496:
1497: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
1498: .donnee = s_objet_adresse;
1499:
1500: /*
1501: * Les informations concernant la cible sont valides si
1502: * la socket est non connectée et des domaines INET ou INET6.
1503: * Dans tous les autres cas, on renvoie une liste vide.
1504: */
1505:
1506: if (((*((struct_socket *) (*s_objet_argument).objet)).domaine
1507: == PF_UNIX) || (strcmp((*((struct_socket *)
1508: (*s_objet_argument).objet)).type, "STREAM") == 0) ||
1509: (strcmp((*((struct_socket *) (*s_objet_argument).objet))
1510: .type, "SEQUENTIAL DATAGRAM") == 0))
1511: {
1512: longueur_adresse = 0;
1513: recvfrom((*((struct_socket *)
1514: (*s_objet_argument).objet)).socket, tampon_lecture,
1515: position_finale, MSG_DONTWAIT,
1516: NULL, &longueur_adresse);
1517:
1518: (*s_objet_adresse).objet = NULL;
1519: }
1520: else if ((*((struct_socket *) (*s_objet_argument).objet))
1521: .domaine == PF_INET)
1522: {
1523: longueur_adresse = sizeof(adresse_ipv4);
1524: recvfrom((*((struct_socket *)
1525: (*s_objet_argument).objet)).socket, tampon_lecture,
1526: position_finale, MSG_DONTWAIT,
1527: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
1528:
1529: if (((*s_objet_adresse).objet =
1530: allocation_maillon(s_etat_processus)) == NULL)
1531: {
1532: (*s_etat_processus).erreur_systeme =
1533: d_es_allocation_memoire;
1534: return;
1535: }
1536:
1537: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1538: .donnee = allocation(s_etat_processus, VIN)) == NULL)
1539: {
1540: (*s_etat_processus).erreur_systeme =
1541: d_es_allocation_memoire;
1542: return;
1543: }
1544:
1545: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
1546: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
1547:
1548: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
1549: (*s_objet_adresse).objet)).donnee).objet)).tableau =
1550: malloc(4 * sizeof(integer8))) == NULL)
1551: {
1552: (*s_etat_processus).erreur_systeme =
1553: d_es_allocation_memoire;
1554: return;
1555: }
1556:
1557: ((integer8 *) (*((struct_vecteur *)
1558: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1559: .objet)).donnee).objet)).tableau)[0] =
1560: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
1561: ((integer8 *) (*((struct_vecteur *)
1562: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1563: .objet)).donnee).objet)).tableau)[1] =
1564: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
1565: ((integer8 *) (*((struct_vecteur *)
1566: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1567: .objet)).donnee).objet)).tableau)[2] =
1568: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
1569: ((integer8 *) (*((struct_vecteur *)
1570: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1571: .objet)).donnee).objet)).tableau)[3] =
1572: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
1573:
1574: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1575: .suivant = allocation_maillon(s_etat_processus))
1576: == NULL)
1577: {
1578: (*s_etat_processus).erreur_systeme =
1579: d_es_allocation_memoire;
1580: return;
1581: }
1582:
1583: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1584: .suivant).donnee = allocation(s_etat_processus, INT))
1585: == NULL)
1586: {
1587: (*s_etat_processus).erreur_systeme =
1588: d_es_allocation_memoire;
1589: return;
1590: }
1591:
1592: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1593: (*s_objet_adresse) .objet)).suivant).donnee).objet)) =
1594: (integer8) ntohs(adresse_ipv4.sin_port);
1595:
1596: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1597: .suivant).suivant = NULL;
1598: }
1599: else if ((*((struct_socket *) (*s_objet_argument).objet))
1600: .domaine == PF_INET6)
1601: {
1602: longueur_adresse = sizeof(adresse_ipv6);
1603: recvfrom((*((struct_socket *)
1604: (*s_objet_argument).objet)).socket, tampon_lecture,
1605: position_finale, MSG_DONTWAIT,
1606: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
1607:
1608: if (((*s_objet_adresse).objet =
1609: allocation_maillon(s_etat_processus)) == NULL)
1610: {
1611: (*s_etat_processus).erreur_systeme =
1612: d_es_allocation_memoire;
1613: return;
1614: }
1615:
1616: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1617: .donnee = allocation(s_etat_processus, VIN)) == NULL)
1618: {
1619: (*s_etat_processus).erreur_systeme =
1620: d_es_allocation_memoire;
1621: return;
1622: }
1623:
1624: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
1625: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
1626:
1627: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
1628: (*s_objet_adresse).objet)).donnee).objet)).tableau =
1629: malloc(16 * sizeof(integer8))) == NULL)
1630: {
1631: (*s_etat_processus).erreur_systeme =
1632: d_es_allocation_memoire;
1633: return;
1634: }
1635:
1636: for(i = 0; i < 16; i++)
1637: {
1638: ((integer8 *) (*((struct_vecteur *)
1639: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1640: .objet)).donnee).objet)).tableau)[0] =
1641: adresse_ipv6.sin6_addr.s6_addr[i];
1642: }
1643:
1644: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1645: .suivant = allocation_maillon(s_etat_processus))
1646: == NULL)
1647: {
1648: (*s_etat_processus).erreur_systeme =
1649: d_es_allocation_memoire;
1650: return;
1651: }
1652:
1653: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1654: .suivant).donnee = allocation(s_etat_processus, INT))
1655: == NULL)
1656: {
1657: (*s_etat_processus).erreur_systeme =
1658: d_es_allocation_memoire;
1659: return;
1660: }
1661:
1662: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1663: (*s_objet_adresse) .objet)).suivant).donnee).objet)) =
1664: (integer8) ntohs(adresse_ipv6.sin6_port);
1665:
1666: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1667: .suivant).suivant = NULL;
1668: }
1669: else
1670: {
1671: longueur_adresse = 0;
1672: recvfrom((*((struct_socket *)
1673: (*s_objet_argument).objet)).socket, tampon_lecture,
1674: position_finale, MSG_DONTWAIT,
1675: NULL, &longueur_adresse);
1676: }
1677:
1678: free(tampon_lecture);
1679:
1680: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1681: s_objet_resultat) == d_erreur)
1682: {
1683: return;
1684: }
1685: }
1686: else
1687: {
1688: /* FLOW ou UNFORMATTED */
1689: }
1690: }
1691: else
1692: {
1693: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1694: return;
1695: }
1696:
1697: liberation(s_etat_processus, s_objet_argument);
1698:
1699: return;
1700: }
1701:
1702: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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