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