![[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.59 bertrand 3: RPL/2 (R) version 4.1.26
1.60 bertrand 4: Copyright (C) 1989-2017 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: {
! 515: liberation(s_etat_processus, s_objet_argument);
! 516:
! 517: (*s_etat_processus).erreur_execution =
! 518: d_ex_erreur_acces_fichier;
! 519: return;
! 520: }
1.1 bertrand 521: }
522: else
523: {
524: liberation(s_etat_processus, s_objet_argument);
525:
526: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
527: return;
528: }
529:
530: liberation(s_etat_processus, s_objet_argument);
531:
532: return;
533: }
534:
535:
536: /*
537: ================================================================================
538: Fonction 'scale'
539: ================================================================================
540: Entrées :
541: --------------------------------------------------------------------------------
542: Sorties :
543: --------------------------------------------------------------------------------
544: Effets de bord : néant
545: ================================================================================
546: */
547:
548: void
549: instruction_scale(struct_processus *s_etat_processus)
550: {
551: /*
552: * Prend comme argument une liste
553: */
554:
555: long nombre_arguments_principaux;
556: long nombre_arguments_auxiliaires;
557:
558: struct_liste_chainee *l_element_courant;
559: struct_liste_chainee *l_element_courant_auxiliaire;
560:
561: struct_objet *s_objet_argument;
562: struct_objet *s_objet_auxiliaire;
563:
564: unsigned char *tampon;
565:
566: (*s_etat_processus).erreur_execution = d_ex;
567:
568: if ((*s_etat_processus).affichage_arguments == 'Y')
569: {
570: printf("\n SCALE ");
571:
572: if ((*s_etat_processus).langue == 'F')
573: {
574: printf("(définition de l'échelle)\n\n");
575: }
576: else
577: {
578: printf("(scale definition)\n\n");
579: }
580:
581: printf(" 1: %s\n\n", d_LST);
582:
583: if ((*s_etat_processus).langue == 'F')
584: {
585: printf(" Utilisation :\n\n");
586: }
587: else
588: {
589: printf(" Usage:\n\n");
590: }
591:
592: printf(" { { Xmin Xmax } { Ymin Ymax } { Zmin Zmax } } SCALE\n");
593: printf(" { \"AUTOMATIC\" { Ymin Ymax } } SCALE\n");
594:
595: return;
596: }
597: else if ((*s_etat_processus).test_instruction == 'Y')
598: {
599: (*s_etat_processus).nombre_arguments = -1;
600: return;
601: }
602:
603: if (test_cfsf(s_etat_processus, 31) == d_vrai)
604: {
605: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
606: {
607: return;
608: }
609: }
610:
611: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
612: &s_objet_argument) == d_erreur)
613: {
614: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
615: return;
616: }
617:
618: if ((*s_objet_argument).type == LST)
619: {
620: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
621: nombre_arguments_principaux = 0;
622:
623: while(l_element_courant != NULL)
624: {
625: nombre_arguments_principaux++;
626: l_element_courant = (*l_element_courant).suivant;
627: }
628:
629: if ((nombre_arguments_principaux != 2) &&
630: (nombre_arguments_principaux != 3))
631: {
632: liberation(s_etat_processus, s_objet_argument);
633:
634: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
635: return;
636: }
637:
638: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
639: nombre_arguments_principaux = 0;
640:
641: while(l_element_courant != NULL)
642: {
643: nombre_arguments_principaux++;
644:
645: if ((*(*l_element_courant).donnee).type == LST)
646: {
647: l_element_courant_auxiliaire = (struct_liste_chainee *)
648: (*(*l_element_courant).donnee).objet;
649: nombre_arguments_auxiliaires = 0;
650:
651: while(l_element_courant_auxiliaire != NULL)
652: {
653: l_element_courant_auxiliaire =
654: (*l_element_courant_auxiliaire).suivant;
655: nombre_arguments_auxiliaires++;
656: }
657:
658: if (nombre_arguments_auxiliaires != 2)
659: {
660: liberation(s_etat_processus, s_objet_argument);
661:
662: (*s_etat_processus).erreur_execution =
663: d_ex_argument_invalide;
664: return;
665: }
666:
667: l_element_courant_auxiliaire = (struct_liste_chainee *)
668: (*(*l_element_courant).donnee).objet;
669: nombre_arguments_auxiliaires = 0;
670:
671: while(l_element_courant_auxiliaire != NULL)
672: {
673: nombre_arguments_auxiliaires++;
674:
675: if (((*(*l_element_courant_auxiliaire).donnee).type ==
676: RPN) || (
677: (*(*l_element_courant_auxiliaire).donnee)
678: .type == ALG) ||
679: ((*(*l_element_courant_auxiliaire).donnee)
680: .type == NOM))
681: {
682: if (evaluation(s_etat_processus,
683: (*l_element_courant_auxiliaire).donnee, 'N')
684: == d_erreur)
685: {
686: liberation(s_etat_processus, s_objet_argument);
687:
688: return;
689: }
690:
691: if (depilement(s_etat_processus,
692: &((*s_etat_processus).l_base_pile),
693: &s_objet_auxiliaire) == d_erreur)
694: {
695: liberation(s_etat_processus, s_objet_argument);
696:
697: (*s_etat_processus).erreur_execution =
698: d_ex_manque_argument;
699: return;
700: }
701:
702: liberation(s_etat_processus,
703: (*l_element_courant_auxiliaire).donnee);
704: (*l_element_courant_auxiliaire).donnee =
705: s_objet_auxiliaire;
706: }
707:
708: if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
709: {
710: switch(nombre_arguments_principaux)
711: {
712: case 1 :
713: {
714: if (nombre_arguments_auxiliaires == 1)
715: {
716: if ((*s_etat_processus).systeme_axes == 0)
717: {
718: (*s_etat_processus).x_min = (real8)
719: (*((integer8 *) (*
720: (*l_element_courant_auxiliaire)
721: .donnee).objet));
722: }
723: else
724: {
725: (*s_etat_processus).x2_min = (real8)
726: (*((integer8 *) (*
727: (*l_element_courant_auxiliaire)
728: .donnee).objet));
729: }
730: }
731: else if (nombre_arguments_auxiliaires == 2)
732: {
733: if ((*s_etat_processus).systeme_axes == 0)
734: {
735: (*s_etat_processus).x_max = (real8)
736: (*((integer8 *) (*
737: (*l_element_courant_auxiliaire)
738: .donnee).objet));
739: (*s_etat_processus)
740: .echelle_automatique_x = d_faux;
741: }
742: else
743: {
744: (*s_etat_processus).x2_max = (real8)
745: (*((integer8 *) (*
746: (*l_element_courant_auxiliaire)
747: .donnee).objet));
748: (*s_etat_processus)
749: .echelle_automatique_x2
750: = d_faux;
751: }
752: }
753: else
754: {
755: liberation(s_etat_processus,
756: s_objet_argument);
757:
758: (*s_etat_processus).erreur_execution =
759: d_ex_argument_invalide;
760: return;
761: }
762:
763: break;
764: }
765:
766: case 2 :
767: {
768: if (nombre_arguments_auxiliaires == 1)
769: {
770: if ((*s_etat_processus).systeme_axes == 0)
771: {
772: (*s_etat_processus).y_min = (real8)
773: (*((integer8 *) (*
774: (*l_element_courant_auxiliaire)
775: .donnee).objet));
776: }
777: else
778: {
779: (*s_etat_processus).y2_min = (real8)
780: (*((integer8 *) (*
781: (*l_element_courant_auxiliaire)
782: .donnee).objet));
783: }
784: }
785: else if (nombre_arguments_auxiliaires == 2)
786: {
787: if ((*s_etat_processus).systeme_axes == 0)
788: {
789: (*s_etat_processus).y_max = (real8)
790: (*((integer8 *) (*
791: (*l_element_courant_auxiliaire)
792: .donnee).objet));
793:
794: (*s_etat_processus)
795: .echelle_automatique_y = d_faux;
796: }
797: else
798: {
799: (*s_etat_processus).y2_max = (real8)
800: (*((integer8 *) (*
801: (*l_element_courant_auxiliaire)
802: .donnee).objet));
803:
804: (*s_etat_processus)
805: .echelle_automatique_y2
806: = d_faux;
807: }
808: }
809: else
810: {
811: liberation(s_etat_processus,
812: s_objet_argument);
813:
814: (*s_etat_processus).erreur_execution =
815: d_ex_argument_invalide;
816: return;
817: }
818:
819: break;
820: }
821:
822: case 3 :
823: {
824: if (nombre_arguments_auxiliaires == 1)
825: {
826: if ((*s_etat_processus).systeme_axes == 0)
827: {
828: (*s_etat_processus).z_min = (real8)
829: (*((integer8 *) (*
830: (*l_element_courant_auxiliaire)
831: .donnee).objet));
832: }
833: else
834: {
835: (*s_etat_processus).z2_min = (real8)
836: (*((integer8 *) (*
837: (*l_element_courant_auxiliaire)
838: .donnee).objet));
839: }
840: }
841: else if (nombre_arguments_auxiliaires == 2)
842: {
843: if ((*s_etat_processus).systeme_axes == 0)
844: {
845: (*s_etat_processus).z_max = (real8)
846: (*((integer8 *) (*
847: (*l_element_courant_auxiliaire)
848: .donnee).objet));
849:
850: (*s_etat_processus)
851: .echelle_automatique_z = d_faux;
852: }
853: else
854: {
855: (*s_etat_processus).z2_max = (real8)
856: (*((integer8 *) (*
857: (*l_element_courant_auxiliaire)
858: .donnee).objet));
859:
860: (*s_etat_processus)
861: .echelle_automatique_z
862: = d_faux;
863: }
864: }
865: else
866: {
867: liberation(s_etat_processus,
868: s_objet_argument);
869:
870: (*s_etat_processus).erreur_execution =
871: d_ex_argument_invalide;
872: return;
873: }
874:
875: break;
876: }
877:
878: default :
879: {
880: liberation(s_etat_processus, s_objet_argument);
881:
882: (*s_etat_processus).erreur_execution =
883: d_ex_argument_invalide;
884: return;
885: }
886: }
887: }
888: else if ((*(*l_element_courant_auxiliaire)
889: .donnee).type == REL)
890: {
891: switch(nombre_arguments_principaux)
892: {
893: case 1 :
894: {
895: if (nombre_arguments_auxiliaires == 1)
896: {
897: if ((*s_etat_processus).systeme_axes == 0)
898: {
899: (*s_etat_processus).x_min =
900: (*((real8 *) (*
901: (*l_element_courant_auxiliaire)
902: .donnee).objet));
903: }
904: else
905: {
906: (*s_etat_processus).x2_min =
907: (*((real8 *) (*
908: (*l_element_courant_auxiliaire)
909: .donnee).objet));
910: }
911: }
912: else if (nombre_arguments_auxiliaires == 2)
913: {
914: if ((*s_etat_processus).systeme_axes == 0)
915: {
916: (*s_etat_processus).x_max =
917: (*((real8 *) (*
918: (*l_element_courant_auxiliaire)
919: .donnee).objet));
920:
921: (*s_etat_processus)
922: .echelle_automatique_x = d_faux;
923: }
924: else
925: {
926: (*s_etat_processus).x2_max =
927: (*((real8 *) (*
928: (*l_element_courant_auxiliaire)
929: .donnee).objet));
930:
931: (*s_etat_processus)
932: .echelle_automatique_x2
933: = d_faux;
934: }
935: }
936: else
937: {
938: liberation(s_etat_processus,
939: s_objet_argument);
940:
941: (*s_etat_processus).erreur_execution =
942: d_ex_argument_invalide;
943: return;
944: }
945:
946: break;
947: }
948:
949: case 2 :
950: {
951: if (nombre_arguments_auxiliaires == 1)
952: {
953: if ((*s_etat_processus).systeme_axes == 0)
954: {
955: (*s_etat_processus).y_min =
956: (*((real8 *) (*
957: (*l_element_courant_auxiliaire)
958: .donnee).objet));
959: }
960: else
961: {
962: (*s_etat_processus).y2_min =
963: (*((real8 *) (*
964: (*l_element_courant_auxiliaire)
965: .donnee).objet));
966: }
967: }
968: else if (nombre_arguments_auxiliaires == 2)
969: {
970: if ((*s_etat_processus).systeme_axes == 0)
971: {
972: (*s_etat_processus).y_max =
973: (*((real8 *) (*
974: (*l_element_courant_auxiliaire)
975: .donnee).objet));
976:
977: (*s_etat_processus)
978: .echelle_automatique_y = d_faux;
979: }
980: else
981: {
982: (*s_etat_processus).y2_max =
983: (*((real8 *) (*
984: (*l_element_courant_auxiliaire)
985: .donnee).objet));
986:
987: (*s_etat_processus)
988: .echelle_automatique_y2
989: = d_faux;
990: }
991: }
992: else
993: {
994: liberation(s_etat_processus,
995: s_objet_argument);
996:
997: (*s_etat_processus).erreur_execution =
998: d_ex_argument_invalide;
999: return;
1000: }
1001:
1002: break;
1003: }
1004:
1005: case 3 :
1006: {
1007: if (nombre_arguments_auxiliaires == 1)
1008: {
1009: if ((*s_etat_processus).systeme_axes == 0)
1010: {
1011: (*s_etat_processus).z_min =
1012: (*((real8 *) (*
1013: (*l_element_courant_auxiliaire)
1014: .donnee).objet));
1015: }
1016: else
1017: {
1018: (*s_etat_processus).z2_min =
1019: (*((real8 *) (*
1020: (*l_element_courant_auxiliaire)
1021: .donnee).objet));
1022: }
1023: }
1024: else if (nombre_arguments_auxiliaires == 2)
1025: {
1026: if ((*s_etat_processus).systeme_axes == 0)
1027: {
1028: (*s_etat_processus).z_max =
1029: (*((real8 *) (*
1030: (*l_element_courant_auxiliaire)
1031: .donnee).objet));
1032:
1033: (*s_etat_processus)
1034: .echelle_automatique_z = d_faux;
1035: }
1036: else
1037: {
1038: (*s_etat_processus).z2_max =
1039: (*((real8 *) (*
1040: (*l_element_courant_auxiliaire)
1041: .donnee).objet));
1042:
1043: (*s_etat_processus)
1044: .echelle_automatique_z2
1045: = d_faux;
1046: }
1047: }
1048: else
1049: {
1050: liberation(s_etat_processus,
1051: s_objet_argument);
1052:
1053: (*s_etat_processus).erreur_execution =
1054: d_ex_argument_invalide;
1055: return;
1056: }
1057:
1058: break;
1059: }
1060:
1061: default :
1062: {
1063: liberation(s_etat_processus, s_objet_argument);
1064:
1065: (*s_etat_processus).erreur_execution =
1066: d_ex_argument_invalide;
1067: return;
1068: }
1069: }
1070: }
1071:
1072: l_element_courant_auxiliaire =
1073: (*l_element_courant_auxiliaire).suivant;
1074: }
1075: }
1076: else if ((*(*l_element_courant).donnee).type == CHN)
1077: {
1.53 bertrand 1078: tampon = conversion_majuscule(s_etat_processus,
1079: (unsigned char *) (*(*l_element_courant).donnee).objet);
1.1 bertrand 1080:
1081: if (tampon == NULL)
1082: {
1083: (*s_etat_processus).erreur_systeme =
1084: d_es_allocation_memoire;
1085: return;
1086: }
1087:
1088: if (strcmp(tampon, "AUTOMATIC") == 0)
1089: {
1090: switch(nombre_arguments_principaux)
1091: {
1092: case 1 :
1093: {
1094: if ((*s_etat_processus).systeme_axes == 0)
1095: {
1096: (*s_etat_processus).echelle_automatique_x
1097: = d_vrai;
1098: }
1099: else
1100: {
1101: (*s_etat_processus).echelle_automatique_x2
1102: = d_vrai;
1103: }
1104:
1105: break;
1106: }
1107:
1108: case 2 :
1109: {
1110: if ((*s_etat_processus).systeme_axes == 0)
1111: {
1112: (*s_etat_processus).echelle_automatique_y
1113: = d_vrai;
1114: }
1115: else
1116: {
1117: (*s_etat_processus).echelle_automatique_y2
1118: = d_vrai;
1119: }
1120:
1121: break;
1122: }
1123:
1124: case 3 :
1125: {
1126: if ((*s_etat_processus).systeme_axes == 0)
1127: {
1128: (*s_etat_processus).echelle_automatique_z
1129: = d_vrai;
1130: }
1131: else
1132: {
1133: (*s_etat_processus).echelle_automatique_z2
1134: = d_vrai;
1135: }
1136:
1137: break;
1138: }
1139:
1140: default :
1141: {
1142: liberation(s_etat_processus, s_objet_argument);
1143: free(tampon);
1144:
1145: (*s_etat_processus).erreur_execution =
1146: d_ex_argument_invalide;
1147: return;
1148: }
1149: }
1150: }
1151: else
1152: {
1153: liberation(s_etat_processus, s_objet_argument);
1154: free(tampon);
1155:
1156: (*s_etat_processus).erreur_execution =
1157: d_ex_argument_invalide;
1158: return;
1159: }
1160:
1161: free(tampon);
1162: }
1163: else
1164: {
1165: liberation(s_etat_processus, s_objet_argument);
1166:
1167: (*s_etat_processus).erreur_execution =
1168: d_ex_erreur_type_argument;
1169: return;
1170: }
1171:
1172: l_element_courant = (*l_element_courant).suivant;
1173: }
1174: }
1175: else
1176: {
1177: liberation(s_etat_processus, s_objet_argument);
1178:
1179: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1180: return;
1181: }
1182:
1183: liberation(s_etat_processus, s_objet_argument);
1184:
1185: if (test_cfsf(s_etat_processus, 52) == d_faux)
1186: {
1187: if ((*s_etat_processus).fichiers_graphiques != NULL)
1188: {
1189: appel_gnuplot(s_etat_processus, 'N');
1190: }
1191: }
1192:
1193: return;
1194: }
1195:
1196:
1197: /*
1198: ================================================================================
1199: Fonction 'scls'
1200: ================================================================================
1201: Entrées :
1202: --------------------------------------------------------------------------------
1203: Sorties :
1204: --------------------------------------------------------------------------------
1205: Effets de bord : néant
1206: ================================================================================
1207: */
1208:
1209: void
1210: instruction_scls(struct_processus *s_etat_processus)
1211: {
1212: logical1 matrice_entiere;
1213:
1214: real8 valeur_courante;
1215:
1216: struct_objet *s_objet_statistique;
1217:
1.43 bertrand 1218: integer8 j;
1.1 bertrand 1219:
1220: (*s_etat_processus).erreur_execution = d_ex;
1221:
1222: if ((*s_etat_processus).affichage_arguments == 'Y')
1223: {
1224: printf("\n SCLS ");
1225:
1226: if ((*s_etat_processus).langue == 'F')
1227: {
1228: printf("(échelle automatique d'un nuage de points)\n\n");
1229: printf(" Aucun argument\n");
1230: }
1231: else
1232: {
1233: printf("(auto scale scatter plot)\n\n");
1234: printf(" No argument\n");
1235: }
1236:
1237: return;
1238: }
1239: else if ((*s_etat_processus).test_instruction == 'Y')
1240: {
1241: (*s_etat_processus).nombre_arguments = -1;
1242: return;
1243: }
1244:
1245: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1246: {
1247: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1248: {
1249: return;
1250: }
1251: }
1252:
1253: /*
1254: * Vérification de la présence de la matrice statistique
1255: */
1256:
1.20 bertrand 1257: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 1258: {
1259: /*
1260: * Aucune variable ds_sdat n'existe.
1261: */
1262:
1.20 bertrand 1263: if ((*s_etat_processus).erreur_execution == d_ex)
1.1 bertrand 1264: {
1.20 bertrand 1265: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1.1 bertrand 1266: }
1267:
1.20 bertrand 1268: (*s_etat_processus).erreur_systeme = d_es;
1.1 bertrand 1269: return;
1270: }
1271:
1.20 bertrand 1272: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
1273: .objet;
1.1 bertrand 1274:
1275: if ((*s_objet_statistique).type == MIN)
1276: {
1277: matrice_entiere = d_vrai;
1278: }
1279: else if ((*s_objet_statistique).type == MRL)
1280: {
1281: matrice_entiere = d_faux;
1282: }
1283: else
1284: {
1285: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1286: return;
1287: }
1288:
1289: switch((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_colonnes)
1290: {
1291: /*
1292: * Une colonne
1293: */
1294:
1295: case 1 :
1296: {
1297: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1298: break;
1299: }
1300:
1301: /*
1302: * Deux colonnes ou plus
1303: */
1304:
1305: default :
1306: {
1307: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
1308: ((*s_etat_processus).colonne_statistique_2 < 1) ||
1309: ((*s_etat_processus).colonne_statistique_1 > (integer8)
1310: (*((struct_matrice *) (*s_objet_statistique).objet))
1311: .nombre_colonnes) ||
1312: ((*s_etat_processus).colonne_statistique_2 > (integer8)
1313: (*((struct_matrice *) (*s_objet_statistique).objet))
1314: .nombre_colonnes))
1315: {
1316: (*s_etat_processus).erreur_execution =
1317: d_ex_observations_inexistantes;
1318: return;
1319: }
1320:
1321: if (matrice_entiere == d_vrai)
1322: {
1323: if ((*s_etat_processus).systeme_axes == 0)
1324: {
1325: (*s_etat_processus).x_min = (real8) ((integer8 **)
1326: (*((struct_matrice *) (*s_objet_statistique).objet))
1327: .tableau)[0][(*s_etat_processus)
1328: .colonne_statistique_1 - 1];
1329: (*s_etat_processus).x_max = (*s_etat_processus).x_min;
1330: }
1331: else
1332: {
1333: (*s_etat_processus).x2_min = (real8) ((integer8 **)
1334: (*((struct_matrice *) (*s_objet_statistique).objet))
1335: .tableau)[0][(*s_etat_processus)
1336: .colonne_statistique_1 - 1];
1337: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1338: }
1339:
1340: if ((*s_etat_processus).systeme_axes == 0)
1341: {
1342: (*s_etat_processus).y_min = (real8) ((integer8 **)
1343: (*((struct_matrice *) (*s_objet_statistique).objet))
1344: .tableau)[0][(*s_etat_processus)
1345: .colonne_statistique_2 - 1];
1346: (*s_etat_processus).y_max = (*s_etat_processus).y_min;
1347: }
1348: else
1349: {
1350: (*s_etat_processus).y2_min = (real8) ((integer8 **)
1351: (*((struct_matrice *) (*s_objet_statistique).objet))
1352: .tableau)[0][(*s_etat_processus)
1353: .colonne_statistique_2 - 1];
1354: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1355: }
1356: }
1357: else
1358: {
1359: if ((*s_etat_processus).systeme_axes == 0)
1360: {
1361: (*s_etat_processus).x_min = ((real8 **)
1362: (*((struct_matrice *) (*s_objet_statistique).objet))
1363: .tableau)[0][(*s_etat_processus)
1364: .colonne_statistique_1 - 1];
1365: (*s_etat_processus).x_max = (*s_etat_processus).x_min;
1366: }
1367: else
1368: {
1369: (*s_etat_processus).x2_min = ((real8 **)
1370: (*((struct_matrice *) (*s_objet_statistique).objet))
1371: .tableau)[0][(*s_etat_processus)
1372: .colonne_statistique_1 - 1];
1373: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1374: }
1375:
1376: if ((*s_etat_processus).systeme_axes == 0)
1377: {
1378: (*s_etat_processus).y_min = ((real8 **)
1379: (*((struct_matrice *) (*s_objet_statistique).objet))
1380: .tableau)[0][(*s_etat_processus)
1381: .colonne_statistique_2 - 1];
1382: (*s_etat_processus).y_max = (*s_etat_processus).y_min;
1383: }
1384: else
1385: {
1386: (*s_etat_processus).y2_min = ((real8 **)
1387: (*((struct_matrice *) (*s_objet_statistique).objet))
1388: .tableau)[0][(*s_etat_processus)
1389: .colonne_statistique_2 - 1];
1390: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1391: }
1392: }
1393:
1394: for(j = 1; j < (*((struct_matrice *) (*s_objet_statistique).objet))
1395: .nombre_lignes; j++)
1396: {
1397: if (matrice_entiere == d_vrai)
1398: {
1399: valeur_courante = (real8) ((integer8 **)
1400: (*((struct_matrice *) (*s_objet_statistique).objet))
1401: .tableau)[j][(*s_etat_processus)
1402: .colonne_statistique_1 - 1];
1403:
1404: if ((*s_etat_processus).systeme_axes == 0)
1405: {
1406: if (valeur_courante < (*s_etat_processus).x_min)
1407: {
1408: (*s_etat_processus).x_min = valeur_courante;
1409: }
1410:
1411: if (valeur_courante > (*s_etat_processus).x_max)
1412: {
1413: (*s_etat_processus).x_max = valeur_courante;
1414: }
1415: }
1416: else
1417: {
1418: if (valeur_courante < (*s_etat_processus).x2_min)
1419: {
1420: (*s_etat_processus).x2_min = valeur_courante;
1421: }
1422:
1423: if (valeur_courante > (*s_etat_processus).x2_max)
1424: {
1425: (*s_etat_processus).x2_max = valeur_courante;
1426: }
1427: }
1428:
1429: valeur_courante = (real8) ((integer8 **)
1430: (*((struct_matrice *) (*s_objet_statistique).objet))
1431: .tableau)[j][(*s_etat_processus)
1432: .colonne_statistique_2 - 1];
1433:
1434: if ((*s_etat_processus).systeme_axes == 0)
1435: {
1436: if (valeur_courante < (*s_etat_processus).y_min)
1437: {
1438: (*s_etat_processus).y_min = valeur_courante;
1439: }
1440:
1441: if (valeur_courante > (*s_etat_processus).y_max)
1442: {
1443: (*s_etat_processus).y_max = valeur_courante;
1444: }
1445: }
1446: else
1447: {
1448: if (valeur_courante < (*s_etat_processus).y2_min)
1449: {
1450: (*s_etat_processus).y2_min = valeur_courante;
1451: }
1452:
1453: if (valeur_courante > (*s_etat_processus).y2_max)
1454: {
1455: (*s_etat_processus).y2_max = valeur_courante;
1456: }
1457: }
1458: }
1459: else
1460: {
1461: valeur_courante = ((real8 **)
1462: (*((struct_matrice *) (*s_objet_statistique).objet))
1463: .tableau)[j][(*s_etat_processus)
1464: .colonne_statistique_1 - 1];
1465:
1466: if ((*s_etat_processus).systeme_axes == 0)
1467: {
1468: if (valeur_courante < (*s_etat_processus).x_min)
1469: {
1470: (*s_etat_processus).x_min = valeur_courante;
1471: }
1472:
1473: if (valeur_courante > (*s_etat_processus).x_max)
1474: {
1475: (*s_etat_processus).x_max = valeur_courante;
1476: }
1477: }
1478: else
1479: {
1480: if (valeur_courante < (*s_etat_processus).x2_min)
1481: {
1482: (*s_etat_processus).x2_min = valeur_courante;
1483: }
1484:
1485: if (valeur_courante > (*s_etat_processus).x2_max)
1486: {
1487: (*s_etat_processus).x2_max = valeur_courante;
1488: }
1489: }
1490:
1491: valeur_courante = ((real8 **)
1492: (*((struct_matrice *) (*s_objet_statistique).objet))
1493: .tableau)[j][(*s_etat_processus)
1494: .colonne_statistique_2 - 1];
1495:
1496: if ((*s_etat_processus).systeme_axes == 0)
1497: {
1498: if (valeur_courante < (*s_etat_processus).y_min)
1499: {
1500: (*s_etat_processus).y_min = valeur_courante;
1501: }
1502:
1503: if (valeur_courante > (*s_etat_processus).y_max)
1504: {
1505: (*s_etat_processus).y_max = valeur_courante;
1506: }
1507: }
1508: else
1509: {
1510: if (valeur_courante < (*s_etat_processus).y2_min)
1511: {
1512: (*s_etat_processus).y2_min = valeur_courante;
1513: }
1514:
1515: if (valeur_courante > (*s_etat_processus).y2_max)
1516: {
1517: (*s_etat_processus).y2_max = valeur_courante;
1518: }
1519: }
1520: }
1521: }
1522:
1523: break;
1524: }
1525: }
1526:
1527: return;
1528: }
1529:
1530:
1531: /*
1532: ================================================================================
1533: Fonction 'spar'
1534: ================================================================================
1535: Entrées :
1536: --------------------------------------------------------------------------------
1537: Sorties :
1538: --------------------------------------------------------------------------------
1539: Effets de bord : néant
1540: ================================================================================
1541: */
1542:
1543: void
1544: instruction_spar(struct_processus *s_etat_processus)
1545: {
1546: logical1 presence_matrice_statistique;
1547:
1548: struct_liste_chainee *l_ancienne_base;
1549: struct_liste_chainee *l_nouvelle_base;
1550:
1551: struct_objet *s_objet_resultat;
1552:
1553: /*
1554: * { { Dimensions de SIGMA } X Y }
1555: */
1556:
1557: (*s_etat_processus).erreur_execution = d_ex;
1558:
1559: if ((*s_etat_processus).affichage_arguments == 'Y')
1560: {
1561: printf("\n SPAR ");
1562:
1563: if ((*s_etat_processus).langue == 'F')
1564: {
1565: printf("(paramètres statistiques)\n\n");
1566: }
1567: else
1568: {
1569: printf("(statistical parameters)\n\n");
1570: }
1571:
1572: printf("-> 1: %s\n", d_LST);
1573:
1574: return;
1575: }
1576: else if ((*s_etat_processus).test_instruction == 'Y')
1577: {
1578: (*s_etat_processus).nombre_arguments = -1;
1579: return;
1580: }
1581:
1582: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1583: {
1584: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1585: {
1586: return;
1587: }
1588: }
1589:
1590: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
1591: {
1592: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1593: return;
1594: }
1595:
1596: (*s_objet_resultat).objet = NULL;
1597: l_ancienne_base = (*s_objet_resultat).objet;
1598:
1599: // Colonne 2
1600:
1601: if ((l_nouvelle_base = malloc(sizeof(struct_liste_chainee))) == NULL)
1602: {
1603: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1604: return;
1605: }
1606:
1607: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1608: == NULL)
1609: {
1610: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1611: return;
1612: }
1613:
1614: (*l_nouvelle_base).suivant = l_ancienne_base;
1615: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1616: (*s_etat_processus).colonne_statistique_2;
1617: (*s_objet_resultat).objet = l_nouvelle_base;
1618: l_ancienne_base = (*s_objet_resultat).objet;
1619:
1620: // Colonne 1
1621:
1622: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1623: {
1624: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1625: return;
1626: }
1627:
1628: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1629: == NULL)
1630: {
1631: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1632: return;
1633: }
1634:
1635: (*l_nouvelle_base).suivant = l_ancienne_base;
1636: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1637: (*s_etat_processus).colonne_statistique_1;
1638: (*s_objet_resultat).objet = l_nouvelle_base;
1639: l_ancienne_base = (*s_objet_resultat).objet;
1640:
1641: // Dimensions de la matrice statistique
1642:
1643: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1644: {
1645: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1646: return;
1647: }
1648:
1649: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
1650: == NULL)
1651: {
1652: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1653: return;
1654: }
1655:
1.20 bertrand 1656: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 1657: {
1658: /*
1659: * Aucune variable SIGMA
1660: */
1661:
1662: (*s_etat_processus).erreur_systeme = d_es;
1.20 bertrand 1663:
1664: if ((*s_etat_processus).erreur_execution == d_ex)
1665: {
1666: (*s_etat_processus).erreur_execution = d_ex;
1667: }
1668:
1.1 bertrand 1669: presence_matrice_statistique = d_faux;
1670: }
1671: else
1672: {
1.20 bertrand 1673: presence_matrice_statistique = d_vrai;
1.1 bertrand 1674: }
1675:
1676: if (presence_matrice_statistique == d_faux)
1677: {
1678: if (((*(*l_nouvelle_base).donnee).objet = malloc(12 *
1679: sizeof(unsigned char))) == NULL)
1680: {
1681: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1682: return;
1683: }
1684:
1685: (*(*l_nouvelle_base).donnee).type = CHN;
1686: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1687: "UNAVAILABLE");
1688: }
1689: else
1690: {
1.20 bertrand 1691: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
1692: .type != MIN) && ((*(*(*s_etat_processus)
1693: .pointeur_variable_courante).objet).type != MRL))
1.1 bertrand 1694: {
1695: if (((*(*l_nouvelle_base).donnee).objet = malloc(9 *
1696: sizeof(unsigned char))) == NULL)
1697: {
1698: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1699: return;
1700: }
1701:
1702: (*(*l_nouvelle_base).donnee).type = CHN;
1703: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1704: "DISABLED");
1705: }
1706: else
1707: {
1708: (*(*l_nouvelle_base).donnee).type = LST;
1709:
1710: if (((*(*l_nouvelle_base).donnee).objet =
1711: allocation_maillon(s_etat_processus)) == NULL)
1712: {
1713: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1714: return;
1715: }
1716:
1717: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1718: .objet)).donnee = allocation(s_etat_processus, INT))
1719: == NULL)
1720: {
1721: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1722: return;
1723: }
1724:
1725: (*((integer8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base)
1726: .donnee).objet)).donnee)).objet)) = (*((struct_matrice *)
1.20 bertrand 1727: (*(*(*s_etat_processus).pointeur_variable_courante).objet)
1.1 bertrand 1728: .objet)).nombre_lignes;
1729:
1730: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1731: .objet)).suivant = allocation_maillon(s_etat_processus))
1732: == NULL)
1733: {
1734: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1735: return;
1736: }
1737:
1738: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
1739: .suivant).suivant = NULL;
1740:
1741: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1742: .objet)).suivant).donnee = allocation(s_etat_processus,
1743: INT)) == NULL)
1744: {
1745: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1746: return;
1747: }
1748:
1749: (*((integer8 *) (*((*(*((struct_liste_chainee *)
1750: (*(*l_nouvelle_base).donnee).objet)).suivant).donnee))
1.20 bertrand 1751: .objet)) = (*((struct_matrice *) (*(*(*s_etat_processus)
1752: .pointeur_variable_courante).objet).objet))
1.1 bertrand 1753: .nombre_colonnes;
1754: }
1755: }
1756:
1757: (*l_nouvelle_base).suivant = l_ancienne_base;
1758: (*s_objet_resultat).objet = l_nouvelle_base;
1759:
1760: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1761: s_objet_resultat) == d_erreur)
1762: {
1763: return;
1764: }
1765:
1766: return;
1767: }
1768:
1769: // vim: ts=4