1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.36
4: Copyright (C) 1989-2024 Dr. BERTRAND Joël
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:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'slice'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_slice(struct_processus *s_etat_processus)
40: {
41: (*s_etat_processus).erreur_execution = d_ex;
42:
43: if ((*s_etat_processus).affichage_arguments == 'Y')
44: {
45: printf("\n SLICE ");
46:
47: if ((*s_etat_processus).langue == 'F')
48: {
49: printf("(graphique tridimensionnel avec courbes de niveau)\n\n");
50: printf(" Aucun argument\n");
51: }
52: else
53: {
54: printf("(3D graph with contour lines)\n\n");
55: printf(" No argument\n");
56: }
57:
58: return;
59: }
60: else if ((*s_etat_processus).test_instruction == 'Y')
61: {
62: (*s_etat_processus).nombre_arguments = -1;
63: return;
64: }
65:
66: # ifndef GNUPLOT_SUPPORT
67: if ((*s_etat_processus).langue == 'F')
68: {
69: printf("+++Attention : Support de GnuPlot non compilé !\n");
70: }
71: else
72: {
73: printf("+++Warning : GnuPlot not available !\n");
74: }
75:
76: fflush(stdout);
77:
78: return;
79: # endif
80:
81: strcpy((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU");
82:
83: return;
84: }
85:
86:
87: /*
88: ================================================================================
89: Fonction 'slicescale'
90: ================================================================================
91: Entrées :
92: --------------------------------------------------------------------------------
93: Sorties :
94: --------------------------------------------------------------------------------
95: Effets de bord : néant
96: ================================================================================
97: */
98:
99: void
100: instruction_slicescale(struct_processus *s_etat_processus)
101: {
102: int automatique;
103: int discret;
104: int incremental;
105:
106: long nombre_arguments;
107:
108: struct_liste_chainee *l_element_courant;
109: struct_liste_chainee *l_element_courant_resultat;
110:
111: struct_objet *s_objet_argument;
112: struct_objet *s_objet_auxiliaire;
113: struct_objet *s_objet_resultat;
114:
115: unsigned char *tampon;
116:
117: (*s_etat_processus).erreur_execution = d_ex;
118:
119: if ((*s_etat_processus).affichage_arguments == 'Y')
120: {
121: printf("\n SLICESCALE ");
122:
123: if ((*s_etat_processus).langue == 'F')
124: {
125: printf("(définition des courbes de niveau)\n\n");
126: }
127: else
128: {
129: printf("(definition of contour lines)\n\n");
130: }
131:
132: printf(" 1: %s\n\n", d_LST);
133:
134: if ((*s_etat_processus).langue == 'F')
135: {
136: printf(" Utilisation :\n\n");
137: }
138: else
139: {
140: printf(" Usage:\n\n");
141: }
142:
143: printf(" { { Xmin Xmax} { Ymin Ymax } { Zmin Zmax} } SCALE\n");
144: printf(" To be fixed!\n");
145: /*
146: AUTOMATIC
147: DISCRETE
148: INCREMENTAL
149: */
150:
151: return;
152: }
153: else if ((*s_etat_processus).test_instruction == 'Y')
154: {
155: (*s_etat_processus).nombre_arguments = -1;
156: return;
157: }
158:
159: if (test_cfsf(s_etat_processus, 31) == d_vrai)
160: {
161: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
162: {
163: return;
164: }
165: }
166:
167: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
168: &s_objet_argument) == d_erreur)
169: {
170: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
171: return;
172: }
173:
174: if ((*s_objet_argument).type == LST)
175: {
176: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
177:
178: automatique = 0;
179: discret = 0;
180: incremental = 0;
181:
182: nombre_arguments = 0;
183:
184: while(l_element_courant != NULL)
185: {
186: if ((*(*l_element_courant).donnee).type == CHN)
187: {
188: if ((tampon = conversion_majuscule(s_etat_processus,
189: (unsigned char *) (*(*l_element_courant).donnee).objet))
190: == NULL)
191: {
192: (*s_etat_processus).erreur_systeme =
193: d_es_allocation_memoire;
194: return;
195: }
196:
197: if (strcmp(tampon, "AUTOMATIC") == 0)
198: {
199: automatique++;
200: }
201: else if (strcmp(tampon, "DISCRETE") == 0)
202: {
203: discret++;
204: }
205: else if (strcmp(tampon, "INCREMENTAL") == 0)
206: {
207: incremental++;
208: }
209: else
210: {
211: free(tampon);
212: liberation(s_etat_processus, s_objet_argument);
213:
214: (*s_etat_processus).erreur_execution =
215: d_ex_argument_invalide;
216: return;
217: }
218:
219: free(tampon);
220: }
221:
222: l_element_courant = (*l_element_courant).suivant;
223: nombre_arguments++;
224: }
225:
226: if ((automatique + discret + incremental) == 1)
227: {
228: if (automatique == 1)
229: {
230: if (nombre_arguments > 2)
231: {
232: liberation(s_etat_processus, s_objet_argument);
233:
234: (*s_etat_processus).erreur_execution =
235: d_ex_argument_invalide;
236: return;
237: }
238: }
239: else if (discret == 1)
240: {
241: if (nombre_arguments < 2)
242: {
243: liberation(s_etat_processus, s_objet_argument);
244:
245: (*s_etat_processus).erreur_execution =
246: d_ex_argument_invalide;
247: return;
248: }
249: }
250: else if (incremental == 1)
251: {
252: if ((nombre_arguments < 3) || (nombre_arguments > 4))
253: {
254: liberation(s_etat_processus, s_objet_argument);
255:
256: (*s_etat_processus).erreur_execution =
257: d_ex_argument_invalide;
258: return;
259: }
260: }
261: else
262: {
263: liberation(s_etat_processus, s_objet_argument);
264:
265: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
266: return;
267: }
268:
269: if ((s_objet_resultat = allocation(s_etat_processus, LST))
270: == NULL)
271: {
272: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
273: return;
274: }
275:
276: if (((*s_objet_resultat).objet =
277: allocation_maillon(s_etat_processus)) == NULL)
278: {
279: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
280: return;
281: }
282:
283: l_element_courant_resultat = (*s_objet_resultat).objet;
284: (*l_element_courant_resultat).suivant = NULL;
285:
286: if (((*l_element_courant_resultat).donnee =
287: allocation(s_etat_processus, CHN)) == NULL)
288: {
289: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
290: return;
291: }
292:
293: if (automatique == 1)
294: {
295: if (((*(*l_element_courant_resultat).donnee).objet = malloc(
296: 10 * sizeof(unsigned char))) == NULL)
297: {
298: (*s_etat_processus).erreur_systeme =
299: d_es_allocation_memoire;
300: return;
301: }
302:
303: strcpy((*(*l_element_courant_resultat).donnee).objet,
304: "AUTOMATIC");
305: }
306: else if (discret == 1)
307: {
308: if (((*(*l_element_courant_resultat).donnee).objet = malloc(
309: 9 * sizeof(unsigned char))) == NULL)
310: {
311: (*s_etat_processus).erreur_systeme =
312: d_es_allocation_memoire;
313: return;
314: }
315:
316: strcpy((*(*l_element_courant_resultat).donnee).objet,
317: "DISCRETE");
318: }
319: else
320: {
321: if (((*(*l_element_courant_resultat).donnee).objet = malloc(
322: 12 * sizeof(unsigned char))) == NULL)
323: {
324: (*s_etat_processus).erreur_systeme =
325: d_es_allocation_memoire;
326: return;
327: }
328:
329: strcpy((*(*l_element_courant_resultat).donnee).objet,
330: "INCREMENTAL");
331: }
332:
333: // Récupération des paramètres numériques
334:
335: l_element_courant = (struct_liste_chainee *)
336: (*s_objet_argument).objet;
337:
338: while(l_element_courant != NULL)
339: {
340: if ((*(*l_element_courant).donnee).type != CHN)
341: {
342: if (((*(*l_element_courant).donnee).type == ALG) ||
343: ((*(*l_element_courant).donnee).type == RPN) ||
344: ((*(*l_element_courant).donnee).type == NOM))
345: {
346: if (evaluation(s_etat_processus,
347: (*l_element_courant).donnee, 'N')
348: == d_erreur)
349: {
350: liberation(s_etat_processus, s_objet_argument);
351: liberation(s_etat_processus, s_objet_resultat);
352:
353: return;
354: }
355:
356: if (depilement(s_etat_processus,
357: &((*s_etat_processus).l_base_pile),
358: &s_objet_auxiliaire) == d_erreur)
359: {
360: liberation(s_etat_processus, s_objet_argument);
361: liberation(s_etat_processus, s_objet_resultat);
362:
363: (*s_etat_processus).erreur_execution =
364: d_ex_manque_argument;
365: return;
366: }
367:
368: liberation(s_etat_processus,
369: (*l_element_courant).donnee);
370: (*l_element_courant).donnee = s_objet_auxiliaire;
371: }
372:
373: if (((*(*l_element_courant).donnee).type == INT) ||
374: ((*(*l_element_courant).donnee).type == REL))
375: {
376: if (((*l_element_courant_resultat).suivant =
377: allocation_maillon(s_etat_processus)) == NULL)
378: {
379: (*s_etat_processus).erreur_systeme =
380: d_es_allocation_memoire;
381: return;
382: }
383:
384: l_element_courant_resultat =
385: (*l_element_courant_resultat).suivant;
386: (*l_element_courant_resultat).suivant = NULL;
387:
388: if (((*l_element_courant_resultat).donnee =
389: copie_objet(s_etat_processus,
390: (*l_element_courant).donnee, 'O'))
391: == NULL)
392: {
393: (*s_etat_processus).erreur_systeme =
394: d_es_allocation_memoire;
395: return;
396: }
397: }
398: else
399: {
400: liberation(s_etat_processus, s_objet_argument);
401: liberation(s_etat_processus, s_objet_resultat);
402:
403: (*s_etat_processus).erreur_execution =
404: d_ex_erreur_type_argument;
405: return;
406: }
407: }
408:
409: l_element_courant = (*l_element_courant).suivant;
410: }
411:
412: liberation(s_etat_processus,
413: (*s_etat_processus).parametres_courbes_de_niveau);
414: (*s_etat_processus).parametres_courbes_de_niveau =
415: s_objet_resultat;
416: }
417: else
418: {
419: liberation(s_etat_processus, s_objet_argument);
420:
421: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
422: return;
423: }
424: }
425: else
426: {
427: liberation(s_etat_processus, s_objet_argument);
428:
429: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
430: return;
431: }
432:
433: liberation(s_etat_processus, s_objet_argument);
434:
435: if (test_cfsf(s_etat_processus, 52) == d_faux)
436: {
437: if ((*s_etat_processus).fichiers_graphiques != NULL)
438: {
439: appel_gnuplot(s_etat_processus, 'N');
440: }
441: }
442:
443: return;
444: }
445:
446:
447: /*
448: ================================================================================
449: Fonction 'sx'
450: ================================================================================
451: Entrées : pointeur sur une structure struct_processus
452: --------------------------------------------------------------------------------
453: Sorties :
454: --------------------------------------------------------------------------------
455: Effets de bord : néant
456: ================================================================================
457: */
458:
459: void
460: instruction_sx(struct_processus *s_etat_processus)
461: {
462: struct_objet *s_objet_statistique;
463: struct_objet *s_objet_resultat;
464:
465: struct_vecteur *resultat;
466:
467: integer8 nombre_colonnes;
468:
469: (*s_etat_processus).erreur_execution = d_ex;
470:
471: if ((*s_etat_processus).affichage_arguments == 'Y')
472: {
473: printf("\n SX ");
474:
475: if ((*s_etat_processus).langue == 'F')
476: {
477: printf("(somme sur la colonne X)\n\n");
478: }
479: else
480: {
481: printf("(sum on X column)\n\n");
482: }
483:
484: printf("-> 1: %s, %s\n", d_INT, d_REL);
485:
486: return;
487: }
488: else if ((*s_etat_processus).test_instruction == 'Y')
489: {
490: (*s_etat_processus).nombre_arguments = -1;
491: return;
492: }
493:
494: if (test_cfsf(s_etat_processus, 31) == d_vrai)
495: {
496: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
497: {
498: return;
499: }
500: }
501:
502: /*
503: * Recherche d'une variable globale référencée par SIGMA
504: */
505:
506: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
507: {
508: /*
509: * Aucune variable SIGMA
510: */
511:
512: (*s_etat_processus).erreur_systeme = d_es;
513:
514: if ((*s_etat_processus).erreur_execution == d_ex)
515: {
516: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
517: }
518:
519: return;
520: }
521: else
522: {
523: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
524: .type != MIN) && ((*(*(*s_etat_processus)
525: .pointeur_variable_courante).objet).type != MRL))
526: {
527: (*s_etat_processus).erreur_execution =
528: d_ex_matrice_statistique_invalide;
529: return;
530: }
531:
532: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
533: .pointeur_variable_courante).objet).objet))
534: .nombre_colonnes;
535: }
536:
537: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
538: ((*s_etat_processus).colonne_statistique_1 > (integer8)
539: nombre_colonnes))
540: {
541: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
542: return;
543: }
544:
545: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
546: .objet;
547:
548: if (((*s_objet_statistique).type == MIN) ||
549: ((*s_objet_statistique).type == MRL))
550: {
551: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
552: {
553: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
554: return;
555: }
556:
557: if ((resultat = sommation_colonne_statistique(s_etat_processus,
558: (struct_matrice *) (*s_objet_statistique).objet,
559: (*s_etat_processus).colonne_statistique_1)) == NULL)
560: {
561: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
562: return;
563: }
564:
565: if ((*resultat).type == 'I')
566: {
567: (*s_objet_resultat).type = INT;
568:
569: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL)
570: {
571: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
572: return;
573: }
574:
575: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
576: (*resultat).tableau));
577: }
578: else
579: {
580: (*s_objet_resultat).type = REL;
581:
582: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
583: {
584: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
585: return;
586: }
587:
588: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
589: (*resultat).tableau));
590: }
591:
592: free((*resultat).tableau);
593: free(resultat);
594:
595: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
596: s_objet_resultat) == d_erreur)
597: {
598: return;
599: }
600: }
601: else
602: {
603: (*s_etat_processus).erreur_execution =
604: d_ex_matrice_statistique_invalide;
605: return;
606: }
607:
608: return;
609: }
610:
611:
612: /*
613: ================================================================================
614: Fonction 'sy'
615: ================================================================================
616: Entrées : pointeur sur une structure struct_processus
617: --------------------------------------------------------------------------------
618: Sorties :
619: --------------------------------------------------------------------------------
620: Effets de bord : néant
621: ================================================================================
622: */
623:
624: void
625: instruction_sy(struct_processus *s_etat_processus)
626: {
627: struct_objet *s_objet_statistique;
628: struct_objet *s_objet_resultat;
629:
630: struct_vecteur *resultat;
631:
632: integer8 nombre_colonnes;
633:
634: (*s_etat_processus).erreur_execution = d_ex;
635:
636: if ((*s_etat_processus).affichage_arguments == 'Y')
637: {
638: printf("\n SY ");
639:
640: if ((*s_etat_processus).langue == 'F')
641: {
642: printf("(somme sur la colonne Y)\n\n");
643: }
644: else
645: {
646: printf("(sum on Y column)\n\n");
647: }
648:
649: printf("-> 1: %s, %s\n", d_INT, d_REL);
650:
651: return;
652: }
653: else if ((*s_etat_processus).test_instruction == 'Y')
654: {
655: (*s_etat_processus).nombre_arguments = -1;
656: return;
657: }
658:
659: if (test_cfsf(s_etat_processus, 31) == d_vrai)
660: {
661: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
662: {
663: return;
664: }
665: }
666:
667: /*
668: * Recherche d'une variable globale référencée par SIGMA
669: */
670:
671: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
672: {
673: /*
674: * Aucune variable SIGMA
675: */
676:
677: (*s_etat_processus).erreur_systeme = d_es;
678:
679: if ((*s_etat_processus).erreur_execution == d_ex)
680: {
681: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
682: }
683:
684: return;
685: }
686: else
687: {
688: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
689: .type != MIN) && ((*(*(*s_etat_processus)
690: .pointeur_variable_courante).objet).type != MRL))
691: {
692: (*s_etat_processus).erreur_execution =
693: d_ex_matrice_statistique_invalide;
694: return;
695: }
696:
697: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
698: .pointeur_variable_courante).objet).objet))
699: .nombre_colonnes;
700: }
701:
702: if (((*s_etat_processus).colonne_statistique_2 < 1) ||
703: ((*s_etat_processus).colonne_statistique_2 > (integer8)
704: nombre_colonnes))
705: {
706: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
707: return;
708: }
709:
710: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
711: .objet;
712:
713: if (((*s_objet_statistique).type == MIN) ||
714: ((*s_objet_statistique).type == MRL))
715: {
716: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
717: {
718: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
719: return;
720: }
721:
722: if ((resultat = sommation_colonne_statistique(s_etat_processus,
723: (struct_matrice *) (*s_objet_statistique).objet,
724: (*s_etat_processus).colonne_statistique_2)) == NULL)
725: {
726: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
727: return;
728: }
729:
730: if ((*resultat).type == 'I')
731: {
732: (*s_objet_resultat).type = INT;
733:
734: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL)
735: {
736: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
737: return;
738: }
739:
740: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
741: (*resultat).tableau));
742: }
743: else
744: {
745: (*s_objet_resultat).type = REL;
746:
747: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
748: {
749: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
750: return;
751: }
752:
753: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
754: (*resultat).tableau));
755: }
756:
757: free((*resultat).tableau);
758: free(resultat);
759:
760: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
761: s_objet_resultat) == d_erreur)
762: {
763: return;
764: }
765: }
766: else
767: {
768: (*s_etat_processus).erreur_execution =
769: d_ex_matrice_statistique_invalide;
770: return;
771: }
772:
773: return;
774: }
775:
776:
777: /*
778: ================================================================================
779: Fonction 'sxy'
780: ================================================================================
781: Entrées : pointeur sur une structure struct_processus
782: --------------------------------------------------------------------------------
783: Sorties :
784: --------------------------------------------------------------------------------
785: Effets de bord : néant
786: ================================================================================
787: */
788:
789: void
790: instruction_sxy(struct_processus *s_etat_processus)
791: {
792: struct_objet *s_objet_statistique;
793: struct_objet *s_objet_resultat;
794:
795: struct_vecteur *resultat;
796:
797: integer8 nombre_colonnes;
798:
799: (*s_etat_processus).erreur_execution = d_ex;
800:
801: if ((*s_etat_processus).affichage_arguments == 'Y')
802: {
803: printf("\n SXY ");
804:
805: if ((*s_etat_processus).langue == 'F')
806: {
807: printf("(somme des produits des colonne X et Y)\n\n");
808: }
809: else
810: {
811: printf("(sum of X and Y colums products)\n\n");
812: }
813:
814: printf("-> 1: %s, %s\n", d_INT, d_REL);
815:
816: return;
817: }
818: else if ((*s_etat_processus).test_instruction == 'Y')
819: {
820: (*s_etat_processus).nombre_arguments = -1;
821: return;
822: }
823:
824: if (test_cfsf(s_etat_processus, 31) == d_vrai)
825: {
826: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
827: {
828: return;
829: }
830: }
831:
832: /*
833: * Recherche d'une variable globale référencée par SIGMA
834: */
835:
836: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
837: {
838: /*
839: * Aucune variable SIGMA
840: */
841:
842: (*s_etat_processus).erreur_systeme = d_es;
843:
844: if ((*s_etat_processus).erreur_execution == d_ex)
845: {
846: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
847: }
848:
849: return;
850: }
851: else
852: {
853: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
854: .type != MIN) && ((*(*(*s_etat_processus)
855: .pointeur_variable_courante).objet).type != MRL))
856: {
857: (*s_etat_processus).erreur_execution =
858: d_ex_matrice_statistique_invalide;
859: return;
860: }
861:
862: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
863: .pointeur_variable_courante).objet).objet))
864: .nombre_colonnes;
865: }
866:
867: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
868: ((*s_etat_processus).colonne_statistique_1 > (integer8)
869: nombre_colonnes) || ((*s_etat_processus).colonne_statistique_2 < 1)
870: || ((*s_etat_processus).colonne_statistique_2 > (integer8)
871: nombre_colonnes))
872: {
873: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
874: return;
875: }
876:
877: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
878: .objet;
879:
880: if (((*s_objet_statistique).type == MIN) ||
881: ((*s_objet_statistique).type == MRL))
882: {
883: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
884: {
885: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
886: return;
887: }
888:
889: if ((resultat = sommation_produits_colonnes_statistiques(
890: s_etat_processus,
891: (struct_matrice *) (*s_objet_statistique).objet,
892: (*s_etat_processus).colonne_statistique_1,
893: (*s_etat_processus).colonne_statistique_2)) == NULL)
894: {
895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
896: return;
897: }
898:
899: if ((*resultat).type == 'I')
900: {
901: (*s_objet_resultat).type = INT;
902:
903: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL)
904: {
905: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
906: return;
907: }
908:
909: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
910: (*resultat).tableau));
911: }
912: else
913: {
914: (*s_objet_resultat).type = REL;
915:
916: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
917: {
918: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
919: return;
920: }
921:
922: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
923: (*resultat).tableau));
924: }
925:
926: free((*resultat).tableau);
927: free(resultat);
928:
929: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
930: s_objet_resultat) == d_erreur)
931: {
932: return;
933: }
934: }
935: else
936: {
937: (*s_etat_processus).erreur_execution =
938: d_ex_matrice_statistique_invalide;
939: return;
940: }
941:
942: return;
943: }
944:
945:
946: /*
947: ================================================================================
948: Fonction 'sx2'
949: ================================================================================
950: Entrées : pointeur sur une structure struct_processus
951: --------------------------------------------------------------------------------
952: Sorties :
953: --------------------------------------------------------------------------------
954: Effets de bord : néant
955: ================================================================================
956: */
957:
958: void
959: instruction_sx2(struct_processus *s_etat_processus)
960: {
961: struct_objet *s_objet_statistique;
962: struct_objet *s_objet_resultat;
963:
964: struct_vecteur *resultat;
965:
966: integer8 nombre_colonnes;
967:
968: (*s_etat_processus).erreur_execution = d_ex;
969:
970: if ((*s_etat_processus).affichage_arguments == 'Y')
971: {
972: printf("\n SX2 ");
973:
974: if ((*s_etat_processus).langue == 'F')
975: {
976: printf("(somme des carrés de la colonne X)\n\n");
977: }
978: else
979: {
980: printf("(sum of column X squares)\n\n");
981: }
982:
983: printf("-> 1: %s, %s\n", d_INT, d_REL);
984:
985: return;
986: }
987: else if ((*s_etat_processus).test_instruction == 'Y')
988: {
989: (*s_etat_processus).nombre_arguments = -1;
990: return;
991: }
992:
993: if (test_cfsf(s_etat_processus, 31) == d_vrai)
994: {
995: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
996: {
997: return;
998: }
999: }
1000:
1001: /*
1002: * Recherche d'une variable globale référencée par SIGMA
1003: */
1004:
1005: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1006: {
1007: /*
1008: * Aucune variable SIGMA
1009: */
1010:
1011: (*s_etat_processus).erreur_systeme = d_es;
1012:
1013: if ((*s_etat_processus).erreur_execution == d_ex)
1014: {
1015: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1016: }
1017:
1018: return;
1019: }
1020: else
1021: {
1022: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
1023: .type != MIN) && ((*(*(*s_etat_processus)
1024: .pointeur_variable_courante).objet).type != MRL))
1025: {
1026: (*s_etat_processus).erreur_execution =
1027: d_ex_matrice_statistique_invalide;
1028: return;
1029: }
1030:
1031: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
1032: .pointeur_variable_courante).objet).objet))
1033: .nombre_colonnes;
1034: }
1035:
1036: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
1037: ((*s_etat_processus).colonne_statistique_1 > (integer8)
1038: nombre_colonnes))
1039: {
1040: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
1041: return;
1042: }
1043:
1044: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
1045: .objet;
1046:
1047: if (((*s_objet_statistique).type == MIN) ||
1048: ((*s_objet_statistique).type == MRL))
1049: {
1050: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
1051: {
1052: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1053: return;
1054: }
1055:
1056: if ((resultat = sommation_produits_colonnes_statistiques(
1057: s_etat_processus,
1058: (struct_matrice *) (*s_objet_statistique).objet,
1059: (*s_etat_processus).colonne_statistique_1,
1060: (*s_etat_processus).colonne_statistique_1)) == NULL)
1061: {
1062: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1063: return;
1064: }
1065:
1066: if ((*resultat).type == 'I')
1067: {
1068: (*s_objet_resultat).type = INT;
1069:
1070: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL)
1071: {
1072: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1073: return;
1074: }
1075:
1076: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
1077: (*resultat).tableau));
1078: }
1079: else
1080: {
1081: (*s_objet_resultat).type = REL;
1082:
1083: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
1084: {
1085: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1086: return;
1087: }
1088:
1089: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
1090: (*resultat).tableau));
1091: }
1092:
1093: free((*resultat).tableau);
1094: free(resultat);
1095:
1096: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1097: s_objet_resultat) == d_erreur)
1098: {
1099: return;
1100: }
1101: }
1102: else
1103: {
1104: (*s_etat_processus).erreur_execution =
1105: d_ex_matrice_statistique_invalide;
1106: return;
1107: }
1108:
1109: return;
1110: }
1111:
1112:
1113: /*
1114: ================================================================================
1115: Fonction 'sy2'
1116: ================================================================================
1117: Entrées : pointeur sur une structure struct_processus
1118: --------------------------------------------------------------------------------
1119: Sorties :
1120: --------------------------------------------------------------------------------
1121: Effets de bord : néant
1122: ================================================================================
1123: */
1124:
1125: void
1126: instruction_sy2(struct_processus *s_etat_processus)
1127: {
1128: struct_objet *s_objet_statistique;
1129: struct_objet *s_objet_resultat;
1130:
1131: struct_vecteur *resultat;
1132:
1133: integer8 nombre_colonnes;
1134:
1135: (*s_etat_processus).erreur_execution = d_ex;
1136:
1137: if ((*s_etat_processus).affichage_arguments == 'Y')
1138: {
1139: printf("\n SY2 ");
1140:
1141: if ((*s_etat_processus).langue == 'F')
1142: {
1143: printf("(somme des carrés de la colonne Y)\n\n");
1144: }
1145: else
1146: {
1147: printf("(sum of column Y squares)\n\n");
1148: }
1149:
1150: printf("-> 1: %s, %s\n", d_INT, d_REL);
1151:
1152: return;
1153: }
1154: else if ((*s_etat_processus).test_instruction == 'Y')
1155: {
1156: (*s_etat_processus).nombre_arguments = -1;
1157: return;
1158: }
1159:
1160: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1161: {
1162: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1163: {
1164: return;
1165: }
1166: }
1167:
1168: /*
1169: * Recherche d'une variable globale référencée par SIGMA
1170: */
1171:
1172: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1173: {
1174: /*
1175: * Aucune variable SIGMA
1176: */
1177:
1178: (*s_etat_processus).erreur_systeme = d_es;
1179:
1180: if ((*s_etat_processus).erreur_execution == d_ex)
1181: {
1182: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1183: }
1184:
1185: return;
1186: }
1187: else
1188: {
1189: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
1190: .type != MIN) && ((*(*(*s_etat_processus)
1191: .pointeur_variable_courante).objet).type != MRL))
1192: {
1193: (*s_etat_processus).erreur_execution =
1194: d_ex_matrice_statistique_invalide;
1195: return;
1196: }
1197:
1198: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
1199: .pointeur_variable_courante).objet).objet))
1200: .nombre_colonnes;
1201: }
1202:
1203: if (((*s_etat_processus).colonne_statistique_2 < 1) ||
1204: ((*s_etat_processus).colonne_statistique_2 > (integer8)
1205: nombre_colonnes))
1206: {
1207: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
1208: return;
1209: }
1210:
1211: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
1212: .objet;
1213:
1214: if (((*s_objet_statistique).type == MIN) ||
1215: ((*s_objet_statistique).type == MRL))
1216: {
1217: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
1218: {
1219: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1220: return;
1221: }
1222:
1223: if ((resultat = sommation_produits_colonnes_statistiques(
1224: s_etat_processus,
1225: (struct_matrice *) (*s_objet_statistique).objet,
1226: (*s_etat_processus).colonne_statistique_2,
1227: (*s_etat_processus).colonne_statistique_2)) == NULL)
1228: {
1229: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1230: return;
1231: }
1232:
1233: if ((*resultat).type == 'I')
1234: {
1235: (*s_objet_resultat).type = INT;
1236:
1237: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL)
1238: {
1239: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1240: return;
1241: }
1242:
1243: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
1244: (*resultat).tableau));
1245: }
1246: else
1247: {
1248: (*s_objet_resultat).type = REL;
1249:
1250: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
1251: {
1252: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1253: return;
1254: }
1255:
1256: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
1257: (*resultat).tableau));
1258: }
1259:
1260: free((*resultat).tableau);
1261: free(resultat);
1262:
1263: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1264: s_objet_resultat) == d_erreur)
1265: {
1266: return;
1267: }
1268: }
1269: else
1270: {
1271: (*s_etat_processus).erreur_execution =
1272: d_ex_matrice_statistique_invalide;
1273: return;
1274: }
1275:
1276: return;
1277: }
1278:
1279: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s7.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src