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