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