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