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