Annotation of rpl/src/instructions_r6.c, revision 1.43
1.1 bertrand 1: /*
2: ================================================================================
1.43 ! bertrand 3: RPL/2 (R) version 4.1.11
1.37 bertrand 4: Copyright (C) 1989-2012 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:
495: unsigned long i;
496: unsigned long 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((*((struct_matrice *)
569: (*s_objet_elementaire).objet)).nombre_colonnes *
570: 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((*((struct_matrice *)
621: (*s_objet_elementaire).objet)).nombre_colonnes *
622: 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((*((struct_matrice *)
673: (*s_objet_elementaire).objet)).nombre_colonnes *
674: 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 += (*((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;
1208: long premier;
1209:
1210: struct_objet *s_objet_argument;
1211: struct_objet *s_objet_resultat;
1212:
1.10 bertrand 1213: unsigned char *pointeur;
1.1 bertrand 1214: unsigned char *requete;
1215: unsigned char **types_generateurs;
1216:
1217: unsigned long nombre_types;
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(nombre_types * sizeof(unsigned char *)))
1254: == 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);
1.10 bertrand 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: }
1.1 bertrand 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 < (long) 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 position;
1718:
1719: long difference;
1720: long difference_ecriture;
1721: long difference_lecture;
1722: long nombre_occurrences;
1723:
1724: struct_liste_chainee *l_element_a_supprimer;
1725: struct_liste_chainee *l_element_courant;
1726: struct_liste_chainee *l_element_courant_2;
1727: struct_liste_chainee *l_element_precedent;
1728: struct_liste_chainee *l_element_precedent_2;
1729:
1730: struct_objet *s_objet_argument_1;
1731: struct_objet *s_objet_argument_2;
1732: struct_objet *s_objet_argument_3;
1733: struct_objet *s_objet_intermediaire;
1734: struct_objet *s_objet_resultat;
1735:
1736: unsigned char *ancien_pointeur_ecriture;
1737: unsigned char *ancien_pointeur_lecture;
1738: unsigned char *pointeur_ecriture;
1739: unsigned char *pointeur_lecture;
1740:
1741: (*s_etat_processus).erreur_execution = d_ex;
1742:
1743: if ((*s_etat_processus).affichage_arguments == 'Y')
1744: {
1745: printf("\n REPL ");
1746:
1747: if ((*s_etat_processus).langue == 'F')
1748: {
1.3 bertrand 1749: printf("(remplacement d'éléments dans une liste ou une chaîne"
1750: ")\n\n");
1.1 bertrand 1751: }
1752: else
1753: {
1754: printf("(replace elements in list or string)\n\n");
1755: }
1756:
1757: printf(" 3: %s\n", d_LST);
1758: printf(" 2: %s\n", d_INT);
1759: printf(" 1: %s\n", d_LST);
1760: printf("-> 1: %s\n\n", d_LST);
1761:
1762: printf(" 3: %s\n", d_CHN);
1763: printf(" 2: %s\n", d_CHN);
1764: printf(" 1: %s\n", d_CHN);
1765: printf("-> 1: %s\n\n", d_CHN);
1766: return;
1767: }
1768: else if ((*s_etat_processus).test_instruction == 'Y')
1769: {
1770: (*s_etat_processus).nombre_arguments = -1;
1771: return;
1772: }
1773:
1774: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1775: {
1776: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1777: {
1778: return;
1779: }
1780: }
1781:
1782: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1783: &s_objet_argument_1) == d_erreur)
1784: {
1785: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1786: return;
1787: }
1788:
1789: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1790: &s_objet_argument_2) == d_erreur)
1791: {
1792: liberation(s_etat_processus, s_objet_argument_1);
1793:
1794: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1795: return;
1796: }
1797:
1798: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1799: &s_objet_argument_3) == d_erreur)
1800: {
1801: liberation(s_etat_processus, s_objet_argument_1);
1802: liberation(s_etat_processus, s_objet_argument_2);
1803:
1804: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1805: return;
1806: }
1807:
1808: if (((*s_objet_argument_1).type == CHN) &&
1809: ((*s_objet_argument_2).type == CHN) &&
1810: ((*s_objet_argument_3).type == CHN))
1811: {
1812: if (strcmp((unsigned char *) (*s_objet_argument_2).objet, "") == 0)
1813: {
1814: liberation(s_etat_processus, s_objet_argument_1);
1815: liberation(s_etat_processus, s_objet_argument_2);
1816: liberation(s_etat_processus, s_objet_argument_3);
1817:
1818: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1819: return;
1820: }
1821:
1822: nombre_occurrences = 0;
1823: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
1824:
1825: for(;;)
1826: {
1827: pointeur_lecture = strstr(pointeur_lecture, (unsigned char *)
1828: (*s_objet_argument_2).objet);
1829:
1830: if (pointeur_lecture == NULL)
1831: {
1832: break;
1833: }
1834:
1835: pointeur_lecture++;
1836: nombre_occurrences++;
1837: }
1838:
1839: // Différence est positive si la nouvelle chaîne est plus longue
1840: // que la chaîne originelle.
1841:
1842: difference = strlen((unsigned char *) (*s_objet_argument_1).objet)
1843: - strlen((unsigned char *) (*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) + (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 = strlen((unsigned char *)
1862: (*s_objet_argument_2).objet);
1863: difference_ecriture = 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: 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