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