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