![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_s6.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.69 ! bertrand 3: RPL/2 (R) version 4.1.32
1.67 bertrand 4: Copyright (C) 1989-2019 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.12 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'sdev'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_sdev(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_statistique;
42: struct_objet *s_objet_resultat;
43: struct_objet *s_objet_temporaire;
44:
1.43 bertrand 45: integer8 nombre_colonnes;
1.1 bertrand 46:
47: (*s_etat_processus).erreur_execution = d_ex;
48:
49: if ((*s_etat_processus).affichage_arguments == 'Y')
50: {
51: printf("\n SDEV ");
52:
53: if ((*s_etat_processus).langue == 'F')
54: {
55: printf("(écart-type)\n\n");
56: }
57: else
58: {
59: printf("(standard deviation)\n\n");
60: }
61:
62: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);
63:
64: return;
65: }
66: else if ((*s_etat_processus).test_instruction == 'Y')
67: {
68: (*s_etat_processus).nombre_arguments = -1;
69: return;
70: }
71:
72: if (test_cfsf(s_etat_processus, 31) == d_vrai)
73: {
74: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
75: {
76: return;
77: }
78: }
79:
80: /*
81: * Recherche d'une variable globale référencée par SIGMA
82: */
83:
1.20 bertrand 84: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 85: {
86: /*
87: * Aucune variable SIGMA
88: */
89:
90: (*s_etat_processus).erreur_systeme = d_es;
1.20 bertrand 91:
92: if ((*s_etat_processus).erreur_execution == d_ex)
93: {
94: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
95: }
96:
1.1 bertrand 97: return;
98: }
99: else
100: {
1.20 bertrand 101: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
102: .type != MIN) && ((*(*(*s_etat_processus)
103: .pointeur_variable_courante).objet).type != MRL))
1.1 bertrand 104: {
1.20 bertrand 105: (*s_etat_processus).erreur_execution =
106: d_ex_matrice_statistique_invalide;
1.1 bertrand 107: return;
108: }
109:
1.20 bertrand 110: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
111: .pointeur_variable_courante).objet).objet)).nombre_colonnes;
1.1 bertrand 112: }
113:
1.20 bertrand 114: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
115: .objet;
1.1 bertrand 116:
117: if (((*s_objet_statistique).type == MIN) ||
118: ((*s_objet_statistique).type == MRL))
119: {
120: if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes
121: <= 1)
122: {
123: (*s_etat_processus).erreur_execution =
124: d_ex_statistiques_echantillon;
125: return;
126: }
127:
128: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
129: {
130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
131: return;
132: }
133:
134: if (((*s_objet_resultat).objet = ecart_type_statistique(
1.53 bertrand 135: s_etat_processus,
1.1 bertrand 136: (struct_matrice *) (*s_objet_statistique).objet, 'E')) == NULL)
137: {
138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
139: return;
140: }
141:
142: if (nombre_colonnes == 1)
143: {
144: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
145: {
146: (*s_objet_resultat).type = VIN;
147: s_objet_temporaire = s_objet_resultat;
148:
149: if ((s_objet_resultat = allocation(s_etat_processus, INT))
150: == NULL)
151: {
152: (*s_etat_processus).erreur_systeme =
153: d_es_allocation_memoire;
154: return;
155: }
156:
157: (*((integer8 *) (*s_objet_resultat).objet)) =
158: ((integer8 *) (*((struct_vecteur *)
159: (*s_objet_temporaire).objet)).tableau)[0];
160:
161: liberation(s_etat_processus, s_objet_temporaire);
162: }
163: else
164: {
165: (*s_objet_resultat).type = VRL;
166: s_objet_temporaire = s_objet_resultat;
167:
168: if ((s_objet_resultat = allocation(s_etat_processus, REL))
169: == NULL)
170: {
171: (*s_etat_processus).erreur_systeme =
172: d_es_allocation_memoire;
173: return;
174: }
175:
176: (*((real8 *) (*s_objet_resultat).objet)) =
177: ((real8 *) (*((struct_vecteur *)
178: (*s_objet_temporaire).objet)).tableau)[0];
179:
180: liberation(s_etat_processus, s_objet_temporaire);
181: }
182: }
183: else
184: {
185: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
186: {
187: (*s_objet_resultat).type = VIN;
188: }
189: else
190: {
191: (*s_objet_resultat).type = VRL;
192: }
193: }
194:
195: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
196: s_objet_resultat) == d_erreur)
197: {
198: return;
199: }
200: }
201: else
202: {
203: (*s_etat_processus).erreur_execution =
204: d_ex_matrice_statistique_invalide;
205: return;
206: }
207:
208: return;
209: }
210:
211:
212: /*
213: ================================================================================
214: Fonction 'schur'
215: ================================================================================
216: Entrées :
217: --------------------------------------------------------------------------------
218: Sorties :
219: --------------------------------------------------------------------------------
220: Effets de bord : néant
221: ================================================================================
222: */
223:
224: void
225: instruction_schur(struct_processus *s_etat_processus)
226: {
227: struct_matrice *s_matrice;
228:
229: struct_objet *s_copie_argument;
230: struct_objet *s_objet_argument;
231: struct_objet *s_objet_resultat;
232:
233: (*s_etat_processus).erreur_execution = d_ex;
234:
235: if ((*s_etat_processus).affichage_arguments == 'Y')
236: {
237: printf("\n SCHUR ");
238:
239: if ((*s_etat_processus).langue == 'F')
240: {
241: printf("(décomposition de Schur)\n\n");
242: }
243: else
244: {
245: printf("(Schur decomposition)\n\n");
246: }
247:
248: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
249: printf("-> 2: %s, %s\n", d_MRL, d_MCX);
250: printf(" 1: %s, %s\n", d_MRL, d_MCX);
251:
252: return;
253: }
254: else if ((*s_etat_processus).test_instruction == 'Y')
255: {
256: (*s_etat_processus).nombre_arguments = -1;
257: return;
258: }
259:
260: if (test_cfsf(s_etat_processus, 31) == d_vrai)
261: {
262: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
263: {
264: return;
265: }
266: }
267:
268: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
269: &s_objet_argument) == d_erreur)
270: {
271: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
272: return;
273: }
274:
275: /*
276: --------------------------------------------------------------------------------
277: Décomposition de Schur réelle
278: --------------------------------------------------------------------------------
279: */
280:
281: if (((*s_objet_argument).type == MIN) ||
282: ((*s_objet_argument).type == MRL))
283: {
284: if ((s_copie_argument = copie_objet(s_etat_processus,
285: s_objet_argument, 'Q')) == NULL)
286: {
287: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
288: return;
289: }
290:
291: liberation(s_etat_processus, s_objet_argument);
292: s_objet_argument = s_copie_argument;
293:
294: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
295: (*((struct_matrice *) (*s_objet_argument).objet))
296: .nombre_colonnes)
297: {
298: liberation(s_etat_processus, s_objet_argument);
299:
300: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
301: return;
302: }
303:
304: if ((s_matrice = malloc(sizeof(struct_matrice)))
305: == NULL)
306: {
307: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
308: return;
309: }
310:
311: factorisation_schur(s_etat_processus, (*s_objet_argument).objet,
312: &s_matrice);
313:
314: if ((*s_etat_processus).erreur_systeme != d_es)
315: {
316: return;
317: }
318:
319: if (((*s_etat_processus).exception != d_ep) ||
320: ((*s_etat_processus).erreur_execution != d_ex))
321: {
322: free(s_matrice);
323: liberation(s_etat_processus, s_objet_argument);
324: return;
325: }
326:
327: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
328: {
329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
330: return;
331: }
332:
333: (*s_objet_resultat).objet = s_matrice;
334: (*s_objet_resultat).type = MRL;
335: (*s_objet_argument).type = MRL;
336: }
337:
338: /*
339: --------------------------------------------------------------------------------
340: Décomposition de Schur complexe
341: --------------------------------------------------------------------------------
342: */
343:
344: else if ((*s_objet_argument).type == MCX)
345: {
346: if ((s_copie_argument = copie_objet(s_etat_processus,
347: s_objet_argument, 'Q')) == NULL)
348: {
349: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
350: return;
351: }
352:
353: liberation(s_etat_processus, s_objet_argument);
354: s_objet_argument = s_copie_argument;
355:
356: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
357: (*((struct_matrice *) (*s_objet_argument).objet))
358: .nombre_colonnes)
359: {
360: liberation(s_etat_processus, s_objet_argument);
361:
362: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
363: return;
364: }
365:
366: if ((s_matrice = malloc(sizeof(struct_matrice)))
367: == NULL)
368: {
369: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
370: return;
371: }
372:
373: factorisation_schur(s_etat_processus, (*s_objet_argument).objet,
374: &s_matrice);
375:
376: if ((*s_etat_processus).erreur_systeme != d_es)
377: {
378: return;
379: }
380:
381: if (((*s_etat_processus).exception != d_ep) ||
382: ((*s_etat_processus).erreur_execution != d_ex))
383: {
384: free(s_matrice);
385: liberation(s_etat_processus, s_objet_argument);
386: return;
387: }
388:
389: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
390: {
391: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
392: return;
393: }
394:
395: (*s_objet_resultat).objet = s_matrice;
396: (*s_objet_resultat).type = MCX;
397: }
398:
399: /*
400: --------------------------------------------------------------------------------
401: Type d'argument invalide
402: --------------------------------------------------------------------------------
403: */
404:
405: else
406: {
407: liberation(s_etat_processus, s_objet_argument);
408:
409: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
410: return;
411: }
412:
413: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
414: s_objet_argument) == d_erreur)
415: {
416: return;
417: }
418:
419: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
420: s_objet_resultat) == d_erreur)
421: {
422: return;
423: }
424:
425: return;
426: }
427:
428:
429: /*
430: ================================================================================
431: Fonction 'sync'
432: ================================================================================
433: Entrées :
434: --------------------------------------------------------------------------------
435: Sorties :
436: --------------------------------------------------------------------------------
437: Effets de bord : néant
438: ================================================================================
439: */
440:
441: void
442: instruction_sync(struct_processus *s_etat_processus)
443: {
1.5 bertrand 444: struct_descripteur_fichier *descripteur;
1.1 bertrand 445:
446: struct_objet *s_objet_argument;
447:
448: (*s_etat_processus).erreur_execution = d_ex;
449:
450: if ((*s_etat_processus).affichage_arguments == 'Y')
451: {
452: printf("\n SYNC ");
453:
454: if ((*s_etat_processus).langue == 'F')
455: {
456: printf("(synchronisation d'un fichier)\n\n");
457: }
458: else
459: {
460: printf("(synchronising a file)\n\n");
461: }
462:
463: printf(" 1: %s\n", d_FCH);
464:
465: return;
466: }
467: else if ((*s_etat_processus).test_instruction == 'Y')
468: {
469: (*s_etat_processus).nombre_arguments = -1;
470: return;
471: }
472:
473: if (test_cfsf(s_etat_processus, 31) == d_vrai)
474: {
475: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
476: {
477: return;
478: }
479: }
480:
481: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
482: &s_objet_argument) == d_erreur)
483: {
484: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
485: return;
486: }
487:
488: if ((*s_objet_argument).type == FCH)
489: {
490: if ((descripteur = descripteur_fichier(s_etat_processus,
491: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
492: {
493: return;
494: }
495:
1.5 bertrand 496: if ((*descripteur).type != 'C')
497: {
498: liberation(s_etat_processus, s_objet_argument);
499:
500: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
501: return;
502: }
503:
504: if (fflush((*descripteur).descripteur_c) != 0)
1.1 bertrand 505: {
506: liberation(s_etat_processus, s_objet_argument);
507:
508: (*s_etat_processus).erreur_execution =
509: d_ex_erreur_acces_fichier;
510: return;
511: }
1.61 bertrand 512:
513: if (fsync(fileno((*descripteur).descripteur_c)) != 0)
514: {
1.62 bertrand 515: if ((errno != EROFS) && (errno != EINVAL))
516: {
517: liberation(s_etat_processus, s_objet_argument);
1.61 bertrand 518:
1.62 bertrand 519: (*s_etat_processus).erreur_execution =
520: d_ex_erreur_acces_fichier;
521: return;
522: }
1.61 bertrand 523: }
1.1 bertrand 524: }
525: else
526: {
527: liberation(s_etat_processus, s_objet_argument);
528:
529: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
530: return;
531: }
532:
533: liberation(s_etat_processus, s_objet_argument);
534:
535: return;
536: }
537:
538:
539: /*
540: ================================================================================
541: Fonction 'scale'
542: ================================================================================
543: Entrées :
544: --------------------------------------------------------------------------------
545: Sorties :
546: --------------------------------------------------------------------------------
547: Effets de bord : néant
548: ================================================================================
549: */
550:
551: void
552: instruction_scale(struct_processus *s_etat_processus)
553: {
554: /*
555: * Prend comme argument une liste
556: */
557:
558: long nombre_arguments_principaux;
559: long nombre_arguments_auxiliaires;
560:
561: struct_liste_chainee *l_element_courant;
562: struct_liste_chainee *l_element_courant_auxiliaire;
563:
564: struct_objet *s_objet_argument;
565: struct_objet *s_objet_auxiliaire;
566:
567: unsigned char *tampon;
568:
569: (*s_etat_processus).erreur_execution = d_ex;
570:
571: if ((*s_etat_processus).affichage_arguments == 'Y')
572: {
573: printf("\n SCALE ");
574:
575: if ((*s_etat_processus).langue == 'F')
576: {
577: printf("(définition de l'échelle)\n\n");
578: }
579: else
580: {
581: printf("(scale definition)\n\n");
582: }
583:
584: printf(" 1: %s\n\n", d_LST);
585:
586: if ((*s_etat_processus).langue == 'F')
587: {
588: printf(" Utilisation :\n\n");
589: }
590: else
591: {
592: printf(" Usage:\n\n");
593: }
594:
595: printf(" { { Xmin Xmax } { Ymin Ymax } { Zmin Zmax } } SCALE\n");
596: printf(" { \"AUTOMATIC\" { Ymin Ymax } } SCALE\n");
597:
598: return;
599: }
600: else if ((*s_etat_processus).test_instruction == 'Y')
601: {
602: (*s_etat_processus).nombre_arguments = -1;
603: return;
604: }
605:
606: if (test_cfsf(s_etat_processus, 31) == d_vrai)
607: {
608: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
609: {
610: return;
611: }
612: }
613:
614: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
615: &s_objet_argument) == d_erreur)
616: {
617: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
618: return;
619: }
620:
621: if ((*s_objet_argument).type == LST)
622: {
623: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
624: nombre_arguments_principaux = 0;
625:
626: while(l_element_courant != NULL)
627: {
628: nombre_arguments_principaux++;
629: l_element_courant = (*l_element_courant).suivant;
630: }
631:
632: if ((nombre_arguments_principaux != 2) &&
633: (nombre_arguments_principaux != 3))
634: {
635: liberation(s_etat_processus, s_objet_argument);
636:
637: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
638: return;
639: }
640:
641: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
642: nombre_arguments_principaux = 0;
643:
644: while(l_element_courant != NULL)
645: {
646: nombre_arguments_principaux++;
647:
648: if ((*(*l_element_courant).donnee).type == LST)
649: {
650: l_element_courant_auxiliaire = (struct_liste_chainee *)
651: (*(*l_element_courant).donnee).objet;
652: nombre_arguments_auxiliaires = 0;
653:
654: while(l_element_courant_auxiliaire != NULL)
655: {
656: l_element_courant_auxiliaire =
657: (*l_element_courant_auxiliaire).suivant;
658: nombre_arguments_auxiliaires++;
659: }
660:
661: if (nombre_arguments_auxiliaires != 2)
662: {
663: liberation(s_etat_processus, s_objet_argument);
664:
665: (*s_etat_processus).erreur_execution =
666: d_ex_argument_invalide;
667: return;
668: }
669:
670: l_element_courant_auxiliaire = (struct_liste_chainee *)
671: (*(*l_element_courant).donnee).objet;
672: nombre_arguments_auxiliaires = 0;
673:
674: while(l_element_courant_auxiliaire != NULL)
675: {
676: nombre_arguments_auxiliaires++;
677:
678: if (((*(*l_element_courant_auxiliaire).donnee).type ==
679: RPN) || (
680: (*(*l_element_courant_auxiliaire).donnee)
681: .type == ALG) ||
682: ((*(*l_element_courant_auxiliaire).donnee)
683: .type == NOM))
684: {
685: if (evaluation(s_etat_processus,
686: (*l_element_courant_auxiliaire).donnee, 'N')
687: == d_erreur)
688: {
689: liberation(s_etat_processus, s_objet_argument);
690:
691: return;
692: }
693:
694: if (depilement(s_etat_processus,
695: &((*s_etat_processus).l_base_pile),
696: &s_objet_auxiliaire) == d_erreur)
697: {
698: liberation(s_etat_processus, s_objet_argument);
699:
700: (*s_etat_processus).erreur_execution =
701: d_ex_manque_argument;
702: return;
703: }
704:
705: liberation(s_etat_processus,
706: (*l_element_courant_auxiliaire).donnee);
707: (*l_element_courant_auxiliaire).donnee =
708: s_objet_auxiliaire;
709: }
710:
711: if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
712: {
713: switch(nombre_arguments_principaux)
714: {
715: case 1 :
716: {
717: if (nombre_arguments_auxiliaires == 1)
718: {
719: if ((*s_etat_processus).systeme_axes == 0)
720: {
721: (*s_etat_processus).x_min = (real8)
722: (*((integer8 *) (*
723: (*l_element_courant_auxiliaire)
724: .donnee).objet));
725: }
726: else
727: {
728: (*s_etat_processus).x2_min = (real8)
729: (*((integer8 *) (*
730: (*l_element_courant_auxiliaire)
731: .donnee).objet));
732: }
733: }
734: else if (nombre_arguments_auxiliaires == 2)
735: {
736: if ((*s_etat_processus).systeme_axes == 0)
737: {
738: (*s_etat_processus).x_max = (real8)
739: (*((integer8 *) (*
740: (*l_element_courant_auxiliaire)
741: .donnee).objet));
742: (*s_etat_processus)
743: .echelle_automatique_x = d_faux;
744: }
745: else
746: {
747: (*s_etat_processus).x2_max = (real8)
748: (*((integer8 *) (*
749: (*l_element_courant_auxiliaire)
750: .donnee).objet));
751: (*s_etat_processus)
752: .echelle_automatique_x2
753: = d_faux;
754: }
755: }
756: else
757: {
758: liberation(s_etat_processus,
759: s_objet_argument);
760:
761: (*s_etat_processus).erreur_execution =
762: d_ex_argument_invalide;
763: return;
764: }
765:
766: break;
767: }
768:
769: case 2 :
770: {
771: if (nombre_arguments_auxiliaires == 1)
772: {
773: if ((*s_etat_processus).systeme_axes == 0)
774: {
775: (*s_etat_processus).y_min = (real8)
776: (*((integer8 *) (*
777: (*l_element_courant_auxiliaire)
778: .donnee).objet));
779: }
780: else
781: {
782: (*s_etat_processus).y2_min = (real8)
783: (*((integer8 *) (*
784: (*l_element_courant_auxiliaire)
785: .donnee).objet));
786: }
787: }
788: else if (nombre_arguments_auxiliaires == 2)
789: {
790: if ((*s_etat_processus).systeme_axes == 0)
791: {
792: (*s_etat_processus).y_max = (real8)
793: (*((integer8 *) (*
794: (*l_element_courant_auxiliaire)
795: .donnee).objet));
796:
797: (*s_etat_processus)
798: .echelle_automatique_y = d_faux;
799: }
800: else
801: {
802: (*s_etat_processus).y2_max = (real8)
803: (*((integer8 *) (*
804: (*l_element_courant_auxiliaire)
805: .donnee).objet));
806:
807: (*s_etat_processus)
808: .echelle_automatique_y2
809: = d_faux;
810: }
811: }
812: else
813: {
814: liberation(s_etat_processus,
815: s_objet_argument);
816:
817: (*s_etat_processus).erreur_execution =
818: d_ex_argument_invalide;
819: return;
820: }
821:
822: break;
823: }
824:
825: case 3 :
826: {
827: if (nombre_arguments_auxiliaires == 1)
828: {
829: if ((*s_etat_processus).systeme_axes == 0)
830: {
831: (*s_etat_processus).z_min = (real8)
832: (*((integer8 *) (*
833: (*l_element_courant_auxiliaire)
834: .donnee).objet));
835: }
836: else
837: {
838: (*s_etat_processus).z2_min = (real8)
839: (*((integer8 *) (*
840: (*l_element_courant_auxiliaire)
841: .donnee).objet));
842: }
843: }
844: else if (nombre_arguments_auxiliaires == 2)
845: {
846: if ((*s_etat_processus).systeme_axes == 0)
847: {
848: (*s_etat_processus).z_max = (real8)
849: (*((integer8 *) (*
850: (*l_element_courant_auxiliaire)
851: .donnee).objet));
852:
853: (*s_etat_processus)
854: .echelle_automatique_z = d_faux;
855: }
856: else
857: {
858: (*s_etat_processus).z2_max = (real8)
859: (*((integer8 *) (*
860: (*l_element_courant_auxiliaire)
861: .donnee).objet));
862:
863: (*s_etat_processus)
864: .echelle_automatique_z
865: = d_faux;
866: }
867: }
868: else
869: {
870: liberation(s_etat_processus,
871: s_objet_argument);
872:
873: (*s_etat_processus).erreur_execution =
874: d_ex_argument_invalide;
875: return;
876: }
877:
878: break;
879: }
880:
881: default :
882: {
883: liberation(s_etat_processus, s_objet_argument);
884:
885: (*s_etat_processus).erreur_execution =
886: d_ex_argument_invalide;
887: return;
888: }
889: }
890: }
891: else if ((*(*l_element_courant_auxiliaire)
892: .donnee).type == REL)
893: {
894: switch(nombre_arguments_principaux)
895: {
896: case 1 :
897: {
898: if (nombre_arguments_auxiliaires == 1)
899: {
900: if ((*s_etat_processus).systeme_axes == 0)
901: {
902: (*s_etat_processus).x_min =
903: (*((real8 *) (*
904: (*l_element_courant_auxiliaire)
905: .donnee).objet));
906: }
907: else
908: {
909: (*s_etat_processus).x2_min =
910: (*((real8 *) (*
911: (*l_element_courant_auxiliaire)
912: .donnee).objet));
913: }
914: }
915: else if (nombre_arguments_auxiliaires == 2)
916: {
917: if ((*s_etat_processus).systeme_axes == 0)
918: {
919: (*s_etat_processus).x_max =
920: (*((real8 *) (*
921: (*l_element_courant_auxiliaire)
922: .donnee).objet));
923:
924: (*s_etat_processus)
925: .echelle_automatique_x = d_faux;
926: }
927: else
928: {
929: (*s_etat_processus).x2_max =
930: (*((real8 *) (*
931: (*l_element_courant_auxiliaire)
932: .donnee).objet));
933:
934: (*s_etat_processus)
935: .echelle_automatique_x2
936: = d_faux;
937: }
938: }
939: else
940: {
941: liberation(s_etat_processus,
942: s_objet_argument);
943:
944: (*s_etat_processus).erreur_execution =
945: d_ex_argument_invalide;
946: return;
947: }
948:
949: break;
950: }
951:
952: case 2 :
953: {
954: if (nombre_arguments_auxiliaires == 1)
955: {
956: if ((*s_etat_processus).systeme_axes == 0)
957: {
958: (*s_etat_processus).y_min =
959: (*((real8 *) (*
960: (*l_element_courant_auxiliaire)
961: .donnee).objet));
962: }
963: else
964: {
965: (*s_etat_processus).y2_min =
966: (*((real8 *) (*
967: (*l_element_courant_auxiliaire)
968: .donnee).objet));
969: }
970: }
971: else if (nombre_arguments_auxiliaires == 2)
972: {
973: if ((*s_etat_processus).systeme_axes == 0)
974: {
975: (*s_etat_processus).y_max =
976: (*((real8 *) (*
977: (*l_element_courant_auxiliaire)
978: .donnee).objet));
979:
980: (*s_etat_processus)
981: .echelle_automatique_y = d_faux;
982: }
983: else
984: {
985: (*s_etat_processus).y2_max =
986: (*((real8 *) (*
987: (*l_element_courant_auxiliaire)
988: .donnee).objet));
989:
990: (*s_etat_processus)
991: .echelle_automatique_y2
992: = d_faux;
993: }
994: }
995: else
996: {
997: liberation(s_etat_processus,
998: s_objet_argument);
999:
1000: (*s_etat_processus).erreur_execution =
1001: d_ex_argument_invalide;
1002: return;
1003: }
1004:
1005: break;
1006: }
1007:
1008: case 3 :
1009: {
1010: if (nombre_arguments_auxiliaires == 1)
1011: {
1012: if ((*s_etat_processus).systeme_axes == 0)
1013: {
1014: (*s_etat_processus).z_min =
1015: (*((real8 *) (*
1016: (*l_element_courant_auxiliaire)
1017: .donnee).objet));
1018: }
1019: else
1020: {
1021: (*s_etat_processus).z2_min =
1022: (*((real8 *) (*
1023: (*l_element_courant_auxiliaire)
1024: .donnee).objet));
1025: }
1026: }
1027: else if (nombre_arguments_auxiliaires == 2)
1028: {
1029: if ((*s_etat_processus).systeme_axes == 0)
1030: {
1031: (*s_etat_processus).z_max =
1032: (*((real8 *) (*
1033: (*l_element_courant_auxiliaire)
1034: .donnee).objet));
1035:
1036: (*s_etat_processus)
1037: .echelle_automatique_z = d_faux;
1038: }
1039: else
1040: {
1041: (*s_etat_processus).z2_max =
1042: (*((real8 *) (*
1043: (*l_element_courant_auxiliaire)
1044: .donnee).objet));
1045:
1046: (*s_etat_processus)
1047: .echelle_automatique_z2
1048: = d_faux;
1049: }
1050: }
1051: else
1052: {
1053: liberation(s_etat_processus,
1054: s_objet_argument);
1055:
1056: (*s_etat_processus).erreur_execution =
1057: d_ex_argument_invalide;
1058: return;
1059: }
1060:
1061: break;
1062: }
1063:
1064: default :
1065: {
1066: liberation(s_etat_processus, s_objet_argument);
1067:
1068: (*s_etat_processus).erreur_execution =
1069: d_ex_argument_invalide;
1070: return;
1071: }
1072: }
1073: }
1074:
1075: l_element_courant_auxiliaire =
1076: (*l_element_courant_auxiliaire).suivant;
1077: }
1078: }
1079: else if ((*(*l_element_courant).donnee).type == CHN)
1080: {
1.53 bertrand 1081: tampon = conversion_majuscule(s_etat_processus,
1082: (unsigned char *) (*(*l_element_courant).donnee).objet);
1.1 bertrand 1083:
1084: if (tampon == NULL)
1085: {
1086: (*s_etat_processus).erreur_systeme =
1087: d_es_allocation_memoire;
1088: return;
1089: }
1090:
1091: if (strcmp(tampon, "AUTOMATIC") == 0)
1092: {
1093: switch(nombre_arguments_principaux)
1094: {
1095: case 1 :
1096: {
1097: if ((*s_etat_processus).systeme_axes == 0)
1098: {
1099: (*s_etat_processus).echelle_automatique_x
1100: = d_vrai;
1101: }
1102: else
1103: {
1104: (*s_etat_processus).echelle_automatique_x2
1105: = d_vrai;
1106: }
1107:
1108: break;
1109: }
1110:
1111: case 2 :
1112: {
1113: if ((*s_etat_processus).systeme_axes == 0)
1114: {
1115: (*s_etat_processus).echelle_automatique_y
1116: = d_vrai;
1117: }
1118: else
1119: {
1120: (*s_etat_processus).echelle_automatique_y2
1121: = d_vrai;
1122: }
1123:
1124: break;
1125: }
1126:
1127: case 3 :
1128: {
1129: if ((*s_etat_processus).systeme_axes == 0)
1130: {
1131: (*s_etat_processus).echelle_automatique_z
1132: = d_vrai;
1133: }
1134: else
1135: {
1136: (*s_etat_processus).echelle_automatique_z2
1137: = d_vrai;
1138: }
1139:
1140: break;
1141: }
1142:
1143: default :
1144: {
1145: liberation(s_etat_processus, s_objet_argument);
1146: free(tampon);
1147:
1148: (*s_etat_processus).erreur_execution =
1149: d_ex_argument_invalide;
1150: return;
1151: }
1152: }
1153: }
1154: else
1155: {
1156: liberation(s_etat_processus, s_objet_argument);
1157: free(tampon);
1158:
1159: (*s_etat_processus).erreur_execution =
1160: d_ex_argument_invalide;
1161: return;
1162: }
1163:
1164: free(tampon);
1165: }
1166: else
1167: {
1168: liberation(s_etat_processus, s_objet_argument);
1169:
1170: (*s_etat_processus).erreur_execution =
1171: d_ex_erreur_type_argument;
1172: return;
1173: }
1174:
1175: l_element_courant = (*l_element_courant).suivant;
1176: }
1177: }
1178: else
1179: {
1180: liberation(s_etat_processus, s_objet_argument);
1181:
1182: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1183: return;
1184: }
1185:
1186: liberation(s_etat_processus, s_objet_argument);
1187:
1188: if (test_cfsf(s_etat_processus, 52) == d_faux)
1189: {
1190: if ((*s_etat_processus).fichiers_graphiques != NULL)
1191: {
1192: appel_gnuplot(s_etat_processus, 'N');
1193: }
1194: }
1195:
1196: return;
1197: }
1198:
1199:
1200: /*
1201: ================================================================================
1202: Fonction 'scls'
1203: ================================================================================
1204: Entrées :
1205: --------------------------------------------------------------------------------
1206: Sorties :
1207: --------------------------------------------------------------------------------
1208: Effets de bord : néant
1209: ================================================================================
1210: */
1211:
1212: void
1213: instruction_scls(struct_processus *s_etat_processus)
1214: {
1215: logical1 matrice_entiere;
1216:
1217: real8 valeur_courante;
1218:
1219: struct_objet *s_objet_statistique;
1220:
1.43 bertrand 1221: integer8 j;
1.1 bertrand 1222:
1223: (*s_etat_processus).erreur_execution = d_ex;
1224:
1225: if ((*s_etat_processus).affichage_arguments == 'Y')
1226: {
1227: printf("\n SCLS ");
1228:
1229: if ((*s_etat_processus).langue == 'F')
1230: {
1231: printf("(échelle automatique d'un nuage de points)\n\n");
1232: printf(" Aucun argument\n");
1233: }
1234: else
1235: {
1236: printf("(auto scale scatter plot)\n\n");
1237: printf(" No argument\n");
1238: }
1239:
1240: return;
1241: }
1242: else if ((*s_etat_processus).test_instruction == 'Y')
1243: {
1244: (*s_etat_processus).nombre_arguments = -1;
1245: return;
1246: }
1247:
1248: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1249: {
1250: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1251: {
1252: return;
1253: }
1254: }
1255:
1256: /*
1257: * Vérification de la présence de la matrice statistique
1258: */
1259:
1.20 bertrand 1260: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 1261: {
1262: /*
1263: * Aucune variable ds_sdat n'existe.
1264: */
1265:
1.20 bertrand 1266: if ((*s_etat_processus).erreur_execution == d_ex)
1.1 bertrand 1267: {
1.20 bertrand 1268: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1.1 bertrand 1269: }
1270:
1.20 bertrand 1271: (*s_etat_processus).erreur_systeme = d_es;
1.1 bertrand 1272: return;
1273: }
1274:
1.20 bertrand 1275: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
1276: .objet;
1.1 bertrand 1277:
1278: if ((*s_objet_statistique).type == MIN)
1279: {
1280: matrice_entiere = d_vrai;
1281: }
1282: else if ((*s_objet_statistique).type == MRL)
1283: {
1284: matrice_entiere = d_faux;
1285: }
1286: else
1287: {
1288: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1289: return;
1290: }
1291:
1292: switch((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_colonnes)
1293: {
1294: /*
1295: * Une colonne
1296: */
1297:
1298: case 1 :
1299: {
1300: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1301: break;
1302: }
1303:
1304: /*
1305: * Deux colonnes ou plus
1306: */
1307:
1308: default :
1309: {
1310: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
1311: ((*s_etat_processus).colonne_statistique_2 < 1) ||
1312: ((*s_etat_processus).colonne_statistique_1 > (integer8)
1313: (*((struct_matrice *) (*s_objet_statistique).objet))
1314: .nombre_colonnes) ||
1315: ((*s_etat_processus).colonne_statistique_2 > (integer8)
1316: (*((struct_matrice *) (*s_objet_statistique).objet))
1317: .nombre_colonnes))
1318: {
1319: (*s_etat_processus).erreur_execution =
1320: d_ex_observations_inexistantes;
1321: return;
1322: }
1323:
1324: if (matrice_entiere == d_vrai)
1325: {
1326: if ((*s_etat_processus).systeme_axes == 0)
1327: {
1328: (*s_etat_processus).x_min = (real8) ((integer8 **)
1329: (*((struct_matrice *) (*s_objet_statistique).objet))
1330: .tableau)[0][(*s_etat_processus)
1331: .colonne_statistique_1 - 1];
1332: (*s_etat_processus).x_max = (*s_etat_processus).x_min;
1333: }
1334: else
1335: {
1336: (*s_etat_processus).x2_min = (real8) ((integer8 **)
1337: (*((struct_matrice *) (*s_objet_statistique).objet))
1338: .tableau)[0][(*s_etat_processus)
1339: .colonne_statistique_1 - 1];
1340: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1341: }
1342:
1343: if ((*s_etat_processus).systeme_axes == 0)
1344: {
1345: (*s_etat_processus).y_min = (real8) ((integer8 **)
1346: (*((struct_matrice *) (*s_objet_statistique).objet))
1347: .tableau)[0][(*s_etat_processus)
1348: .colonne_statistique_2 - 1];
1349: (*s_etat_processus).y_max = (*s_etat_processus).y_min;
1350: }
1351: else
1352: {
1353: (*s_etat_processus).y2_min = (real8) ((integer8 **)
1354: (*((struct_matrice *) (*s_objet_statistique).objet))
1355: .tableau)[0][(*s_etat_processus)
1356: .colonne_statistique_2 - 1];
1357: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1358: }
1359: }
1360: else
1361: {
1362: if ((*s_etat_processus).systeme_axes == 0)
1363: {
1364: (*s_etat_processus).x_min = ((real8 **)
1365: (*((struct_matrice *) (*s_objet_statistique).objet))
1366: .tableau)[0][(*s_etat_processus)
1367: .colonne_statistique_1 - 1];
1368: (*s_etat_processus).x_max = (*s_etat_processus).x_min;
1369: }
1370: else
1371: {
1372: (*s_etat_processus).x2_min = ((real8 **)
1373: (*((struct_matrice *) (*s_objet_statistique).objet))
1374: .tableau)[0][(*s_etat_processus)
1375: .colonne_statistique_1 - 1];
1376: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1377: }
1378:
1379: if ((*s_etat_processus).systeme_axes == 0)
1380: {
1381: (*s_etat_processus).y_min = ((real8 **)
1382: (*((struct_matrice *) (*s_objet_statistique).objet))
1383: .tableau)[0][(*s_etat_processus)
1384: .colonne_statistique_2 - 1];
1385: (*s_etat_processus).y_max = (*s_etat_processus).y_min;
1386: }
1387: else
1388: {
1389: (*s_etat_processus).y2_min = ((real8 **)
1390: (*((struct_matrice *) (*s_objet_statistique).objet))
1391: .tableau)[0][(*s_etat_processus)
1392: .colonne_statistique_2 - 1];
1393: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1394: }
1395: }
1396:
1397: for(j = 1; j < (*((struct_matrice *) (*s_objet_statistique).objet))
1398: .nombre_lignes; j++)
1399: {
1400: if (matrice_entiere == d_vrai)
1401: {
1402: valeur_courante = (real8) ((integer8 **)
1403: (*((struct_matrice *) (*s_objet_statistique).objet))
1404: .tableau)[j][(*s_etat_processus)
1405: .colonne_statistique_1 - 1];
1406:
1407: if ((*s_etat_processus).systeme_axes == 0)
1408: {
1409: if (valeur_courante < (*s_etat_processus).x_min)
1410: {
1411: (*s_etat_processus).x_min = valeur_courante;
1412: }
1413:
1414: if (valeur_courante > (*s_etat_processus).x_max)
1415: {
1416: (*s_etat_processus).x_max = valeur_courante;
1417: }
1418: }
1419: else
1420: {
1421: if (valeur_courante < (*s_etat_processus).x2_min)
1422: {
1423: (*s_etat_processus).x2_min = valeur_courante;
1424: }
1425:
1426: if (valeur_courante > (*s_etat_processus).x2_max)
1427: {
1428: (*s_etat_processus).x2_max = valeur_courante;
1429: }
1430: }
1431:
1432: valeur_courante = (real8) ((integer8 **)
1433: (*((struct_matrice *) (*s_objet_statistique).objet))
1434: .tableau)[j][(*s_etat_processus)
1435: .colonne_statistique_2 - 1];
1436:
1437: if ((*s_etat_processus).systeme_axes == 0)
1438: {
1439: if (valeur_courante < (*s_etat_processus).y_min)
1440: {
1441: (*s_etat_processus).y_min = valeur_courante;
1442: }
1443:
1444: if (valeur_courante > (*s_etat_processus).y_max)
1445: {
1446: (*s_etat_processus).y_max = valeur_courante;
1447: }
1448: }
1449: else
1450: {
1451: if (valeur_courante < (*s_etat_processus).y2_min)
1452: {
1453: (*s_etat_processus).y2_min = valeur_courante;
1454: }
1455:
1456: if (valeur_courante > (*s_etat_processus).y2_max)
1457: {
1458: (*s_etat_processus).y2_max = valeur_courante;
1459: }
1460: }
1461: }
1462: else
1463: {
1464: valeur_courante = ((real8 **)
1465: (*((struct_matrice *) (*s_objet_statistique).objet))
1466: .tableau)[j][(*s_etat_processus)
1467: .colonne_statistique_1 - 1];
1468:
1469: if ((*s_etat_processus).systeme_axes == 0)
1470: {
1471: if (valeur_courante < (*s_etat_processus).x_min)
1472: {
1473: (*s_etat_processus).x_min = valeur_courante;
1474: }
1475:
1476: if (valeur_courante > (*s_etat_processus).x_max)
1477: {
1478: (*s_etat_processus).x_max = valeur_courante;
1479: }
1480: }
1481: else
1482: {
1483: if (valeur_courante < (*s_etat_processus).x2_min)
1484: {
1485: (*s_etat_processus).x2_min = valeur_courante;
1486: }
1487:
1488: if (valeur_courante > (*s_etat_processus).x2_max)
1489: {
1490: (*s_etat_processus).x2_max = valeur_courante;
1491: }
1492: }
1493:
1494: valeur_courante = ((real8 **)
1495: (*((struct_matrice *) (*s_objet_statistique).objet))
1496: .tableau)[j][(*s_etat_processus)
1497: .colonne_statistique_2 - 1];
1498:
1499: if ((*s_etat_processus).systeme_axes == 0)
1500: {
1501: if (valeur_courante < (*s_etat_processus).y_min)
1502: {
1503: (*s_etat_processus).y_min = valeur_courante;
1504: }
1505:
1506: if (valeur_courante > (*s_etat_processus).y_max)
1507: {
1508: (*s_etat_processus).y_max = valeur_courante;
1509: }
1510: }
1511: else
1512: {
1513: if (valeur_courante < (*s_etat_processus).y2_min)
1514: {
1515: (*s_etat_processus).y2_min = valeur_courante;
1516: }
1517:
1518: if (valeur_courante > (*s_etat_processus).y2_max)
1519: {
1520: (*s_etat_processus).y2_max = valeur_courante;
1521: }
1522: }
1523: }
1524: }
1525:
1526: break;
1527: }
1528: }
1529:
1530: return;
1531: }
1532:
1533:
1534: /*
1535: ================================================================================
1536: Fonction 'spar'
1537: ================================================================================
1538: Entrées :
1539: --------------------------------------------------------------------------------
1540: Sorties :
1541: --------------------------------------------------------------------------------
1542: Effets de bord : néant
1543: ================================================================================
1544: */
1545:
1546: void
1547: instruction_spar(struct_processus *s_etat_processus)
1548: {
1549: logical1 presence_matrice_statistique;
1550:
1551: struct_liste_chainee *l_ancienne_base;
1552: struct_liste_chainee *l_nouvelle_base;
1553:
1554: struct_objet *s_objet_resultat;
1555:
1556: /*
1557: * { { Dimensions de SIGMA } X Y }
1558: */
1559:
1560: (*s_etat_processus).erreur_execution = d_ex;
1561:
1562: if ((*s_etat_processus).affichage_arguments == 'Y')
1563: {
1564: printf("\n SPAR ");
1565:
1566: if ((*s_etat_processus).langue == 'F')
1567: {
1568: printf("(paramètres statistiques)\n\n");
1569: }
1570: else
1571: {
1572: printf("(statistical parameters)\n\n");
1573: }
1574:
1575: printf("-> 1: %s\n", d_LST);
1576:
1577: return;
1578: }
1579: else if ((*s_etat_processus).test_instruction == 'Y')
1580: {
1581: (*s_etat_processus).nombre_arguments = -1;
1582: return;
1583: }
1584:
1585: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1586: {
1587: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1588: {
1589: return;
1590: }
1591: }
1592:
1593: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
1594: {
1595: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1596: return;
1597: }
1598:
1599: (*s_objet_resultat).objet = NULL;
1600: l_ancienne_base = (*s_objet_resultat).objet;
1601:
1602: // Colonne 2
1603:
1604: if ((l_nouvelle_base = malloc(sizeof(struct_liste_chainee))) == NULL)
1605: {
1606: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1607: return;
1608: }
1609:
1610: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1611: == NULL)
1612: {
1613: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1614: return;
1615: }
1616:
1617: (*l_nouvelle_base).suivant = l_ancienne_base;
1618: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1619: (*s_etat_processus).colonne_statistique_2;
1620: (*s_objet_resultat).objet = l_nouvelle_base;
1621: l_ancienne_base = (*s_objet_resultat).objet;
1622:
1623: // Colonne 1
1624:
1625: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1626: {
1627: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1628: return;
1629: }
1630:
1631: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1632: == NULL)
1633: {
1634: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1635: return;
1636: }
1637:
1638: (*l_nouvelle_base).suivant = l_ancienne_base;
1639: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1640: (*s_etat_processus).colonne_statistique_1;
1641: (*s_objet_resultat).objet = l_nouvelle_base;
1642: l_ancienne_base = (*s_objet_resultat).objet;
1643:
1644: // Dimensions de la matrice statistique
1645:
1646: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1647: {
1648: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1649: return;
1650: }
1651:
1652: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
1653: == NULL)
1654: {
1655: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1656: return;
1657: }
1658:
1.20 bertrand 1659: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 1660: {
1661: /*
1662: * Aucune variable SIGMA
1663: */
1664:
1665: (*s_etat_processus).erreur_systeme = d_es;
1.20 bertrand 1666:
1667: if ((*s_etat_processus).erreur_execution == d_ex)
1668: {
1669: (*s_etat_processus).erreur_execution = d_ex;
1670: }
1671:
1.1 bertrand 1672: presence_matrice_statistique = d_faux;
1673: }
1674: else
1675: {
1.20 bertrand 1676: presence_matrice_statistique = d_vrai;
1.1 bertrand 1677: }
1678:
1679: if (presence_matrice_statistique == d_faux)
1680: {
1681: if (((*(*l_nouvelle_base).donnee).objet = malloc(12 *
1682: sizeof(unsigned char))) == NULL)
1683: {
1684: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1685: return;
1686: }
1687:
1688: (*(*l_nouvelle_base).donnee).type = CHN;
1689: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1690: "UNAVAILABLE");
1691: }
1692: else
1693: {
1.20 bertrand 1694: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
1695: .type != MIN) && ((*(*(*s_etat_processus)
1696: .pointeur_variable_courante).objet).type != MRL))
1.1 bertrand 1697: {
1698: if (((*(*l_nouvelle_base).donnee).objet = malloc(9 *
1699: sizeof(unsigned char))) == NULL)
1700: {
1701: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1702: return;
1703: }
1704:
1705: (*(*l_nouvelle_base).donnee).type = CHN;
1706: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1707: "DISABLED");
1708: }
1709: else
1710: {
1711: (*(*l_nouvelle_base).donnee).type = LST;
1712:
1713: if (((*(*l_nouvelle_base).donnee).objet =
1714: allocation_maillon(s_etat_processus)) == NULL)
1715: {
1716: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1717: return;
1718: }
1719:
1720: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1721: .objet)).donnee = allocation(s_etat_processus, INT))
1722: == NULL)
1723: {
1724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1725: return;
1726: }
1727:
1728: (*((integer8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base)
1729: .donnee).objet)).donnee)).objet)) = (*((struct_matrice *)
1.20 bertrand 1730: (*(*(*s_etat_processus).pointeur_variable_courante).objet)
1.1 bertrand 1731: .objet)).nombre_lignes;
1732:
1733: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1734: .objet)).suivant = allocation_maillon(s_etat_processus))
1735: == NULL)
1736: {
1737: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1738: return;
1739: }
1740:
1741: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
1742: .suivant).suivant = NULL;
1743:
1744: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1745: .objet)).suivant).donnee = allocation(s_etat_processus,
1746: INT)) == NULL)
1747: {
1748: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1749: return;
1750: }
1751:
1752: (*((integer8 *) (*((*(*((struct_liste_chainee *)
1753: (*(*l_nouvelle_base).donnee).objet)).suivant).donnee))
1.20 bertrand 1754: .objet)) = (*((struct_matrice *) (*(*(*s_etat_processus)
1755: .pointeur_variable_courante).objet).objet))
1.1 bertrand 1756: .nombre_colonnes;
1757: }
1758: }
1759:
1760: (*l_nouvelle_base).suivant = l_ancienne_base;
1761: (*s_objet_resultat).objet = l_nouvelle_base;
1762:
1763: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1764: s_objet_resultat) == d_erreur)
1765: {
1766: return;
1767: }
1768:
1769: return;
1770: }
1771:
1772: // vim: ts=4