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