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