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