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