1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.3
4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'recv'
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_recv(struct_processus *s_etat_processus)
40: {
41: integer8 nombre_donnees;
42:
43: sig_atomic_t registre_stop;
44:
45: ssize_t longueur_ecriture;
46:
47: struct_liste_chainee *l_element_courant;
48:
49: struct_objet *s_objet_argument;
50: struct_objet *s_objet_resultat;
51:
52: struct sigaction action;
53: struct sigaction registre;
54:
55: (*s_etat_processus).erreur_execution = d_ex;
56:
57: if ((*s_etat_processus).affichage_arguments == 'Y')
58: {
59: printf("\n RECV ");
60:
61: if ((*s_etat_processus).langue == 'F')
62: {
63: printf("(réception de données d'un processus fils)\n\n");
64: }
65: else
66: {
67: printf("(data reception from child process)\n\n");
68: }
69:
70: printf(" 1: %s\n", d_PRC);
71: printf("-> 1: %s (0)\n\n", d_INT);
72:
73: printf(" 1: %s\n", d_PRC);
74: printf("-> 2: %s, %s, %s, %s, %s, %s,\n"
75: " %s, %s, %s, %s, %s,\n"
76: " %s, %s, %s, %s\n",
77: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
78: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN);
79: printf(" 1: %s (-1)\n", d_INT);
80:
81: return;
82: }
83: else if ((*s_etat_processus).test_instruction == 'Y')
84: {
85: (*s_etat_processus).nombre_arguments = -1;
86: return;
87: }
88:
89: if (test_cfsf(s_etat_processus, 31) == d_vrai)
90: {
91: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
92: {
93: return;
94: }
95: }
96:
97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
98: &s_objet_argument) == d_erreur)
99: {
100: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
101: return;
102: }
103:
104: if ((*s_objet_argument).type == PRC)
105: {
106: /*
107: * Le champ de la structure nombre_objets_dans_pipe à jour
108: * est celui présent dans *s_etat_processus et non celui
109: * de la structure présente dans la pile opérationnelle.
110: */
111:
112: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
113: {
114: (*s_etat_processus).erreur_systeme_processus_fils =
115: d_es_processus;
116: return;
117: }
118:
119: l_element_courant = (struct_liste_chainee *)
120: (*s_etat_processus).l_base_pile_processus;
121: nombre_donnees = -1;
122:
123: while(l_element_courant != NULL)
124: {
125: if ((*(*((struct_processus_fils *) (*s_objet_argument).objet))
126: .thread).processus_detache == d_vrai)
127: {
128: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
129: .donnee).objet)).thread).processus_detache == d_faux)
130: {
131: l_element_courant = (*l_element_courant).suivant;
132: continue;
133: }
134:
135: if ((*(*((struct_processus_fils *) (*s_objet_argument).objet))
136: .thread).pid == (*(*((struct_processus_fils *)
137: (*(*l_element_courant).donnee).objet)).thread).pid)
138: {
139: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
140: (*s_objet_argument).objet)).thread).mutex)) != 0)
141: {
142: (*s_etat_processus).erreur_systeme = d_es_processus;
143: return;
144: }
145:
146: nombre_donnees = (*(*((struct_processus_fils *)
147: (*(*l_element_courant).donnee).objet)).thread)
148: .nombre_objets_dans_pipe;
149:
150: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
151: (*s_objet_argument).objet)).thread).mutex)) != 0)
152: {
153: (*s_etat_processus).erreur_systeme = d_es_processus;
154: return;
155: }
156:
157: break;
158: }
159: }
160: else
161: {
162: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
163: .donnee).objet)).thread).processus_detache == d_vrai)
164: {
165: l_element_courant = (*l_element_courant).suivant;
166: continue;
167: }
168:
169: if ((pthread_equal((*(*((struct_processus_fils *)
170: (*s_objet_argument).objet)).thread).tid,
171: (*(*((struct_processus_fils *) (*(*l_element_courant)
172: .donnee).objet)).thread).tid) != 0) &&
173: ((*(*((struct_processus_fils *)
174: (*s_objet_argument).objet)).thread).pid ==
175: (*(*((struct_processus_fils *) (*(*l_element_courant)
176: .donnee).objet)).thread).pid))
177: {
178: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
179: (*s_objet_argument).objet)).thread).mutex)) != 0)
180: {
181: (*s_etat_processus).erreur_systeme = d_es_processus;
182: return;
183: }
184:
185: nombre_donnees = (*(*((struct_processus_fils *)
186: (*(*l_element_courant).donnee).objet)).thread)
187: .nombre_objets_dans_pipe;
188:
189: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
190: (*s_objet_argument).objet)).thread).mutex)) != 0)
191: {
192: (*s_etat_processus).erreur_systeme = d_es_processus;
193: return;
194: }
195:
196: break;
197: }
198: }
199:
200: l_element_courant = (*l_element_courant).suivant;
201: }
202:
203: /*
204: * 0 : aucune donnée dans le pipe du processus.
205: * -1 : processus absent de la pile
206: */
207:
208: if (nombre_donnees == -1)
209: {
210: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
211: {
212: (*s_etat_processus).erreur_systeme_processus_fils =
213: d_es_processus;
214: return;
215: }
216:
217: (*s_etat_processus).erreur_execution = d_ex_processus;
218: return;
219: }
220: else if (nombre_donnees == 0)
221: {
222: /*
223: * On empile une valeur nulle
224: */
225:
226: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
227: {
228: (*s_etat_processus).erreur_systeme_processus_fils =
229: d_es_processus;
230: return;
231: }
232:
233: if ((s_objet_resultat = allocation(s_etat_processus, INT))
234: == NULL)
235: {
236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
237: return;
238: }
239:
240: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
241:
242: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
243: s_objet_resultat) == d_erreur)
244: {
245: return;
246: }
247:
248: liberation(s_etat_processus, s_objet_argument);
249:
250: return;
251: }
252:
253: registre_stop = (*s_etat_processus)
254: .var_volatile_traitement_retarde_stop;
255: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
256:
257: if ((*s_etat_processus).profilage == d_vrai)
258: {
259: profilage(s_etat_processus, "Interprocess or interthread "
260: "communications (RECV)");
261:
262: if ((*s_etat_processus).erreur_systeme != d_es)
263: {
264: return;
265: }
266: }
267:
268: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
269: {
270: (*s_etat_processus).erreur_systeme = d_es_processus;
271: return;
272: }
273:
274: if ((s_objet_resultat = lecture_pipe(s_etat_processus,
275: (*(*((struct_processus_fils *) (*s_objet_argument).objet))
276: .thread).pipe_objets[0])) == NULL)
277: {
278: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
279: {
280: if (errno != EINTR)
281: {
282: (*s_etat_processus).erreur_systeme = d_es_processus;
283: return;
284: }
285: }
286:
287: if (registre_stop == 0)
288: {
289: if ((*s_etat_processus).var_volatile_traitement_retarde_stop
290: == -1)
291: {
292: (*s_etat_processus).var_volatile_requete_arret = -1;
293: }
294:
295: (*s_etat_processus).var_volatile_traitement_retarde_stop
296: = registre_stop;
297: }
298:
299: if ((*s_etat_processus).profilage == d_vrai)
300: {
301: profilage(s_etat_processus, NULL);
302: }
303:
304: pthread_mutex_unlock(&((*s_etat_processus).mutex));
305: return;
306: }
307:
308: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
309: {
310: if (errno != EINTR)
311: {
312: (*s_etat_processus).erreur_systeme = d_es_processus;
313: return;
314: }
315: }
316:
317: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
318: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
319: {
320: (*s_etat_processus).erreur_systeme = d_es_processus;
321: return;
322: }
323:
324: (*(*((struct_processus_fils *) (*(*l_element_courant).donnee).objet))
325: .thread).nombre_objets_dans_pipe--;
326:
327: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
328: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
329: {
330: (*s_etat_processus).erreur_systeme = d_es_processus;
331: return;
332: }
333:
334: action.sa_handler = SIG_IGN;
335: action.sa_flags = SA_ONSTACK;
336:
337: if (sigaction(SIGPIPE, &action, ®istre) != 0)
338: {
339: if (registre_stop == 0)
340: {
341: if ((*s_etat_processus).var_volatile_traitement_retarde_stop
342: == -1)
343: {
344: (*s_etat_processus).var_volatile_requete_arret = -1;
345: }
346:
347: (*s_etat_processus).var_volatile_traitement_retarde_stop
348: = registre_stop;
349: }
350:
351: pthread_mutex_unlock(&((*s_etat_processus).mutex));
352:
353: if ((*s_etat_processus).profilage == d_vrai)
354: {
355: profilage(s_etat_processus, NULL);
356: }
357:
358: (*s_etat_processus).erreur_systeme = d_es_signal;
359: return;
360: }
361:
362: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
363: {
364: (*s_etat_processus).erreur_systeme = d_es_processus;
365: return;
366: }
367:
368: while((longueur_ecriture = write_atomic(s_etat_processus,
369: (*(*((struct_processus_fils *) (*(*l_element_courant)
370: .donnee).objet)).thread).pipe_nombre_injections[1], "+",
371: sizeof(unsigned char))) != sizeof(unsigned char))
372: {
373: if (longueur_ecriture == -1)
374: {
375: // Le processus n'existe plus.
376: break;
377: }
378: }
379:
380: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
381: {
382: if (errno != EINTR)
383: {
384: (*s_etat_processus).erreur_systeme = d_es_processus;
385: return;
386: }
387: }
388:
389: if ((*s_etat_processus).profilage == d_vrai)
390: {
391: profilage(s_etat_processus, NULL);
392: }
393:
394: if (registre_stop == 0)
395: {
396: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
397: {
398: (*s_etat_processus).var_volatile_requete_arret = -1;
399: }
400:
401: (*s_etat_processus).var_volatile_traitement_retarde_stop
402: = registre_stop;
403: }
404:
405: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
406: {
407: pthread_mutex_unlock(&((*s_etat_processus).mutex));
408:
409: (*s_etat_processus).erreur_systeme = d_es_signal;
410: return;
411: }
412:
413: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
414: {
415: (*s_etat_processus).erreur_systeme_processus_fils =
416: d_es_processus;
417: }
418: }
419: else
420: {
421: liberation(s_etat_processus, s_objet_argument);
422:
423: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
424: return;
425: }
426:
427: liberation(s_etat_processus, s_objet_argument);
428:
429: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
430: s_objet_resultat) == d_erreur)
431: {
432: return;
433: }
434:
435: /*
436: * On rajoute "-1" dans la pile.
437: */
438:
439: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
440: {
441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
442: return;
443: }
444:
445: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
446:
447: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
448: s_objet_resultat) == d_erreur)
449: {
450: return;
451: }
452:
453: return;
454: }
455:
456:
457: /*
458: ================================================================================
459: Fonction 'row->'
460: ================================================================================
461: Entrées :
462: --------------------------------------------------------------------------------
463: Sorties :
464: --------------------------------------------------------------------------------
465: Effets de bord : néant
466: ================================================================================
467: */
468:
469: void
470: instruction_row_fleche(struct_processus *s_etat_processus)
471: {
472: struct_objet *s_objet;
473: struct_objet *s_objet_elementaire;
474:
475: unsigned long i;
476: unsigned long j;
477:
478: (*s_etat_processus).erreur_execution = d_ex;
479:
480: if ((*s_etat_processus).affichage_arguments == 'Y')
481: {
482: printf("\n ROW-> ");
483:
484: if ((*s_etat_processus).langue == 'F')
485: {
486: printf("(extraction des lignes d'une matrice)\n\n");
487: }
488: else
489: {
490: printf("(extract matrix rows)\n\n");
491: }
492:
493: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
494: printf("-> n: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
495: printf(" ...\n");
496: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
497: printf(" 1: %s\n", d_INT);
498:
499: return;
500: }
501: else if ((*s_etat_processus).test_instruction == 'Y')
502: {
503: (*s_etat_processus).nombre_arguments = -1;
504: return;
505: }
506:
507: if (test_cfsf(s_etat_processus, 31) == d_vrai)
508: {
509: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
510: {
511: return;
512: }
513: }
514:
515: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
516: &s_objet) == d_erreur)
517: {
518: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
519: return;
520: }
521:
522: if ((*s_objet).type == MIN)
523: {
524: for(i = 0; i < (*((struct_matrice *)
525: (*s_objet).objet)).nombre_lignes; i++)
526: {
527: if ((s_objet_elementaire = allocation(s_etat_processus, MIN))
528: == NULL)
529: {
530: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
531: return;
532: }
533:
534: (*((struct_matrice *) (*s_objet_elementaire).objet))
535: .nombre_lignes = 1;
536: (*((struct_matrice *) (*s_objet_elementaire).objet))
537: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet))
538: .nombre_colonnes;
539:
540: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
541: malloc(sizeof(integer8 *))) == NULL)
542: {
543: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
544: return;
545: }
546:
547: if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
548: .objet)).tableau)[0] = malloc((*((struct_matrice *)
549: (*s_objet_elementaire).objet)).nombre_colonnes *
550: sizeof(integer8))) == NULL)
551: {
552: (*s_etat_processus).erreur_systeme =
553: d_es_allocation_memoire;
554: return;
555: }
556:
557: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet))
558: .nombre_colonnes; j++)
559: {
560: ((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
561: .objet)).tableau)[0][j] =
562: ((integer8 **) (*((struct_matrice *)
563: (*s_objet).objet)).tableau)[i][j];
564: }
565:
566: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
567: s_objet_elementaire) == d_erreur)
568: {
569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
570: return;
571: }
572: }
573: }
574: else if ((*s_objet).type == MRL)
575: {
576: for(i = 0; i < (*((struct_matrice *)
577: (*s_objet).objet)).nombre_lignes; i++)
578: {
579: if ((s_objet_elementaire = allocation(s_etat_processus, MRL))
580: == NULL)
581: {
582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
583: return;
584: }
585:
586: (*((struct_matrice *) (*s_objet_elementaire).objet))
587: .nombre_lignes = 1;
588: (*((struct_matrice *) (*s_objet_elementaire).objet))
589: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet))
590: .nombre_colonnes;
591:
592: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
593: malloc(sizeof(real8 *))) == NULL)
594: {
595: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
596: return;
597: }
598:
599: if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
600: .objet)).tableau)[0] = malloc((*((struct_matrice *)
601: (*s_objet_elementaire).objet)).nombre_colonnes *
602: sizeof(real8))) == NULL)
603: {
604: (*s_etat_processus).erreur_systeme =
605: d_es_allocation_memoire;
606: return;
607: }
608:
609: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet))
610: .nombre_colonnes; j++)
611: {
612: ((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
613: .objet)).tableau)[0][j] =
614: ((real8 **) (*((struct_matrice *)
615: (*s_objet).objet)).tableau)[i][j];
616: }
617:
618: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
619: s_objet_elementaire) == d_erreur)
620: {
621: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
622: return;
623: }
624: }
625: }
626: else if ((*s_objet).type == MCX)
627: {
628: for(i = 0; i < (*((struct_matrice *)
629: (*s_objet).objet)).nombre_lignes; i++)
630: {
631: if ((s_objet_elementaire = allocation(s_etat_processus, MCX))
632: == NULL)
633: {
634: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
635: return;
636: }
637:
638: (*((struct_matrice *) (*s_objet_elementaire).objet))
639: .nombre_lignes = 1;
640: (*((struct_matrice *) (*s_objet_elementaire).objet))
641: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet))
642: .nombre_colonnes;
643:
644: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
645: malloc(sizeof(complex16 *))) == NULL)
646: {
647: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
648: return;
649: }
650:
651: if ((((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
652: .objet)).tableau)[0] = malloc((*((struct_matrice *)
653: (*s_objet_elementaire).objet)).nombre_colonnes *
654: sizeof(complex16))) == NULL)
655: {
656: (*s_etat_processus).erreur_systeme =
657: d_es_allocation_memoire;
658: return;
659: }
660:
661: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet))
662: .nombre_colonnes; j++)
663: {
664: ((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
665: .objet)).tableau)[0][j].partie_reelle =
666: ((complex16 **) (*((struct_matrice *)
667: (*s_objet).objet)).tableau)[i][j].partie_reelle;
668: ((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
669: .objet)).tableau)[0][j].partie_imaginaire =
670: ((complex16 **) (*((struct_matrice *)
671: (*s_objet).objet)).tableau)[i][j].partie_imaginaire;
672: }
673:
674: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
675: s_objet_elementaire) == d_erreur)
676: {
677: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
678: return;
679: }
680: }
681: }
682: else
683: {
684: liberation(s_etat_processus, s_objet);
685:
686: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
687: return;
688: }
689:
690: if ((s_objet_elementaire = allocation(s_etat_processus, INT)) == NULL)
691: {
692: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
693: return;
694: }
695:
696: (*((integer8 *) (*s_objet_elementaire).objet)) =
697: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
698:
699: liberation(s_etat_processus, s_objet);
700:
701: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
702: s_objet_elementaire) == d_erreur)
703: {
704: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
705: return;
706: }
707:
708: return;
709: }
710:
711:
712: /*
713: ================================================================================
714: Fonction 'rdate'
715: ================================================================================
716: Entrées : pointeur sur une structure struct_processus
717: --------------------------------------------------------------------------------
718: Sorties :
719: --------------------------------------------------------------------------------
720: Effets de bord : néant
721: ================================================================================
722: */
723:
724: void
725: instruction_rdate(struct_processus *s_etat_processus)
726: {
727: struct_objet *s_objet;
728: struct_objet *s_objet_argument;
729:
730: struct timeval horodatage;
731:
732: (*s_etat_processus).erreur_execution = d_ex;
733:
734: if ((*s_etat_processus).affichage_arguments == 'Y')
735: {
736: printf("\n RDATE ");
737:
738: if ((*s_etat_processus).langue == 'F')
739: {
740: printf("(information sur la date et l'heure avec offset)\n\n");
741: }
742: else
743: {
744: printf("(date and time with offset)\n\n");
745: }
746:
747: printf(" 1: %s\n", d_INT);
748: printf("-> 1: %s\n", d_LST);
749:
750: return;
751: }
752: else if ((*s_etat_processus).test_instruction == 'Y')
753: {
754: (*s_etat_processus).nombre_arguments = 1;
755: return;
756: }
757:
758: if (test_cfsf(s_etat_processus, 31) == d_vrai)
759: {
760: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
761: {
762: return;
763: }
764: }
765:
766: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
767: &s_objet_argument) == d_erreur)
768: {
769: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
770: return;
771: }
772:
773: if ((*s_objet_argument).type == INT)
774: {
775: gettimeofday(&horodatage, NULL);
776: horodatage.tv_sec += (*((integer8 *) (*s_objet_argument).objet));
777:
778: if (horodatage.tv_sec < 0)
779: {
780: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
781:
782: liberation(s_etat_processus, s_objet_argument);
783: return;
784: }
785:
786: if ((s_objet = formateur_date(s_etat_processus, &horodatage)) == NULL)
787: {
788: liberation(s_etat_processus, s_objet_argument);
789: return;
790: }
791:
792: liberation(s_etat_processus, s_objet_argument);
793: }
794: else
795: {
796: liberation(s_etat_processus, s_objet_argument);
797:
798: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
799: return;
800: }
801:
802: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
803: s_objet) == d_erreur)
804: {
805: return;
806: }
807:
808: return;
809: }
810:
811:
812: /*
813: ================================================================================
814: Fonction 'rclswi'
815: ================================================================================
816: Entrées : pointeur sur une structure struct_processus
817: --------------------------------------------------------------------------------
818: Sorties :
819: --------------------------------------------------------------------------------
820: Effets de bord : néant
821: ================================================================================
822: */
823:
824: void
825: instruction_rclswi(struct_processus *s_etat_processus)
826: {
827: integer8 interruption;
828:
829: struct_objet *s_objet_argument;
830: struct_objet *s_objet_resultat;
831:
832: (*s_etat_processus).erreur_execution = d_ex;
833:
834: if ((*s_etat_processus).affichage_arguments == 'Y')
835: {
836: printf("\n RCLSWI ");
837:
838: if ((*s_etat_processus).langue == 'F')
839: {
840: printf("(rappel d'une interruption logicielle)\n\n");
841: }
842: else
843: {
844: printf("(recall software interrupt)\n\n");
845: }
846:
847: printf(" 1: %s\n", d_INT);
848: printf("-> 1: %s, %s\n", d_NOM, d_RPN);
849:
850: return;
851: }
852: else if ((*s_etat_processus).test_instruction == 'Y')
853: {
854: (*s_etat_processus).nombre_arguments = -1;
855: return;
856: }
857:
858: if (test_cfsf(s_etat_processus, 31) == d_vrai)
859: {
860: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
861: {
862: return;
863: }
864: }
865:
866: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
867: &s_objet_argument) == d_erreur)
868: {
869: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
870: return;
871: }
872:
873: if ((*s_objet_argument).type == INT)
874: {
875: interruption = (*((integer8 *) (*s_objet_argument).objet));
876:
877: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
878: {
879: liberation(s_etat_processus, s_objet_argument);
880:
881: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
882: return;
883: }
884:
885: if ((*s_etat_processus).corps_interruptions[interruption - 1] == NULL)
886: {
887: liberation(s_etat_processus, s_objet_argument);
888:
889: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
890: return;
891: }
892:
893: if ((s_objet_resultat = copie_objet(s_etat_processus,
894: (*s_etat_processus).corps_interruptions[interruption - 1], 'P'))
895: == NULL)
896: {
897: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
898: return;
899: }
900: }
901: else
902: {
903: liberation(s_etat_processus, s_objet_argument);
904:
905: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
906: return;
907: }
908:
909: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
910: s_objet_resultat) == d_erreur)
911: {
912: return;
913: }
914:
915: return;
916: }
917:
918:
919: /*
920: ================================================================================
921: Fonction 'revlist'
922: ================================================================================
923: Entrées : pointeur sur une structure struct_processus
924: --------------------------------------------------------------------------------
925: Sorties :
926: --------------------------------------------------------------------------------
927: Effets de bord : néant
928: ================================================================================
929: */
930:
931: void
932: instruction_revlist(struct_processus *s_etat_processus)
933: {
934: struct_liste_chainee *l_ancienne_base;
935: struct_liste_chainee *l_nouvelle_base;
936:
937: struct_objet *s_objet_argument;
938: struct_objet *s_objet_intermediaire;
939: struct_objet *s_objet_resultat;
940:
941: (*s_etat_processus).erreur_execution = d_ex;
942:
943: if ((*s_etat_processus).affichage_arguments == 'Y')
944: {
945: printf("\n REVLIST ");
946:
947: if ((*s_etat_processus).langue == 'F')
948: {
949: printf("(inverse les éléments d'une liste)\n\n");
950: }
951: else
952: {
953: printf("(inverts list elements)\n\n");
954: }
955:
956: printf(" 1: %s\n", d_LST);
957: printf("-> 1: %s\n", d_LST);
958:
959: return;
960: }
961: else if ((*s_etat_processus).test_instruction == 'Y')
962: {
963: (*s_etat_processus).nombre_arguments = -1;
964: return;
965: }
966:
967: if (test_cfsf(s_etat_processus, 31) == d_vrai)
968: {
969: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
970: {
971: return;
972: }
973: }
974:
975: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
976: &s_objet_argument) == d_erreur)
977: {
978: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
979: return;
980: }
981:
982: if ((*s_objet_argument).type == LST)
983: {
984: if ((s_objet_resultat = copie_objet(s_etat_processus,
985: s_objet_argument, 'N')) == NULL)
986: {
987: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
988: return;
989: }
990:
991: l_ancienne_base = (*s_objet_resultat).objet;
992: l_nouvelle_base = NULL;
993:
994: while(l_ancienne_base != NULL)
995: {
996: if (depilement(s_etat_processus, &l_ancienne_base,
997: &s_objet_intermediaire) == d_erreur)
998: {
999: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
1000: return;
1001: }
1002:
1003: if (empilement(s_etat_processus, &l_nouvelle_base,
1004: s_objet_intermediaire) == d_erreur)
1005: {
1006: return;
1007: }
1008: }
1009:
1010: (*s_objet_resultat).objet = l_nouvelle_base;
1011: }
1012: else
1013: {
1014: liberation(s_etat_processus, s_objet_argument);
1015:
1016: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1017: return;
1018: }
1019:
1020: liberation(s_etat_processus, s_objet_argument);
1021:
1022: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1023: s_objet_resultat) == d_erreur)
1024: {
1025: return;
1026: }
1027:
1028: return;
1029: }
1030:
1031:
1032: /*
1033: ================================================================================
1034: Fonction 'rstop'
1035: ================================================================================
1036: Entrées :
1037: --------------------------------------------------------------------------------
1038: Sorties :
1039: --------------------------------------------------------------------------------
1040: Effets de bord : néant
1041: ================================================================================
1042: */
1043:
1044: void
1045: instruction_rstop(struct_processus *s_etat_processus)
1046: {
1047: (*s_etat_processus).erreur_execution = d_ex;
1048:
1049: if ((*s_etat_processus).affichage_arguments == 'Y')
1050: {
1051: printf("\n RSTOP ");
1052:
1053: if ((*s_etat_processus).langue == 'F')
1054: {
1055: printf("(libère le signal stop)\n\n");
1056: printf(" Aucun argument\n");
1057: }
1058: else
1059: {
1060: printf("(release stop signal)\n\n");
1061: printf(" No argument\n");
1062: }
1063:
1064: return;
1065: }
1066: else if ((*s_etat_processus).test_instruction == 'Y')
1067: {
1068: (*s_etat_processus).nombre_arguments = -1;
1069: return;
1070: }
1071:
1072: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1073: {
1074: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1075: {
1076: return;
1077: }
1078: }
1079:
1080: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
1081: {
1082: (*s_etat_processus).erreur_execution = d_ex_stop;
1083: return;
1084: }
1085:
1086: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
1087: {
1088: (*s_etat_processus).var_volatile_requete_arret = -1;
1089: }
1090:
1091: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
1092:
1093: return;
1094: }
1095:
1096:
1097: /*
1098: ================================================================================
1099: fonction 'rfuse'
1100: ================================================================================
1101: entrées :
1102: --------------------------------------------------------------------------------
1103: sorties :
1104: --------------------------------------------------------------------------------
1105: effets de bord : néant
1106: ================================================================================
1107: */
1108:
1109: void
1110: instruction_rfuse(struct_processus *s_etat_processus)
1111: {
1112: struct_objet *s_objet_resultat;
1113:
1114: (*s_etat_processus).erreur_execution = d_ex;
1115:
1116: if ((*s_etat_processus).affichage_arguments == 'Y')
1117: {
1118: printf("\n RFUSE ");
1119:
1120: if ((*s_etat_processus).langue == 'F')
1121: {
1122: printf("(valeur courante du fusible)\n\n");
1123: }
1124: else
1125: {
1126: printf("(remaining fuse value)\n\n");
1127: }
1128:
1129: printf("-> 1: %s\n", d_REL);
1130: return;
1131: }
1132: else if ((*s_etat_processus).test_instruction == 'Y')
1133: {
1134: (*s_etat_processus).nombre_arguments = -1;
1135: return;
1136: }
1137:
1138: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1139: {
1140: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1141: {
1142: return;
1143: }
1144: }
1145:
1146: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1147: {
1148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1149: return;
1150: }
1151:
1152: (*((real8 *) (*s_objet_resultat).objet)) =
1153: (*s_etat_processus).temps_maximal_cpu;
1154:
1155: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1156: s_objet_resultat) == d_erreur)
1157: {
1158: return;
1159: }
1160:
1161: return;
1162: }
1163:
1164:
1165: /*
1166: ================================================================================
1167: fonction 'rdgn'
1168: ================================================================================
1169: entrées :
1170: --------------------------------------------------------------------------------
1171: sorties :
1172: --------------------------------------------------------------------------------
1173: effets de bord : néant
1174: ================================================================================
1175: */
1176:
1177: void
1178: instruction_rdgn(struct_processus *s_etat_processus)
1179: {
1180: const gsl_rng_type **type_courant;
1181: const gsl_rng_type **types;
1182:
1183: const unsigned char *message = "UNINITIALIZED RANDOM GENERATOR";
1184:
1185: long dernier;
1186: long i;
1187: long j;
1188: long premier;
1189:
1190: struct_objet *s_objet_argument;
1191: struct_objet *s_objet_resultat;
1192:
1193: unsigned char *pointeur;
1194: unsigned char *requete;
1195: unsigned char **types_generateurs;
1196:
1197: unsigned long nombre_types;
1198:
1199: (*s_etat_processus).erreur_execution = d_ex;
1200:
1201: types = gsl_rng_types_setup();
1202:
1203: if ((*s_etat_processus).affichage_arguments == 'Y')
1204: {
1205: printf("\n RDGN ");
1206:
1207: if ((*s_etat_processus).langue == 'F')
1208: {
1209: printf("(choix du générateur de nombres aléatoires)\n\n");
1210: }
1211: else
1212: {
1213: printf("(random number generator specification)\n\n");
1214: }
1215:
1216: printf(" 1: %s\n\n", d_CHN);
1217:
1218: printf(" 1: \"QUERY\"\n");
1219: printf("-> 1: %s\n\n", d_CHN);
1220:
1221: if ((*s_etat_processus).langue == 'F')
1222: {
1223: printf(" Générateurs disponibles :\n\n");
1224: }
1225: else
1226: {
1227: printf(" Available generators:\n\n");
1228: }
1229:
1230: for(nombre_types = 0, type_courant = types;
1231: (*type_courant) != NULL; type_courant++, nombre_types++);
1232:
1233: if ((types_generateurs = malloc(nombre_types * sizeof(unsigned char *)))
1234: == NULL)
1235: {
1236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1237: return;
1238: }
1239:
1240: for(i = 0, type_courant = types; (*type_courant) != NULL;
1241: type_courant++, i++)
1242: {
1243: if ((types_generateurs[i] = malloc((strlen((**type_courant).name)
1244: + 1) * sizeof(unsigned char))) == NULL)
1245: {
1246: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1247: return;
1248: }
1249:
1250: strcpy(types_generateurs[i], (**type_courant).name);
1251: pointeur = types_generateurs[i];
1252:
1253: while((*pointeur) != d_code_fin_chaine)
1254: {
1255: if ((*pointeur) == '-')
1256: {
1257: (*pointeur) = '_';
1258: }
1259:
1260: pointeur++;
1261: }
1262: }
1263:
1264: // Tri des types de générateurs (tri shaker)
1265:
1266: premier = 1;
1267: dernier = nombre_types - 2;
1268:
1269: while((dernier - premier) >= 2)
1270: {
1271: for(j = 2, i = premier; i <= dernier; i++)
1272: {
1273: if (strcmp(types_generateurs[i], types_generateurs[i + 1]) > 0)
1274: {
1275: swap(&(types_generateurs[i]),
1276: &(types_generateurs[i + 1]),
1277: sizeof(unsigned char *));
1278: j = i;
1279: }
1280: }
1281:
1282: dernier = j;
1283: i = nombre_types - 2;
1284:
1285: for(i = dernier; i >= premier; i--)
1286: {
1287: if (strcmp(types_generateurs[i - 1], types_generateurs[i]) > 0)
1288: {
1289: swap(&(types_generateurs[i - 1]),
1290: &(types_generateurs[i]),
1291: sizeof(unsigned char *));
1292: j = i;
1293: }
1294: }
1295:
1296: premier = j;
1297: }
1298:
1299: for(i = 0; i < (long) nombre_types; i++)
1300: {
1301: printf(" - %s\n", types_generateurs[i]);
1302: free(types_generateurs[i]);
1303: }
1304:
1305: free(types_generateurs);
1306: return;
1307: }
1308: else if ((*s_etat_processus).test_instruction == 'Y')
1309: {
1310: (*s_etat_processus).nombre_arguments = -1;
1311: return;
1312: }
1313:
1314: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1315: {
1316: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1317: {
1318: return;
1319: }
1320: }
1321:
1322: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1323: &s_objet_argument) == d_erreur)
1324: {
1325: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1326: return;
1327: }
1328:
1329: if ((*s_objet_argument).type == CHN)
1330: {
1331: if ((requete = conversion_majuscule((unsigned char *)
1332: (*s_objet_argument).objet)) == NULL)
1333: {
1334: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1335: return;
1336: }
1337:
1338: if (strcmp(requete, "QUERY") == 0)
1339: {
1340: /*
1341: * Récupération du type du générateur
1342: */
1343:
1344: free(requete);
1345:
1346: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1347: {
1348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1349: return;
1350: }
1351:
1352: if ((*s_etat_processus).type_generateur_aleatoire == NULL)
1353: {
1354: if (((*s_objet_resultat).objet = malloc((strlen(message) + 1) *
1355: sizeof(unsigned char))) == NULL)
1356: {
1357: (*s_etat_processus).erreur_systeme =
1358: d_es_allocation_memoire;
1359: return;
1360: }
1361:
1362: strcpy((unsigned char *) (*s_objet_resultat).objet, message);
1363: }
1364: else
1365: {
1366: if (((*s_objet_resultat).objet = conversion_majuscule(
1367: (unsigned char *) gsl_rng_name(
1368: (*s_etat_processus).generateur_aleatoire))) == NULL)
1369: {
1370: (*s_etat_processus).erreur_systeme =
1371: d_es_allocation_memoire;
1372: return;
1373: }
1374: }
1375:
1376: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1377: s_objet_resultat) == d_erreur)
1378: {
1379: return;
1380: }
1381: }
1382: else
1383: {
1384: /*
1385: * Affectation d'un nouveau type de générateur
1386: */
1387:
1388: # include "generateurs.c"
1389:
1390: free(requete);
1391:
1392: if ((*s_etat_processus).generateur_aleatoire != NULL)
1393: {
1394: liberation_generateur_aleatoire(s_etat_processus);
1395: }
1396:
1397: initialisation_generateur_aleatoire(s_etat_processus, d_vrai, 0);
1398: }
1399: }
1400: else
1401: {
1402: liberation(s_etat_processus, s_objet_argument);
1403:
1404: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1405: return;
1406: }
1407:
1408: liberation(s_etat_processus, s_objet_argument);
1409:
1410: return;
1411: }
1412:
1413:
1414: /*
1415: ================================================================================
1416: fonction 'rank'
1417: ================================================================================
1418: entrées :
1419: --------------------------------------------------------------------------------
1420: sorties :
1421: --------------------------------------------------------------------------------
1422: effets de bord : néant
1423: ================================================================================
1424: */
1425:
1426: void
1427: instruction_rank(struct_processus *s_etat_processus)
1428: {
1429: struct_objet *s_objet_argument;
1430: struct_objet *s_objet_resultat;
1431:
1432: (*s_etat_processus).erreur_execution = d_ex;
1433:
1434: if ((*s_etat_processus).affichage_arguments == 'Y')
1435: {
1436: printf("\n RANK ");
1437:
1438: if ((*s_etat_processus).langue == 'F')
1439: {
1440: printf("(rang de la matrice)\n\n");
1441: }
1442: else
1443: {
1444: printf("(matrix rank)\n\n");
1445: }
1446:
1447: printf(" 1: %s, %s, %s\n", d_MIN, d_REL, d_MCX);
1448: printf("-> 1: %s\n", d_INT);
1449:
1450: return;
1451: }
1452: else if ((*s_etat_processus).test_instruction == 'Y')
1453: {
1454: (*s_etat_processus).nombre_arguments = -1;
1455: return;
1456: }
1457:
1458: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1459: {
1460: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1461: {
1462: return;
1463: }
1464: }
1465:
1466: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1467: &s_objet_argument) == d_erreur)
1468: {
1469: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1470: return;
1471: }
1472:
1473: if (((*s_objet_argument).type == MIN) ||
1474: ((*s_objet_argument).type == MRL) ||
1475: ((*s_objet_argument).type == MCX))
1476: {
1477: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1478: {
1479: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1480: return;
1481: }
1482:
1483: rang(s_etat_processus, (*s_objet_argument).objet,
1484: (*s_objet_resultat).objet);
1485:
1486: if ((*s_etat_processus).erreur_systeme != d_es)
1487: {
1488: return;
1489: }
1490:
1491: if (((*s_etat_processus).erreur_execution != d_ex) ||
1492: ((*s_etat_processus).exception != d_ep))
1493: {
1494: liberation(s_etat_processus, s_objet_argument);
1495: liberation(s_etat_processus, s_objet_resultat);
1496: return;
1497: }
1498: }
1499: else
1500: {
1501: liberation(s_etat_processus, s_objet_argument);
1502:
1503: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1504: return;
1505: }
1506:
1507: liberation(s_etat_processus, s_objet_argument);
1508:
1509: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1510: s_objet_resultat) == d_erreur)
1511: {
1512: return;
1513: }
1514:
1515: return;
1516: }
1517:
1518:
1519: /*
1520: ================================================================================
1521: Fonction 'recode'
1522: ================================================================================
1523: Entrées :
1524: --------------------------------------------------------------------------------
1525: Sorties :
1526: --------------------------------------------------------------------------------
1527: Effets de bord : néant
1528: ================================================================================
1529: */
1530:
1531: void
1532: instruction_recode(struct_processus *s_etat_processus)
1533: {
1534: struct_objet *s_objet_argument_1;
1535: struct_objet *s_objet_argument_2;
1536: struct_objet *s_objet_argument_3;
1537: struct_objet *s_objet_resultat;
1538:
1539: unsigned char *encodage_destination;
1540: unsigned char *encodage_source;
1541: unsigned char *tampon;
1542:
1543: (*s_etat_processus).erreur_execution = d_ex;
1544:
1545: if ((*s_etat_processus).affichage_arguments == 'Y')
1546: {
1547: printf("\n RECODE ");
1548:
1549: if ((*s_etat_processus).langue == 'F')
1550: {
1551: printf("(conversion d'encodage d'une chaîne de caractères)\n\n");
1552: }
1553: else
1554: {
1555: printf("(string recodage)\n\n");
1556: }
1557:
1558: printf(" 3: %s\n", d_CHN);
1559: printf(" 2: %s\n", d_CHN);
1560: printf(" 1: %s\n", d_CHN);
1561: printf("-> 1: %s\n\n", d_CHN);
1562:
1563: if ((*s_etat_processus).langue == 'F')
1564: {
1565: printf(" Utilisation :\n\n");
1566: }
1567: else
1568: {
1569: printf(" Usage:\n\n");
1570: }
1571:
1572: printf(" \"string\" \"ISO8859-1\" \"UTF-8\" recode\n");
1573: printf(" \"string\" \"ISO8859-1\" \"UTF-8//TRANSLIT\" recode\n");
1574: printf(" \"string\" \"ISO8859-1\" \"UTF-8//IGNORE\" recode\n");
1575: return;
1576: }
1577: else if ((*s_etat_processus).test_instruction == 'Y')
1578: {
1579: (*s_etat_processus).nombre_arguments = -1;
1580: return;
1581: }
1582:
1583: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1584: {
1585: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1586: {
1587: return;
1588: }
1589: }
1590:
1591: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1592: &s_objet_argument_1) == d_erreur)
1593: {
1594: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1595: return;
1596: }
1597:
1598: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1599: &s_objet_argument_2) == d_erreur)
1600: {
1601: liberation(s_etat_processus, s_objet_argument_1);
1602:
1603: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1604: return;
1605: }
1606:
1607: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1608: &s_objet_argument_3) == d_erreur)
1609: {
1610: liberation(s_etat_processus, s_objet_argument_1);
1611: liberation(s_etat_processus, s_objet_argument_2);
1612:
1613: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1614: return;
1615: }
1616:
1617: if (((*s_objet_argument_1).type == CHN) &&
1618: ((*s_objet_argument_2).type == CHN) &&
1619: ((*s_objet_argument_3).type == CHN))
1620: {
1621: if ((encodage_source = conversion_majuscule((unsigned char *)
1622: (*s_objet_argument_2).objet)) == NULL)
1623: {
1624: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1625: return;
1626: }
1627:
1628: if ((encodage_destination = conversion_majuscule((unsigned char *)
1629: (*s_objet_argument_1).objet)) == NULL)
1630: {
1631: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1632: return;
1633: }
1634:
1635: tampon = reencodage(s_etat_processus,
1636: (*s_objet_argument_3).objet, encodage_source,
1637: encodage_destination);
1638:
1639: free(encodage_destination);
1640: free(encodage_source);
1641:
1642: if (tampon == NULL)
1643: {
1644: liberation(s_etat_processus, s_objet_argument_1);
1645: liberation(s_etat_processus, s_objet_argument_2);
1646: liberation(s_etat_processus, s_objet_argument_3);
1647: return;
1648: }
1649:
1650: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1651: {
1652: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1653: return;
1654: }
1655:
1656: (*s_objet_resultat).objet = tampon;
1657: }
1658: else
1659: {
1660: liberation(s_etat_processus, s_objet_argument_1);
1661: liberation(s_etat_processus, s_objet_argument_2);
1662: liberation(s_etat_processus, s_objet_argument_3);
1663:
1664: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1665: return;
1666: }
1667:
1668: liberation(s_etat_processus, s_objet_argument_1);
1669: liberation(s_etat_processus, s_objet_argument_2);
1670: liberation(s_etat_processus, s_objet_argument_3);
1671:
1672: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1673: s_objet_resultat) == d_erreur)
1674: {
1675: return;
1676: }
1677:
1678: return;
1679: }
1680:
1681:
1682: /*
1683: ================================================================================
1684: Fonction 'repl'
1685: ================================================================================
1686: Entrées :
1687: --------------------------------------------------------------------------------
1688: Sorties :
1689: --------------------------------------------------------------------------------
1690: Effets de bord : néant
1691: ================================================================================
1692: */
1693:
1694: void
1695: instruction_repl(struct_processus *s_etat_processus)
1696: {
1697: integer8 position;
1698:
1699: long difference;
1700: long difference_ecriture;
1701: long difference_lecture;
1702: long nombre_occurrences;
1703:
1704: struct_liste_chainee *l_element_a_supprimer;
1705: struct_liste_chainee *l_element_courant;
1706: struct_liste_chainee *l_element_courant_2;
1707: struct_liste_chainee *l_element_precedent;
1708: struct_liste_chainee *l_element_precedent_2;
1709:
1710: struct_objet *s_objet_argument_1;
1711: struct_objet *s_objet_argument_2;
1712: struct_objet *s_objet_argument_3;
1713: struct_objet *s_objet_intermediaire;
1714: struct_objet *s_objet_resultat;
1715:
1716: unsigned char *ancien_pointeur_ecriture;
1717: unsigned char *ancien_pointeur_lecture;
1718: unsigned char *pointeur_ecriture;
1719: unsigned char *pointeur_lecture;
1720:
1721: (*s_etat_processus).erreur_execution = d_ex;
1722:
1723: if ((*s_etat_processus).affichage_arguments == 'Y')
1724: {
1725: printf("\n REPL ");
1726:
1727: if ((*s_etat_processus).langue == 'F')
1728: {
1729: printf("(remplacement d'éléments dans une liste ou une chaîne"
1730: ")\n\n");
1731: }
1732: else
1733: {
1734: printf("(replace elements in list or string)\n\n");
1735: }
1736:
1737: printf(" 3: %s\n", d_LST);
1738: printf(" 2: %s\n", d_INT);
1739: printf(" 1: %s\n", d_LST);
1740: printf("-> 1: %s\n\n", d_LST);
1741:
1742: printf(" 3: %s\n", d_CHN);
1743: printf(" 2: %s\n", d_CHN);
1744: printf(" 1: %s\n", d_CHN);
1745: printf("-> 1: %s\n\n", d_CHN);
1746: return;
1747: }
1748: else if ((*s_etat_processus).test_instruction == 'Y')
1749: {
1750: (*s_etat_processus).nombre_arguments = -1;
1751: return;
1752: }
1753:
1754: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1755: {
1756: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1757: {
1758: return;
1759: }
1760: }
1761:
1762: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1763: &s_objet_argument_1) == d_erreur)
1764: {
1765: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1766: return;
1767: }
1768:
1769: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1770: &s_objet_argument_2) == d_erreur)
1771: {
1772: liberation(s_etat_processus, s_objet_argument_1);
1773:
1774: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1775: return;
1776: }
1777:
1778: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1779: &s_objet_argument_3) == d_erreur)
1780: {
1781: liberation(s_etat_processus, s_objet_argument_1);
1782: liberation(s_etat_processus, s_objet_argument_2);
1783:
1784: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1785: return;
1786: }
1787:
1788: if (((*s_objet_argument_1).type == CHN) &&
1789: ((*s_objet_argument_2).type == CHN) &&
1790: ((*s_objet_argument_3).type == CHN))
1791: {
1792: if (strcmp((unsigned char *) (*s_objet_argument_2).objet, "") == 0)
1793: {
1794: liberation(s_etat_processus, s_objet_argument_1);
1795: liberation(s_etat_processus, s_objet_argument_2);
1796: liberation(s_etat_processus, s_objet_argument_3);
1797:
1798: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1799: return;
1800: }
1801:
1802: nombre_occurrences = 0;
1803: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
1804:
1805: for(;;)
1806: {
1807: pointeur_lecture = strstr(pointeur_lecture, (unsigned char *)
1808: (*s_objet_argument_2).objet);
1809:
1810: if (pointeur_lecture == NULL)
1811: {
1812: break;
1813: }
1814:
1815: pointeur_lecture++;
1816: nombre_occurrences++;
1817: }
1818:
1819: // Différence est positive si la nouvelle chaîne est plus longue
1820: // que la chaîne originelle.
1821:
1822: difference = strlen((unsigned char *) (*s_objet_argument_1).objet)
1823: - strlen((unsigned char *) (*s_objet_argument_2).objet);
1824:
1825: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1826: {
1827: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1828: return;
1829: }
1830:
1831: if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *)
1832: (*s_objet_argument_3).objet) + (nombre_occurrences *
1833: difference) + 1) * sizeof(unsigned char))) == NULL)
1834: {
1835: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1836: return;
1837: }
1838:
1839: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
1840: pointeur_ecriture = (unsigned char *) (*s_objet_resultat).objet;
1841: difference_lecture = strlen((unsigned char *)
1842: (*s_objet_argument_2).objet);
1843: difference_ecriture = strlen((unsigned char *)
1844: (*s_objet_argument_1).objet);
1845:
1846: for(;;)
1847: {
1848: ancien_pointeur_lecture = pointeur_lecture;
1849: ancien_pointeur_ecriture = pointeur_ecriture;
1850:
1851: pointeur_lecture = strstr(ancien_pointeur_lecture,
1852: (unsigned char *) (*s_objet_argument_2).objet);
1853:
1854: if (pointeur_lecture == NULL)
1855: {
1856: strcpy(ancien_pointeur_ecriture, ancien_pointeur_lecture);
1857: break;
1858: }
1859:
1860: strncpy(ancien_pointeur_ecriture, ancien_pointeur_lecture,
1861: pointeur_lecture - ancien_pointeur_lecture);
1862: strcpy(ancien_pointeur_ecriture +
1863: (pointeur_lecture - ancien_pointeur_lecture),
1864: (unsigned char *) (*s_objet_argument_1).objet);
1865:
1866: pointeur_ecriture += difference_ecriture +
1867: (pointeur_lecture - ancien_pointeur_lecture);
1868: pointeur_lecture += difference_lecture;
1869: }
1870: }
1871: else if (((*s_objet_argument_1).type == LST) &&
1872: ((*s_objet_argument_2).type == INT) &&
1873: ((*s_objet_argument_3).type == LST))
1874: {
1875: if ((*((integer8 *) (*s_objet_argument_2).objet)) <= 0)
1876: {
1877: liberation(s_etat_processus, s_objet_argument_1);
1878: liberation(s_etat_processus, s_objet_argument_2);
1879: liberation(s_etat_processus, s_objet_argument_3);
1880:
1881: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1882: return;
1883: }
1884:
1885: if ((s_objet_resultat = copie_objet(s_etat_processus,
1886: s_objet_argument_3, 'N')) == NULL)
1887: {
1888: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1889: return;
1890: }
1891:
1892: l_element_courant = (*s_objet_resultat).objet;
1893: l_element_precedent = NULL;
1894: position = 1;
1895:
1896: while(position < (*((integer8 *) (*s_objet_argument_2).objet)))
1897: {
1898: if (l_element_courant == NULL)
1899: {
1900: liberation(s_etat_processus, s_objet_argument_1);
1901: liberation(s_etat_processus, s_objet_argument_2);
1902: liberation(s_etat_processus, s_objet_argument_3);
1903: liberation(s_etat_processus, s_objet_resultat);
1904:
1905: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1906: return;
1907: }
1908:
1909: position++;
1910: l_element_precedent = l_element_courant;
1911: l_element_courant = (*l_element_courant).suivant;
1912: }
1913:
1914: l_element_a_supprimer = l_element_courant;
1915:
1916: if (l_element_courant == NULL)
1917: {
1918: liberation(s_etat_processus, s_objet_argument_1);
1919: liberation(s_etat_processus, s_objet_argument_2);
1920: liberation(s_etat_processus, s_objet_argument_3);
1921: liberation(s_etat_processus, s_objet_resultat);
1922:
1923: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1924: return;
1925: }
1926:
1927: if ((s_objet_intermediaire = copie_objet(s_etat_processus,
1928: s_objet_argument_1, 'N')) == NULL)
1929: {
1930: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1931: return;
1932: }
1933:
1934: if (l_element_precedent == NULL)
1935: {
1936: (*s_objet_resultat).objet = (*s_objet_intermediaire).objet;
1937: }
1938: else
1939: {
1940: (*l_element_precedent).suivant = (*s_objet_intermediaire).objet;
1941: }
1942:
1943: // (*l_element_precedent).suivant contient le premier maillon
1944: // de la liste accrochée, l_element_a_supprimer est le premier maillons
1945: // à supprimer.
1946:
1947: l_element_courant = (*s_objet_intermediaire).objet;
1948: (*s_objet_intermediaire).objet = l_element_a_supprimer;
1949:
1950: l_element_courant_2 = l_element_a_supprimer;
1951: l_element_precedent_2 = NULL;
1952:
1953: for(;;)
1954: {
1955: if (l_element_courant == NULL)
1956: {
1957: // La nouvelle liste est plus courte. On raboute les éléments
1958: // restant de l'ancienne liste à la nouvelle.
1959:
1960: if (l_element_precedent == NULL)
1961: {
1962: (*s_objet_resultat).objet = l_element_courant_2;
1963: }
1964: else
1965: {
1966: (*l_element_precedent).suivant = l_element_courant_2;
1967: }
1968:
1969: if (l_element_precedent_2 == NULL)
1970: {
1971: (*s_objet_intermediaire).objet = NULL;
1972: }
1973: else
1974: {
1975: (*l_element_precedent_2).suivant = NULL;
1976: }
1977:
1978: break;
1979: }
1980:
1981: if (l_element_courant_2 == NULL)
1982: {
1983: // L'ancienne liste est plus courte.
1984: break;
1985: }
1986:
1987: l_element_precedent = l_element_courant;
1988: l_element_precedent_2 = l_element_courant_2;
1989: l_element_courant = (*l_element_courant).suivant;
1990: l_element_courant_2 = (*l_element_courant_2).suivant;
1991: }
1992:
1993: liberation(s_etat_processus, s_objet_intermediaire);
1994: }
1995: else
1996: {
1997: liberation(s_etat_processus, s_objet_argument_1);
1998: liberation(s_etat_processus, s_objet_argument_2);
1999: liberation(s_etat_processus, s_objet_argument_3);
2000:
2001: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2002: return;
2003: }
2004:
2005: liberation(s_etat_processus, s_objet_argument_1);
2006: liberation(s_etat_processus, s_objet_argument_2);
2007: liberation(s_etat_processus, s_objet_argument_3);
2008:
2009: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2010: s_objet_resultat) == d_erreur)
2011: {
2012: return;
2013: }
2014:
2015: return;
2016: }
2017:
2018: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_r6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src