Annotation of rpl/src/instructions_r6.c, revision 1.48
1.1 bertrand 1: /*
2: ================================================================================
1.47 bertrand 3: RPL/2 (R) version 4.1.13
1.46 bertrand 4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
1.1 bertrand 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:
1.14 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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:
1.34 bertrand 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
1.1 bertrand 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: {
1.34 bertrand 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
1.1 bertrand 287: {
1.33 bertrand 288: if (errno != EINTR)
289: {
290: (*s_etat_processus).erreur_systeme = d_es_processus;
291: return;
292: }
1.1 bertrand 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:
1.34 bertrand 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
1.1 bertrand 321: {
1.33 bertrand 322: if (errno != EINTR)
323: {
324: (*s_etat_processus).erreur_systeme = d_es_processus;
325: return;
326: }
1.1 bertrand 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:
1.34 bertrand 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
1.1 bertrand 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:
1.34 bertrand 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
1.1 bertrand 401: {
1.33 bertrand 402: if (errno != EINTR)
403: {
404: (*s_etat_processus).erreur_systeme = d_es_processus;
405: return;
406: }
1.1 bertrand 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:
1.48 ! bertrand 495: integer8 i;
! 496: integer8 j;
1.1 bertrand 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)
1.48 ! bertrand 568: .objet)).tableau)[0] = malloc(((size_t)
! 569: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 570: .nombre_colonnes) * sizeof(integer8))) == NULL)
1.1 bertrand 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)
1.48 ! bertrand 620: .objet)).tableau)[0] = malloc(((size_t)
! 621: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 622: .nombre_colonnes) * sizeof(real8))) == NULL)
1.1 bertrand 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)
1.48 ! bertrand 672: .objet)).tableau)[0] = malloc(((size_t)
! 673: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 674: .nombre_colonnes) * sizeof(complex16))) == NULL)
1.1 bertrand 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 += (*((integer8 *) (*s_objet_argument).objet));
797:
798: if (horodatage.tv_sec < 0)
799: {
800: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
801:
802: liberation(s_etat_processus, s_objet_argument);
803: return;
804: }
805:
806: if ((s_objet = formateur_date(s_etat_processus, &horodatage)) == NULL)
807: {
808: liberation(s_etat_processus, s_objet_argument);
809: return;
810: }
811:
812: liberation(s_etat_processus, s_objet_argument);
813: }
814: else
815: {
816: liberation(s_etat_processus, s_objet_argument);
817:
818: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
819: return;
820: }
821:
822: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
823: s_objet) == d_erreur)
824: {
825: return;
826: }
827:
828: return;
829: }
830:
831:
832: /*
833: ================================================================================
834: Fonction 'rclswi'
835: ================================================================================
836: Entrées : pointeur sur une structure struct_processus
837: --------------------------------------------------------------------------------
838: Sorties :
839: --------------------------------------------------------------------------------
840: Effets de bord : néant
841: ================================================================================
842: */
843:
844: void
845: instruction_rclswi(struct_processus *s_etat_processus)
846: {
847: integer8 interruption;
848:
849: struct_objet *s_objet_argument;
850: struct_objet *s_objet_resultat;
851:
852: (*s_etat_processus).erreur_execution = d_ex;
853:
854: if ((*s_etat_processus).affichage_arguments == 'Y')
855: {
856: printf("\n RCLSWI ");
857:
858: if ((*s_etat_processus).langue == 'F')
859: {
860: printf("(rappel d'une interruption logicielle)\n\n");
861: }
862: else
863: {
864: printf("(recall software interrupt)\n\n");
865: }
866:
867: printf(" 1: %s\n", d_INT);
868: printf("-> 1: %s, %s\n", d_NOM, d_RPN);
869:
870: return;
871: }
872: else if ((*s_etat_processus).test_instruction == 'Y')
873: {
874: (*s_etat_processus).nombre_arguments = -1;
875: return;
876: }
877:
878: if (test_cfsf(s_etat_processus, 31) == d_vrai)
879: {
880: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
881: {
882: return;
883: }
884: }
885:
886: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
887: &s_objet_argument) == d_erreur)
888: {
889: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
890: return;
891: }
892:
893: if ((*s_objet_argument).type == INT)
894: {
895: interruption = (*((integer8 *) (*s_objet_argument).objet));
896:
897: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
898: {
899: liberation(s_etat_processus, s_objet_argument);
900:
901: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
902: return;
903: }
904:
905: if ((*s_etat_processus).corps_interruptions[interruption - 1] == NULL)
906: {
907: liberation(s_etat_processus, s_objet_argument);
908:
909: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
910: return;
911: }
912:
913: if ((s_objet_resultat = copie_objet(s_etat_processus,
914: (*s_etat_processus).corps_interruptions[interruption - 1], 'P'))
915: == NULL)
916: {
917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
918: return;
919: }
920: }
921: else
922: {
923: liberation(s_etat_processus, s_objet_argument);
924:
925: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
926: return;
927: }
928:
929: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
930: s_objet_resultat) == d_erreur)
931: {
932: return;
933: }
934:
935: return;
936: }
937:
938:
939: /*
940: ================================================================================
941: Fonction 'revlist'
942: ================================================================================
943: Entrées : pointeur sur une structure struct_processus
944: --------------------------------------------------------------------------------
945: Sorties :
946: --------------------------------------------------------------------------------
947: Effets de bord : néant
948: ================================================================================
949: */
950:
951: void
952: instruction_revlist(struct_processus *s_etat_processus)
953: {
954: struct_liste_chainee *l_ancienne_base;
955: struct_liste_chainee *l_nouvelle_base;
956:
957: struct_objet *s_objet_argument;
958: struct_objet *s_objet_intermediaire;
959: struct_objet *s_objet_resultat;
960:
961: (*s_etat_processus).erreur_execution = d_ex;
962:
963: if ((*s_etat_processus).affichage_arguments == 'Y')
964: {
965: printf("\n REVLIST ");
966:
967: if ((*s_etat_processus).langue == 'F')
968: {
969: printf("(inverse les éléments d'une liste)\n\n");
970: }
971: else
972: {
973: printf("(inverts list elements)\n\n");
974: }
975:
976: printf(" 1: %s\n", d_LST);
977: printf("-> 1: %s\n", d_LST);
978:
979: return;
980: }
981: else if ((*s_etat_processus).test_instruction == 'Y')
982: {
983: (*s_etat_processus).nombre_arguments = -1;
984: return;
985: }
986:
987: if (test_cfsf(s_etat_processus, 31) == d_vrai)
988: {
989: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
990: {
991: return;
992: }
993: }
994:
995: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
996: &s_objet_argument) == d_erreur)
997: {
998: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
999: return;
1000: }
1001:
1002: if ((*s_objet_argument).type == LST)
1003: {
1004: if ((s_objet_resultat = copie_objet(s_etat_processus,
1005: s_objet_argument, 'N')) == NULL)
1006: {
1007: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1008: return;
1009: }
1010:
1011: l_ancienne_base = (*s_objet_resultat).objet;
1012: l_nouvelle_base = NULL;
1013:
1014: while(l_ancienne_base != NULL)
1015: {
1016: if (depilement(s_etat_processus, &l_ancienne_base,
1017: &s_objet_intermediaire) == d_erreur)
1018: {
1019: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
1020: return;
1021: }
1022:
1023: if (empilement(s_etat_processus, &l_nouvelle_base,
1024: s_objet_intermediaire) == d_erreur)
1025: {
1026: return;
1027: }
1028: }
1029:
1030: (*s_objet_resultat).objet = l_nouvelle_base;
1031: }
1032: else
1033: {
1034: liberation(s_etat_processus, s_objet_argument);
1035:
1036: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1037: return;
1038: }
1039:
1040: liberation(s_etat_processus, s_objet_argument);
1041:
1042: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1043: s_objet_resultat) == d_erreur)
1044: {
1045: return;
1046: }
1047:
1048: return;
1049: }
1050:
1051:
1052: /*
1053: ================================================================================
1054: Fonction 'rstop'
1055: ================================================================================
1056: Entrées :
1057: --------------------------------------------------------------------------------
1058: Sorties :
1059: --------------------------------------------------------------------------------
1060: Effets de bord : néant
1061: ================================================================================
1062: */
1063:
1064: void
1065: instruction_rstop(struct_processus *s_etat_processus)
1066: {
1067: (*s_etat_processus).erreur_execution = d_ex;
1068:
1069: if ((*s_etat_processus).affichage_arguments == 'Y')
1070: {
1071: printf("\n RSTOP ");
1072:
1073: if ((*s_etat_processus).langue == 'F')
1074: {
1075: printf("(libère le signal stop)\n\n");
1076: printf(" Aucun argument\n");
1077: }
1078: else
1079: {
1080: printf("(release stop signal)\n\n");
1081: printf(" No argument\n");
1082: }
1083:
1084: return;
1085: }
1086: else if ((*s_etat_processus).test_instruction == 'Y')
1087: {
1088: (*s_etat_processus).nombre_arguments = -1;
1089: return;
1090: }
1091:
1092: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1093: {
1094: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1095: {
1096: return;
1097: }
1098: }
1099:
1100: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
1101: {
1102: (*s_etat_processus).erreur_execution = d_ex_stop;
1103: return;
1104: }
1105:
1106: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
1107: {
1108: (*s_etat_processus).var_volatile_requete_arret = -1;
1109: }
1110:
1111: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
1112:
1113: return;
1114: }
1115:
1116:
1117: /*
1118: ================================================================================
1119: fonction 'rfuse'
1120: ================================================================================
1121: entrées :
1122: --------------------------------------------------------------------------------
1123: sorties :
1124: --------------------------------------------------------------------------------
1125: effets de bord : néant
1126: ================================================================================
1127: */
1128:
1129: void
1130: instruction_rfuse(struct_processus *s_etat_processus)
1131: {
1132: struct_objet *s_objet_resultat;
1133:
1134: (*s_etat_processus).erreur_execution = d_ex;
1135:
1136: if ((*s_etat_processus).affichage_arguments == 'Y')
1137: {
1138: printf("\n RFUSE ");
1139:
1140: if ((*s_etat_processus).langue == 'F')
1141: {
1142: printf("(valeur courante du fusible)\n\n");
1143: }
1144: else
1145: {
1146: printf("(remaining fuse value)\n\n");
1147: }
1148:
1149: printf("-> 1: %s\n", d_REL);
1150: return;
1151: }
1152: else if ((*s_etat_processus).test_instruction == 'Y')
1153: {
1154: (*s_etat_processus).nombre_arguments = -1;
1155: return;
1156: }
1157:
1158: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1159: {
1160: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1161: {
1162: return;
1163: }
1164: }
1165:
1166: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1167: {
1168: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1169: return;
1170: }
1171:
1172: (*((real8 *) (*s_objet_resultat).objet)) =
1173: (*s_etat_processus).temps_maximal_cpu;
1174:
1175: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1176: s_objet_resultat) == d_erreur)
1177: {
1178: return;
1179: }
1180:
1181: return;
1182: }
1183:
1184:
1185: /*
1186: ================================================================================
1187: fonction 'rdgn'
1188: ================================================================================
1189: entrées :
1190: --------------------------------------------------------------------------------
1191: sorties :
1192: --------------------------------------------------------------------------------
1193: effets de bord : néant
1194: ================================================================================
1195: */
1196:
1197: void
1198: instruction_rdgn(struct_processus *s_etat_processus)
1199: {
1200: const gsl_rng_type **type_courant;
1201: const gsl_rng_type **types;
1202:
1203: const unsigned char *message = "UNINITIALIZED RANDOM GENERATOR";
1204:
1205: long dernier;
1206: long i;
1207: long j;
1.48 ! bertrand 1208: long nombre_types;
1.1 bertrand 1209: long premier;
1210:
1211: struct_objet *s_objet_argument;
1212: struct_objet *s_objet_resultat;
1213:
1.10 bertrand 1214: unsigned char *pointeur;
1.1 bertrand 1215: unsigned char *requete;
1216: unsigned char **types_generateurs;
1217:
1218: (*s_etat_processus).erreur_execution = d_ex;
1219:
1220: types = gsl_rng_types_setup();
1221:
1222: if ((*s_etat_processus).affichage_arguments == 'Y')
1223: {
1224: printf("\n RDGN ");
1225:
1226: if ((*s_etat_processus).langue == 'F')
1227: {
1228: printf("(choix du générateur de nombres aléatoires)\n\n");
1229: }
1230: else
1231: {
1232: printf("(random number generator specification)\n\n");
1233: }
1234:
1235: printf(" 1: %s\n\n", d_CHN);
1236:
1237: printf(" 1: \"QUERY\"\n");
1238: printf("-> 1: %s\n\n", d_CHN);
1239:
1240: if ((*s_etat_processus).langue == 'F')
1241: {
1242: printf(" Générateurs disponibles :\n\n");
1243: }
1244: else
1245: {
1246: printf(" Available generators:\n\n");
1247: }
1248:
1249: for(nombre_types = 0, type_courant = types;
1250: (*type_courant) != NULL; type_courant++, nombre_types++);
1251:
1.48 ! bertrand 1252: if ((types_generateurs = malloc(((size_t) nombre_types) *
! 1253: sizeof(unsigned char *))) == NULL)
1.1 bertrand 1254: {
1255: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1256: return;
1257: }
1258:
1259: for(i = 0, type_courant = types; (*type_courant) != NULL;
1260: type_courant++, i++)
1261: {
1262: if ((types_generateurs[i] = malloc((strlen((**type_courant).name)
1263: + 1) * sizeof(unsigned char))) == NULL)
1264: {
1265: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1266: return;
1267: }
1268:
1269: strcpy(types_generateurs[i], (**type_courant).name);
1.10 bertrand 1270: pointeur = types_generateurs[i];
1271:
1272: while((*pointeur) != d_code_fin_chaine)
1273: {
1274: if ((*pointeur) == '-')
1275: {
1276: (*pointeur) = '_';
1277: }
1278:
1279: pointeur++;
1280: }
1.1 bertrand 1281: }
1282:
1283: // Tri des types de générateurs (tri shaker)
1284:
1285: premier = 1;
1286: dernier = nombre_types - 2;
1287:
1288: while((dernier - premier) >= 2)
1289: {
1290: for(j = 2, i = premier; i <= dernier; i++)
1291: {
1292: if (strcmp(types_generateurs[i], types_generateurs[i + 1]) > 0)
1293: {
1294: swap(&(types_generateurs[i]),
1295: &(types_generateurs[i + 1]),
1296: sizeof(unsigned char *));
1297: j = i;
1298: }
1299: }
1300:
1301: dernier = j;
1302: i = nombre_types - 2;
1303:
1304: for(i = dernier; i >= premier; i--)
1305: {
1306: if (strcmp(types_generateurs[i - 1], types_generateurs[i]) > 0)
1307: {
1308: swap(&(types_generateurs[i - 1]),
1309: &(types_generateurs[i]),
1310: sizeof(unsigned char *));
1311: j = i;
1312: }
1313: }
1314:
1315: premier = j;
1316: }
1317:
1318: for(i = 0; i < (long) nombre_types; i++)
1319: {
1320: printf(" - %s\n", types_generateurs[i]);
1321: free(types_generateurs[i]);
1322: }
1323:
1324: free(types_generateurs);
1325: return;
1326: }
1327: else if ((*s_etat_processus).test_instruction == 'Y')
1328: {
1329: (*s_etat_processus).nombre_arguments = -1;
1330: return;
1331: }
1332:
1333: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1334: {
1335: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1336: {
1337: return;
1338: }
1339: }
1340:
1341: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1342: &s_objet_argument) == d_erreur)
1343: {
1344: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1345: return;
1346: }
1347:
1348: if ((*s_objet_argument).type == CHN)
1349: {
1350: if ((requete = conversion_majuscule((unsigned char *)
1351: (*s_objet_argument).objet)) == NULL)
1352: {
1353: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1354: return;
1355: }
1356:
1357: if (strcmp(requete, "QUERY") == 0)
1358: {
1359: /*
1360: * Récupération du type du générateur
1361: */
1362:
1363: free(requete);
1364:
1365: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1366: {
1367: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1368: return;
1369: }
1370:
1371: if ((*s_etat_processus).type_generateur_aleatoire == NULL)
1372: {
1373: if (((*s_objet_resultat).objet = malloc((strlen(message) + 1) *
1374: sizeof(unsigned char))) == NULL)
1375: {
1376: (*s_etat_processus).erreur_systeme =
1377: d_es_allocation_memoire;
1378: return;
1379: }
1380:
1381: strcpy((unsigned char *) (*s_objet_resultat).objet, message);
1382: }
1383: else
1384: {
1385: if (((*s_objet_resultat).objet = conversion_majuscule(
1386: (unsigned char *) gsl_rng_name(
1387: (*s_etat_processus).generateur_aleatoire))) == NULL)
1388: {
1389: (*s_etat_processus).erreur_systeme =
1390: d_es_allocation_memoire;
1391: return;
1392: }
1393: }
1394:
1395: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1396: s_objet_resultat) == d_erreur)
1397: {
1398: return;
1399: }
1400: }
1401: else
1402: {
1403: /*
1404: * Affectation d'un nouveau type de générateur
1405: */
1406:
1407: # include "generateurs.c"
1408:
1409: free(requete);
1410:
1411: if ((*s_etat_processus).generateur_aleatoire != NULL)
1412: {
1413: liberation_generateur_aleatoire(s_etat_processus);
1414: }
1415:
1416: initialisation_generateur_aleatoire(s_etat_processus, d_vrai, 0);
1417: }
1418: }
1419: else
1420: {
1421: liberation(s_etat_processus, s_objet_argument);
1422:
1423: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1424: return;
1425: }
1426:
1427: liberation(s_etat_processus, s_objet_argument);
1428:
1429: return;
1430: }
1431:
1432:
1433: /*
1434: ================================================================================
1435: fonction 'rank'
1436: ================================================================================
1437: entrées :
1438: --------------------------------------------------------------------------------
1439: sorties :
1440: --------------------------------------------------------------------------------
1441: effets de bord : néant
1442: ================================================================================
1443: */
1444:
1445: void
1446: instruction_rank(struct_processus *s_etat_processus)
1447: {
1448: struct_objet *s_objet_argument;
1449: struct_objet *s_objet_resultat;
1450:
1451: (*s_etat_processus).erreur_execution = d_ex;
1452:
1453: if ((*s_etat_processus).affichage_arguments == 'Y')
1454: {
1455: printf("\n RANK ");
1456:
1457: if ((*s_etat_processus).langue == 'F')
1458: {
1459: printf("(rang de la matrice)\n\n");
1460: }
1461: else
1462: {
1463: printf("(matrix rank)\n\n");
1464: }
1465:
1466: printf(" 1: %s, %s, %s\n", d_MIN, d_REL, d_MCX);
1467: printf("-> 1: %s\n", d_INT);
1468:
1469: return;
1470: }
1471: else if ((*s_etat_processus).test_instruction == 'Y')
1472: {
1473: (*s_etat_processus).nombre_arguments = -1;
1474: return;
1475: }
1476:
1477: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1478: {
1479: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1480: {
1481: return;
1482: }
1483: }
1484:
1485: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1486: &s_objet_argument) == d_erreur)
1487: {
1488: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1489: return;
1490: }
1491:
1492: if (((*s_objet_argument).type == MIN) ||
1493: ((*s_objet_argument).type == MRL) ||
1494: ((*s_objet_argument).type == MCX))
1495: {
1496: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1497: {
1498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1499: return;
1500: }
1501:
1502: rang(s_etat_processus, (*s_objet_argument).objet,
1503: (*s_objet_resultat).objet);
1504:
1505: if ((*s_etat_processus).erreur_systeme != d_es)
1506: {
1507: return;
1508: }
1509:
1510: if (((*s_etat_processus).erreur_execution != d_ex) ||
1511: ((*s_etat_processus).exception != d_ep))
1512: {
1513: liberation(s_etat_processus, s_objet_argument);
1514: liberation(s_etat_processus, s_objet_resultat);
1515: return;
1516: }
1517: }
1518: else
1519: {
1520: liberation(s_etat_processus, s_objet_argument);
1521:
1522: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1523: return;
1524: }
1525:
1526: liberation(s_etat_processus, s_objet_argument);
1527:
1528: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1529: s_objet_resultat) == d_erreur)
1530: {
1531: return;
1532: }
1533:
1534: return;
1535: }
1536:
1537:
1538: /*
1539: ================================================================================
1540: Fonction 'recode'
1541: ================================================================================
1542: Entrées :
1543: --------------------------------------------------------------------------------
1544: Sorties :
1545: --------------------------------------------------------------------------------
1546: Effets de bord : néant
1547: ================================================================================
1548: */
1549:
1550: void
1551: instruction_recode(struct_processus *s_etat_processus)
1552: {
1553: struct_objet *s_objet_argument_1;
1554: struct_objet *s_objet_argument_2;
1555: struct_objet *s_objet_argument_3;
1556: struct_objet *s_objet_resultat;
1557:
1558: unsigned char *encodage_destination;
1559: unsigned char *encodage_source;
1560: unsigned char *tampon;
1561:
1562: (*s_etat_processus).erreur_execution = d_ex;
1563:
1564: if ((*s_etat_processus).affichage_arguments == 'Y')
1565: {
1566: printf("\n RECODE ");
1567:
1568: if ((*s_etat_processus).langue == 'F')
1569: {
1570: printf("(conversion d'encodage d'une chaîne de caractères)\n\n");
1571: }
1572: else
1573: {
1574: printf("(string recodage)\n\n");
1575: }
1576:
1577: printf(" 3: %s\n", d_CHN);
1578: printf(" 2: %s\n", d_CHN);
1579: printf(" 1: %s\n", d_CHN);
1580: printf("-> 1: %s\n\n", d_CHN);
1581:
1582: if ((*s_etat_processus).langue == 'F')
1583: {
1584: printf(" Utilisation :\n\n");
1585: }
1586: else
1587: {
1588: printf(" Usage:\n\n");
1589: }
1590:
1591: printf(" \"string\" \"ISO8859-1\" \"UTF-8\" recode\n");
1592: printf(" \"string\" \"ISO8859-1\" \"UTF-8//TRANSLIT\" recode\n");
1593: printf(" \"string\" \"ISO8859-1\" \"UTF-8//IGNORE\" recode\n");
1594: return;
1595: }
1596: else if ((*s_etat_processus).test_instruction == 'Y')
1597: {
1598: (*s_etat_processus).nombre_arguments = -1;
1599: return;
1600: }
1601:
1602: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1603: {
1604: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1605: {
1606: return;
1607: }
1608: }
1609:
1610: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1611: &s_objet_argument_1) == d_erreur)
1612: {
1613: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1614: return;
1615: }
1616:
1617: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1618: &s_objet_argument_2) == d_erreur)
1619: {
1620: liberation(s_etat_processus, s_objet_argument_1);
1621:
1622: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1623: return;
1624: }
1625:
1626: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1627: &s_objet_argument_3) == d_erreur)
1628: {
1629: liberation(s_etat_processus, s_objet_argument_1);
1630: liberation(s_etat_processus, s_objet_argument_2);
1631:
1632: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1633: return;
1634: }
1635:
1636: if (((*s_objet_argument_1).type == CHN) &&
1637: ((*s_objet_argument_2).type == CHN) &&
1638: ((*s_objet_argument_3).type == CHN))
1639: {
1640: if ((encodage_source = conversion_majuscule((unsigned char *)
1641: (*s_objet_argument_2).objet)) == NULL)
1642: {
1643: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1644: return;
1645: }
1646:
1647: if ((encodage_destination = conversion_majuscule((unsigned char *)
1648: (*s_objet_argument_1).objet)) == NULL)
1649: {
1650: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1651: return;
1652: }
1653:
1654: tampon = reencodage(s_etat_processus,
1655: (*s_objet_argument_3).objet, encodage_source,
1656: encodage_destination);
1657:
1658: free(encodage_destination);
1659: free(encodage_source);
1660:
1661: if (tampon == NULL)
1662: {
1663: liberation(s_etat_processus, s_objet_argument_1);
1664: liberation(s_etat_processus, s_objet_argument_2);
1665: liberation(s_etat_processus, s_objet_argument_3);
1666: return;
1667: }
1668:
1669: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1670: {
1671: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1672: return;
1673: }
1674:
1675: (*s_objet_resultat).objet = tampon;
1676: }
1677: else
1678: {
1679: liberation(s_etat_processus, s_objet_argument_1);
1680: liberation(s_etat_processus, s_objet_argument_2);
1681: liberation(s_etat_processus, s_objet_argument_3);
1682:
1683: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1684: return;
1685: }
1686:
1687: liberation(s_etat_processus, s_objet_argument_1);
1688: liberation(s_etat_processus, s_objet_argument_2);
1689: liberation(s_etat_processus, s_objet_argument_3);
1690:
1691: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1692: s_objet_resultat) == d_erreur)
1693: {
1694: return;
1695: }
1696:
1697: return;
1698: }
1699:
1700:
1701: /*
1702: ================================================================================
1703: Fonction 'repl'
1704: ================================================================================
1705: Entrées :
1706: --------------------------------------------------------------------------------
1707: Sorties :
1708: --------------------------------------------------------------------------------
1709: Effets de bord : néant
1710: ================================================================================
1711: */
1712:
1713: void
1714: instruction_repl(struct_processus *s_etat_processus)
1715: {
1.48 ! bertrand 1716: integer8 difference;
! 1717: integer8 difference_ecriture;
! 1718: integer8 difference_lecture;
! 1719: integer8 nombre_occurrences;
1.1 bertrand 1720: integer8 position;
1721:
1722: struct_liste_chainee *l_element_a_supprimer;
1723: struct_liste_chainee *l_element_courant;
1724: struct_liste_chainee *l_element_courant_2;
1725: struct_liste_chainee *l_element_precedent;
1726: struct_liste_chainee *l_element_precedent_2;
1727:
1728: struct_objet *s_objet_argument_1;
1729: struct_objet *s_objet_argument_2;
1730: struct_objet *s_objet_argument_3;
1731: struct_objet *s_objet_intermediaire;
1732: struct_objet *s_objet_resultat;
1733:
1734: unsigned char *ancien_pointeur_ecriture;
1735: unsigned char *ancien_pointeur_lecture;
1736: unsigned char *pointeur_ecriture;
1737: unsigned char *pointeur_lecture;
1738:
1739: (*s_etat_processus).erreur_execution = d_ex;
1740:
1741: if ((*s_etat_processus).affichage_arguments == 'Y')
1742: {
1743: printf("\n REPL ");
1744:
1745: if ((*s_etat_processus).langue == 'F')
1746: {
1.3 bertrand 1747: printf("(remplacement d'éléments dans une liste ou une chaîne"
1748: ")\n\n");
1.1 bertrand 1749: }
1750: else
1751: {
1752: printf("(replace elements in list or string)\n\n");
1753: }
1754:
1755: printf(" 3: %s\n", d_LST);
1756: printf(" 2: %s\n", d_INT);
1757: printf(" 1: %s\n", d_LST);
1758: printf("-> 1: %s\n\n", d_LST);
1759:
1760: printf(" 3: %s\n", d_CHN);
1761: printf(" 2: %s\n", d_CHN);
1762: printf(" 1: %s\n", d_CHN);
1763: printf("-> 1: %s\n\n", d_CHN);
1764: return;
1765: }
1766: else if ((*s_etat_processus).test_instruction == 'Y')
1767: {
1768: (*s_etat_processus).nombre_arguments = -1;
1769: return;
1770: }
1771:
1772: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1773: {
1774: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1775: {
1776: return;
1777: }
1778: }
1779:
1780: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1781: &s_objet_argument_1) == d_erreur)
1782: {
1783: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1784: return;
1785: }
1786:
1787: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1788: &s_objet_argument_2) == d_erreur)
1789: {
1790: liberation(s_etat_processus, s_objet_argument_1);
1791:
1792: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1793: return;
1794: }
1795:
1796: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1797: &s_objet_argument_3) == d_erreur)
1798: {
1799: liberation(s_etat_processus, s_objet_argument_1);
1800: liberation(s_etat_processus, s_objet_argument_2);
1801:
1802: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1803: return;
1804: }
1805:
1806: if (((*s_objet_argument_1).type == CHN) &&
1807: ((*s_objet_argument_2).type == CHN) &&
1808: ((*s_objet_argument_3).type == CHN))
1809: {
1810: if (strcmp((unsigned char *) (*s_objet_argument_2).objet, "") == 0)
1811: {
1812: liberation(s_etat_processus, s_objet_argument_1);
1813: liberation(s_etat_processus, s_objet_argument_2);
1814: liberation(s_etat_processus, s_objet_argument_3);
1815:
1816: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1817: return;
1818: }
1819:
1820: nombre_occurrences = 0;
1821: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
1822:
1823: for(;;)
1824: {
1825: pointeur_lecture = strstr(pointeur_lecture, (unsigned char *)
1826: (*s_objet_argument_2).objet);
1827:
1828: if (pointeur_lecture == NULL)
1829: {
1830: break;
1831: }
1832:
1833: pointeur_lecture++;
1834: nombre_occurrences++;
1835: }
1836:
1837: // Différence est positive si la nouvelle chaîne est plus longue
1838: // que la chaîne originelle.
1839:
1.48 ! bertrand 1840: difference = ((integer8) strlen((unsigned char *) (*s_objet_argument_1)
! 1841: .objet)) - ((integer8) strlen((unsigned char *)
! 1842: (*s_objet_argument_2).objet));
1.1 bertrand 1843:
1844: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1845: {
1846: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1847: return;
1848: }
1849:
1850: if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *)
1.48 ! bertrand 1851: (*s_objet_argument_3).objet) + ((size_t) (nombre_occurrences *
! 1852: difference)) + 1) * sizeof(unsigned char))) == NULL)
1.1 bertrand 1853: {
1854: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1855: return;
1856: }
1857:
1858: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
1859: pointeur_ecriture = (unsigned char *) (*s_objet_resultat).objet;
1.48 ! bertrand 1860: difference_lecture = (integer8) strlen((unsigned char *)
1.1 bertrand 1861: (*s_objet_argument_2).objet);
1.48 ! bertrand 1862: difference_ecriture = (integer8) strlen((unsigned char *)
1.1 bertrand 1863: (*s_objet_argument_1).objet);
1864:
1865: for(;;)
1866: {
1867: ancien_pointeur_lecture = pointeur_lecture;
1868: ancien_pointeur_ecriture = pointeur_ecriture;
1869:
1870: pointeur_lecture = strstr(ancien_pointeur_lecture,
1871: (unsigned char *) (*s_objet_argument_2).objet);
1872:
1873: if (pointeur_lecture == NULL)
1874: {
1875: strcpy(ancien_pointeur_ecriture, ancien_pointeur_lecture);
1876: break;
1877: }
1878:
1879: strncpy(ancien_pointeur_ecriture, ancien_pointeur_lecture,
1.48 ! bertrand 1880: (size_t) (pointeur_lecture - ancien_pointeur_lecture));
1.1 bertrand 1881: strcpy(ancien_pointeur_ecriture +
1882: (pointeur_lecture - ancien_pointeur_lecture),
1883: (unsigned char *) (*s_objet_argument_1).objet);
1884:
1885: pointeur_ecriture += difference_ecriture +
1886: (pointeur_lecture - ancien_pointeur_lecture);
1887: pointeur_lecture += difference_lecture;
1888: }
1889: }
1890: else if (((*s_objet_argument_1).type == LST) &&
1891: ((*s_objet_argument_2).type == INT) &&
1892: ((*s_objet_argument_3).type == LST))
1893: {
1894: if ((*((integer8 *) (*s_objet_argument_2).objet)) <= 0)
1895: {
1896: liberation(s_etat_processus, s_objet_argument_1);
1897: liberation(s_etat_processus, s_objet_argument_2);
1898: liberation(s_etat_processus, s_objet_argument_3);
1899:
1900: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1901: return;
1902: }
1903:
1904: if ((s_objet_resultat = copie_objet(s_etat_processus,
1905: s_objet_argument_3, 'N')) == NULL)
1906: {
1907: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1908: return;
1909: }
1910:
1911: l_element_courant = (*s_objet_resultat).objet;
1912: l_element_precedent = NULL;
1913: position = 1;
1914:
1915: while(position < (*((integer8 *) (*s_objet_argument_2).objet)))
1916: {
1917: if (l_element_courant == NULL)
1918: {
1919: liberation(s_etat_processus, s_objet_argument_1);
1920: liberation(s_etat_processus, s_objet_argument_2);
1921: liberation(s_etat_processus, s_objet_argument_3);
1922: liberation(s_etat_processus, s_objet_resultat);
1923:
1924: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1925: return;
1926: }
1927:
1928: position++;
1929: l_element_precedent = l_element_courant;
1930: l_element_courant = (*l_element_courant).suivant;
1931: }
1932:
1933: l_element_a_supprimer = l_element_courant;
1934:
1935: if (l_element_courant == NULL)
1936: {
1937: liberation(s_etat_processus, s_objet_argument_1);
1938: liberation(s_etat_processus, s_objet_argument_2);
1939: liberation(s_etat_processus, s_objet_argument_3);
1940: liberation(s_etat_processus, s_objet_resultat);
1941:
1942: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1943: return;
1944: }
1945:
1946: if ((s_objet_intermediaire = copie_objet(s_etat_processus,
1947: s_objet_argument_1, 'N')) == NULL)
1948: {
1949: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1950: return;
1951: }
1952:
1953: if (l_element_precedent == NULL)
1954: {
1955: (*s_objet_resultat).objet = (*s_objet_intermediaire).objet;
1956: }
1957: else
1958: {
1959: (*l_element_precedent).suivant = (*s_objet_intermediaire).objet;
1960: }
1961:
1962: // (*l_element_precedent).suivant contient le premier maillon
1963: // de la liste accrochée, l_element_a_supprimer est le premier maillons
1964: // à supprimer.
1965:
1966: l_element_courant = (*s_objet_intermediaire).objet;
1967: (*s_objet_intermediaire).objet = l_element_a_supprimer;
1968:
1969: l_element_courant_2 = l_element_a_supprimer;
1970: l_element_precedent_2 = NULL;
1971:
1972: for(;;)
1973: {
1974: if (l_element_courant == NULL)
1975: {
1976: // La nouvelle liste est plus courte. On raboute les éléments
1977: // restant de l'ancienne liste à la nouvelle.
1978:
1979: if (l_element_precedent == NULL)
1980: {
1981: (*s_objet_resultat).objet = l_element_courant_2;
1982: }
1983: else
1984: {
1985: (*l_element_precedent).suivant = l_element_courant_2;
1986: }
1987:
1988: if (l_element_precedent_2 == NULL)
1989: {
1990: (*s_objet_intermediaire).objet = NULL;
1991: }
1992: else
1993: {
1994: (*l_element_precedent_2).suivant = NULL;
1995: }
1996:
1997: break;
1998: }
1999:
2000: if (l_element_courant_2 == NULL)
2001: {
2002: // L'ancienne liste est plus courte.
2003: break;
2004: }
2005:
2006: l_element_precedent = l_element_courant;
2007: l_element_precedent_2 = l_element_courant_2;
2008: l_element_courant = (*l_element_courant).suivant;
2009: l_element_courant_2 = (*l_element_courant_2).suivant;
2010: }
2011:
2012: liberation(s_etat_processus, s_objet_intermediaire);
2013: }
2014: else
2015: {
2016: liberation(s_etat_processus, s_objet_argument_1);
2017: liberation(s_etat_processus, s_objet_argument_2);
2018: liberation(s_etat_processus, s_objet_argument_3);
2019:
2020: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2021: return;
2022: }
2023:
2024: liberation(s_etat_processus, s_objet_argument_1);
2025: liberation(s_etat_processus, s_objet_argument_2);
2026: liberation(s_etat_processus, s_objet_argument_3);
2027:
2028: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2029: s_objet_resultat) == d_erreur)
2030: {
2031: return;
2032: }
2033:
2034: return;
2035: }
2036:
2037: // 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