![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_p5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_p5.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.2 ! bertrand 3: RPL/2 (R) version 4.0.10
1.1 bertrand 4: Copyright (C) 1989-2010 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 'pcov'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_pcov(struct_processus *s_etat_processus)
40: {
41: integer8 nombre_colonnes;
42:
43: logical1 erreur;
44: logical1 presence_variable;
45:
46: long i;
47:
48: struct_objet *s_objet_statistique;
49: struct_objet *s_objet_resultat;
50:
51: (*s_etat_processus).erreur_execution = d_ex;
52:
53: if ((*s_etat_processus).affichage_arguments == 'Y')
54: {
55: printf("\n PCOV ");
56:
57: if ((*s_etat_processus).langue == 'F')
58: {
59: printf("(covariance d'une population)\n\n");
60: }
61: else
62: {
63: printf("(population covariance)\n\n");
64: }
65:
66: printf("-> 1: %s\n", d_REL);
67:
68: return;
69: }
70: else if ((*s_etat_processus).test_instruction == 'Y')
71: {
72: (*s_etat_processus).nombre_arguments = -1;
73: return;
74: }
75:
76: if (test_cfsf(s_etat_processus, 31) == d_vrai)
77: {
78: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
79: {
80: return;
81: }
82: }
83:
84: /*
85: * Recherche d'une variable globale référencée par SIGMA
86: */
87:
88: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
89: {
90: /*
91: * Aucune variable SIGMA
92: */
93:
94: (*s_etat_processus).erreur_systeme = d_es;
95: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
96: return;
97: }
98: else
99: {
100: /*
101: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
102: * d'une variable SIGMA globale...
103: */
104:
105: i = (*s_etat_processus).position_variable_courante;
106: presence_variable = d_faux;
107:
108: while(i >= 0)
109: {
110: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
111: ds_sdat) == 0) && ((*s_etat_processus)
112: .s_liste_variables[i].niveau == 1))
113: {
114: presence_variable = d_vrai;
115: break;
116: }
117:
118: i--;
119: }
120:
121: if (presence_variable == d_faux)
122: {
123: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
124: return;
125: }
126: else
127: {
128: (*s_etat_processus).position_variable_courante = i;
129:
130: if (((*s_etat_processus).s_liste_variables[i]).objet == NULL)
131: {
132: (*s_etat_processus).erreur_execution =
133: d_ex_variable_partagee;
134: return;
135: }
136:
137: if (((*((*s_etat_processus).s_liste_variables
138: [(*s_etat_processus).position_variable_courante].objet))
139: .type != MIN) && ((*((*s_etat_processus)
140: .s_liste_variables[(*s_etat_processus)
141: .position_variable_courante].objet)).type != MRL))
142: {
143: (*s_etat_processus).erreur_execution =
144: d_ex_matrice_statistique_invalide;
145: return;
146: }
147:
148: nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
149: .s_liste_variables[(*s_etat_processus)
150: .position_variable_courante].objet)).objet))
151: .nombre_colonnes;
152: }
153: }
154:
155: s_objet_statistique = ((*s_etat_processus).s_liste_variables
156: [(*s_etat_processus).position_variable_courante]).objet;
157:
158: if (((*s_objet_statistique).type == MIN) ||
159: ((*s_objet_statistique).type == MRL))
160: {
161: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
162: ((*s_etat_processus).colonne_statistique_2 < 1) ||
163: ((*s_etat_processus).colonne_statistique_1 > nombre_colonnes) ||
164: ((*s_etat_processus).colonne_statistique_2 > nombre_colonnes))
165: {
166: (*s_etat_processus).erreur_execution =
167: d_ex_observations_inexistantes;
168: return;
169: }
170:
171: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
172: {
173: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
174: return;
175: }
176:
177: (*((real8 *) (*s_objet_resultat).objet)) = covariance_statistique(
178: (struct_matrice *) (*s_objet_statistique).objet,
179: (*s_etat_processus).colonne_statistique_1,
180: (*s_etat_processus).colonne_statistique_2, 'N', &erreur);
181:
182: if (erreur == d_erreur)
183: {
184: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
185: return;
186: }
187: }
188: else
189: {
190: (*s_etat_processus).erreur_execution =
191: d_ex_matrice_statistique_invalide;
192: return;
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: return;
202: }
203:
204:
205: /*
206: ================================================================================
207: Fonction 'prlcd'
208: ================================================================================
209: Entrées :
210: --------------------------------------------------------------------------------
211: Sorties :
212: --------------------------------------------------------------------------------
213: Effets de bord : néant
214: ================================================================================
215: */
216:
217: void
218: instruction_prlcd(struct_processus *s_etat_processus)
219: {
220: (*s_etat_processus).erreur_execution = d_ex;
221:
222: if ((*s_etat_processus).affichage_arguments == 'Y')
223: {
224: printf("\n PRLCD ");
225:
226: if ((*s_etat_processus).langue == 'F')
227: {
228: printf("(impression puis destruction de la file graphique)\n\n");
229: printf(" Aucun argument\n");
230: }
231: else
232: {
233: printf("(print and purge the graphical queue)\n\n");
234: printf(" No argument\n");
235: }
236:
237: return;
238: }
239: else if ((*s_etat_processus).test_instruction == 'Y')
240: {
241: (*s_etat_processus).nombre_arguments = -1;
242: return;
243: }
244:
245: if (test_cfsf(s_etat_processus, 31) == d_vrai)
246: {
247: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
248: {
249: return;
250: }
251: }
252:
253: appel_gnuplot(s_etat_processus, 'I');
254:
255: (*s_etat_processus).exception = d_ep;
256:
257: return;
258: }
259:
260:
261: /*
262: ================================================================================
263: Fonction 'putc'
264: ================================================================================
265: Entrées :
266: --------------------------------------------------------------------------------
267: Sorties :
268: --------------------------------------------------------------------------------
269: Effets de bord : néant
270: ================================================================================
271: */
272:
273: void
274: instruction_putc(struct_processus *s_etat_processus)
275: {
276: integer8 position;
277:
278: logical1 presence_nom;
279: logical1 variable_partagee;
280:
281: struct_liste_chainee *l_element_courant;
282:
283: struct_objet *s_copie_argument_3;
284: struct_objet *s_objet_argument_1;
285: struct_objet *s_objet_argument_2;
286: struct_objet *s_objet_argument_3;
287:
288: unsigned long i;
289: unsigned long j;
290: unsigned long nombre_elements;
291:
292: void *tampon;
293:
294: (*s_etat_processus).erreur_execution = d_ex;
295:
296: if ((*s_etat_processus).affichage_arguments == 'Y')
297: {
298: printf("\n PUTC ");
299:
300: if ((*s_etat_processus).langue == 'F')
301: {
302: printf("(change une colonne)\n\n");
303: }
304: else
305: {
306: printf("(change column)\n\n");
307: }
308:
309: printf(" 3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
310: printf(" 2: %s\n", d_LST);
311: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
312: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
313:
314: printf(" 3: %s\n", d_NOM);
315: printf(" 2: %s\n", d_LST);
316: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
317:
318: return;
319: }
320: else if ((*s_etat_processus).test_instruction == 'Y')
321: {
322: (*s_etat_processus).nombre_arguments = -1;
323: return;
324: }
325:
326: if (test_cfsf(s_etat_processus, 31) == d_vrai)
327: {
328: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
329: {
330: return;
331: }
332: }
333:
334: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
335: &s_objet_argument_1) == d_erreur)
336: {
337: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
338: return;
339: }
340:
341: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
342: &s_objet_argument_2) == d_erreur)
343: {
344: liberation(s_etat_processus, s_objet_argument_1);
345:
346: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
347: return;
348: }
349:
350: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
351: &s_objet_argument_3) == d_erreur)
352: {
353: liberation(s_etat_processus, s_objet_argument_1);
354: liberation(s_etat_processus, s_objet_argument_2);
355:
356: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
357: return;
358: }
359:
360: if (((*s_objet_argument_1).type != MIN) &&
361: ((*s_objet_argument_1).type != MRL) &&
362: ((*s_objet_argument_1).type != MCX))
363: {
364: liberation(s_etat_processus, s_objet_argument_1);
365: liberation(s_etat_processus, s_objet_argument_2);
366: liberation(s_etat_processus, s_objet_argument_3);
367:
368: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
369: return;
370: }
371:
372: if ((*s_objet_argument_2).type != LST)
373: {
374: liberation(s_etat_processus, s_objet_argument_1);
375: liberation(s_etat_processus, s_objet_argument_2);
376: liberation(s_etat_processus, s_objet_argument_3);
377:
378: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
379: return;
380: }
381:
382: nombre_elements = 0;
383: l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet;
384:
385: while(l_element_courant != NULL)
386: {
387: if ((*(*l_element_courant).donnee).type != INT)
388: {
389: liberation(s_etat_processus, s_objet_argument_1);
390: liberation(s_etat_processus, s_objet_argument_2);
391: liberation(s_etat_processus, s_objet_argument_3);
392:
393: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
394: return;
395: }
396:
397: nombre_elements++;
398: l_element_courant = (*l_element_courant).suivant;
399: }
400:
401: if ((nombre_elements == 0) || (nombre_elements != (*((struct_matrice *)
402: (*s_objet_argument_1).objet)).nombre_colonnes))
403: {
404: liberation(s_etat_processus, s_objet_argument_1);
405: liberation(s_etat_processus, s_objet_argument_2);
406: liberation(s_etat_processus, s_objet_argument_3);
407:
408: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
409: return;
410: }
411:
412: variable_partagee = d_faux;
413:
414: if ((*s_objet_argument_3).type == NOM)
415: {
416: presence_nom = d_vrai;
417:
418: if (recherche_variable(s_etat_processus, (*((struct_nom *)
419: (*s_objet_argument_3).objet)).nom) == d_faux)
420: {
421: (*s_etat_processus).erreur_systeme = d_es;
422: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
423:
424: liberation(s_etat_processus, s_objet_argument_1);
425: liberation(s_etat_processus, s_objet_argument_2);
426: liberation(s_etat_processus, s_objet_argument_3);
427:
428: return;
429: }
430:
431: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
432: .position_variable_courante].variable_verrouillee == d_vrai)
433: {
434: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
435:
436: liberation(s_etat_processus, s_objet_argument_1);
437: liberation(s_etat_processus, s_objet_argument_2);
438: liberation(s_etat_processus, s_objet_argument_3);
439:
440: return;
441: }
442:
443: liberation(s_etat_processus, s_objet_argument_3);
444: s_objet_argument_3 = (*s_etat_processus).s_liste_variables
445: [(*s_etat_processus).position_variable_courante].objet;
446:
447: if (s_objet_argument_3 == NULL)
448: {
449: if (pthread_mutex_lock(&((*(*s_etat_processus)
450: .s_liste_variables_partagees).mutex)) != 0)
451: {
452: (*s_etat_processus).erreur_systeme = d_es_processus;
453: return;
454: }
455:
456: if (recherche_variable_partagee(s_etat_processus,
457: (*s_etat_processus).s_liste_variables
458: [(*s_etat_processus).position_variable_courante].nom,
459: (*s_etat_processus).s_liste_variables
460: [(*s_etat_processus).position_variable_courante]
461: .variable_partagee, (*s_etat_processus).s_liste_variables
462: [(*s_etat_processus).position_variable_courante].origine)
463: == d_faux)
464: {
465: if (pthread_mutex_unlock(&((*(*s_etat_processus)
466: .s_liste_variables_partagees).mutex)) != 0)
467: {
468: (*s_etat_processus).erreur_systeme = d_es_processus;
469: return;
470: }
471:
472: (*s_etat_processus).erreur_systeme = d_es;
473: (*s_etat_processus).erreur_execution =
474: d_ex_variable_non_definie;
475:
476: liberation(s_etat_processus, s_objet_argument_1);
477: liberation(s_etat_processus, s_objet_argument_2);
478:
479: return;
480: }
481:
482: s_objet_argument_3 = (*(*s_etat_processus)
483: .s_liste_variables_partagees).table[(*(*s_etat_processus)
484: .s_liste_variables_partagees).position_variable].objet;
485: variable_partagee = d_vrai;
486: }
487:
488: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
489: s_objet_argument_3, 'O')) == NULL)
490: {
491: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
492: return;
493: }
494:
495: liberation(s_etat_processus, s_objet_argument_3);
496: s_objet_argument_3 = s_copie_argument_3;
497:
498: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
499: .position_variable_courante].objet = s_objet_argument_3;
500: }
501: else
502: {
503: presence_nom = d_faux;
504:
505: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
506: s_objet_argument_3, 'O')) == NULL)
507: {
508: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
509: return;
510: }
511:
512: liberation(s_etat_processus, s_objet_argument_3);
513: s_objet_argument_3 = s_copie_argument_3;
514: }
515:
516: if ((*s_objet_argument_1).type == MRL)
517: {
518: if ((*s_objet_argument_3).type == MIN)
519: {
520: // Conversion de la matrice entière en matrice réelle
521:
522: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
523: .nombre_lignes; i++)
524: {
525: tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
526: .tableau[i];
527:
528: if (((*((struct_matrice *) (*s_objet_argument_3).objet))
529: .tableau[i] = malloc((*((struct_matrice *)
530: (*s_objet_argument_3).objet)).nombre_colonnes *
531: sizeof(real8))) == NULL)
532: {
533: if (variable_partagee == d_vrai)
534: {
535: if (pthread_mutex_unlock(&((*(*s_etat_processus)
536: .s_liste_variables_partagees).mutex)) != 0)
537: {
538: (*s_etat_processus).erreur_systeme = d_es_processus;
539: return;
540: }
541: }
542:
543: (*s_etat_processus).erreur_systeme =
544: d_es_allocation_memoire;
545: return;
546: }
547:
548: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
549: .objet)).nombre_colonnes; j++)
550: {
551: ((real8 **) (*((struct_matrice *) (*s_objet_argument_3)
552: .objet)).tableau)[i][j] = (real8) (((integer8 *)
553: tampon)[j]);
554: }
555:
556: free(tampon);
557: }
558:
559: (*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'R';
560: (*s_objet_argument_3).type = MRL;
561: }
562: }
563: else if ((*s_objet_argument_1).type == MCX)
564: {
565: if ((*s_objet_argument_3).type == MIN)
566: {
567: // Conversion de la matrice entière en matrice complexe
568:
569: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
570: .nombre_lignes; i++)
571: {
572: tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
573: .tableau[i];
574:
575: if (((*((struct_matrice *) (*s_objet_argument_3).objet))
576: .tableau[i] = malloc((*((struct_matrice *)
577: (*s_objet_argument_3).objet)).nombre_colonnes *
578: sizeof(complex16))) == NULL)
579: {
580: if (variable_partagee == d_vrai)
581: {
582: if (pthread_mutex_unlock(&((*(*s_etat_processus)
583: .s_liste_variables_partagees).mutex)) != 0)
584: {
585: (*s_etat_processus).erreur_systeme = d_es_processus;
586: return;
587: }
588: }
589:
590: (*s_etat_processus).erreur_systeme =
591: d_es_allocation_memoire;
592: return;
593: }
594:
595: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
596: .objet)).nombre_colonnes; j++)
597: {
598: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
599: .objet)).tableau)[i][j].partie_reelle =
600: (real8) (((integer8 *) tampon)[j]);
601: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
602: .objet)).tableau)[i][j].partie_imaginaire = 0;
603: }
604:
605: free(tampon);
606: }
607:
608: (*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'C';
609: (*s_objet_argument_3).type = MCX;
610: }
611: else if ((*s_objet_argument_3).type == MRL)
612: {
613: // Conversion de la matrice réelle en matrice complexe
614:
615: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
616: .nombre_lignes; i++)
617: {
618: tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
619: .tableau[i];
620:
621: if (((*((struct_matrice *) (*s_objet_argument_3).objet))
622: .tableau[i] = malloc((*((struct_matrice *)
623: (*s_objet_argument_3).objet)).nombre_colonnes *
624: sizeof(complex16))) == NULL)
625: {
626: if (variable_partagee == d_vrai)
627: {
628: if (pthread_mutex_unlock(&((*(*s_etat_processus)
629: .s_liste_variables_partagees).mutex)) != 0)
630: {
631: (*s_etat_processus).erreur_systeme = d_es_processus;
632: return;
633: }
634: }
635:
636: (*s_etat_processus).erreur_systeme =
637: d_es_allocation_memoire;
638: return;
639: }
640:
641: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
642: .objet)).nombre_colonnes; j++)
643: {
644: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
645: .objet)).tableau)[i][j].partie_reelle =
646: ((real8 *) tampon)[j];
647: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
648: .objet)).tableau)[i][j].partie_imaginaire = 0;
649: }
650:
651: free(tampon);
652: }
653:
654: (*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'C';
655: (*s_objet_argument_3).type = MCX;
656: }
657: }
658:
659: if ((*s_objet_argument_3).type == MIN)
660: {
661: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
662: != (*((struct_matrice *) (*s_objet_argument_3).objet))
663: .nombre_lignes)
664: {
665: if (variable_partagee == d_vrai)
666: {
667: if (pthread_mutex_unlock(&((*(*s_etat_processus)
668: .s_liste_variables_partagees).mutex)) != 0)
669: {
670: (*s_etat_processus).erreur_systeme = d_es_processus;
671: return;
672: }
673: }
674:
675: liberation(s_etat_processus, s_objet_argument_1);
676: liberation(s_etat_processus, s_objet_argument_2);
677:
678: if (presence_nom == d_faux)
679: {
680: liberation(s_etat_processus, s_objet_argument_3);
681: }
682:
683: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
684: return;
685: }
686:
687: l_element_courant = (struct_liste_chainee *)
688: (*s_objet_argument_2).objet;
689: i = 0;
690:
691: while(l_element_courant != NULL)
692: {
693: position = (*((integer8 *) (*(*l_element_courant).donnee).objet));
694:
695: if ((position < 1) || (position > (integer8) (*((struct_matrice *)
696: (*s_objet_argument_3).objet)).nombre_colonnes))
697: {
698: if (variable_partagee == d_vrai)
699: {
700: if (pthread_mutex_unlock(&((*(*s_etat_processus)
701: .s_liste_variables_partagees).mutex)) != 0)
702: {
703: (*s_etat_processus).erreur_systeme = d_es_processus;
704: return;
705: }
706: }
707:
708: liberation(s_etat_processus, s_objet_argument_1);
709: liberation(s_etat_processus, s_objet_argument_2);
710:
711: if (presence_nom == d_faux)
712: {
713: liberation(s_etat_processus, s_objet_argument_3);
714: }
715:
716: (*s_etat_processus).erreur_execution =
717: d_ex_argument_invalide;
718: return;
719: }
720:
721: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3).objet))
722: .nombre_lignes; j++)
723: {
724: ((integer8 **) (*((struct_matrice *) (*s_objet_argument_3)
725: .objet)).tableau)[j][position - 1] = ((integer8 **)
726: (*((struct_matrice *) (*s_objet_argument_1).objet))
727: .tableau)[j][i];
728: }
729:
730: l_element_courant = (*l_element_courant).suivant;
731: i++;
732: }
733: }
734: else if ((*s_objet_argument_3).type == MRL)
735: {
736: if ((*s_objet_argument_1).type == MIN)
737: {
738: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
739: .nombre_lignes != (*((struct_matrice *)
740: (*s_objet_argument_3).objet)).nombre_lignes)
741: {
742: if (variable_partagee == d_vrai)
743: {
744: if (pthread_mutex_unlock(&((*(*s_etat_processus)
745: .s_liste_variables_partagees).mutex)) != 0)
746: {
747: (*s_etat_processus).erreur_systeme = d_es_processus;
748: return;
749: }
750: }
751:
752: liberation(s_etat_processus, s_objet_argument_1);
753: liberation(s_etat_processus, s_objet_argument_2);
754:
755: if (presence_nom == d_faux)
756: {
757: liberation(s_etat_processus, s_objet_argument_3);
758: }
759:
760: (*s_etat_processus).erreur_execution =
761: d_ex_dimensions_invalides;
762: return;
763: }
764:
765: l_element_courant = (struct_liste_chainee *)
766: (*s_objet_argument_2).objet;
767: i = 0;
768:
769: while(l_element_courant != NULL)
770: {
771: position = (*((integer8 *) (*(*l_element_courant)
772: .donnee).objet));
773:
774: if ((position < 1) || (position > (integer8)
775: (*((struct_matrice *)(*s_objet_argument_3).objet))
776: .nombre_colonnes))
777: {
778: if (variable_partagee == d_vrai)
779: {
780: if (pthread_mutex_unlock(&((*(*s_etat_processus)
781: .s_liste_variables_partagees).mutex)) != 0)
782: {
783: (*s_etat_processus).erreur_systeme = d_es_processus;
784: return;
785: }
786: }
787:
788: liberation(s_etat_processus, s_objet_argument_1);
789: liberation(s_etat_processus, s_objet_argument_2);
790:
791: if (presence_nom == d_faux)
792: {
793: liberation(s_etat_processus, s_objet_argument_3);
794: }
795:
796: (*s_etat_processus).erreur_execution =
797: d_ex_erreur_type_argument;
798: return;
799: }
800:
801: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
802: .objet)).nombre_lignes; j++)
803: {
804: ((real8 **) (*((struct_matrice *) (*s_objet_argument_3)
805: .objet)).tableau)[j][position - 1] = (real8)
806: ((integer8 **) (*((struct_matrice *)
807: (*s_objet_argument_1).objet)).tableau)[j][i];
808: }
809:
810: l_element_courant = (*l_element_courant).suivant;
811: i++;
812: }
813: }
814: else // Matrice réelle
815: {
816: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
817: .nombre_lignes != (*((struct_matrice *)
818: (*s_objet_argument_3).objet)).nombre_lignes)
819: {
820: if (variable_partagee == d_vrai)
821: {
822: if (pthread_mutex_unlock(&((*(*s_etat_processus)
823: .s_liste_variables_partagees).mutex)) != 0)
824: {
825: (*s_etat_processus).erreur_systeme = d_es_processus;
826: return;
827: }
828: }
829:
830: liberation(s_etat_processus, s_objet_argument_1);
831: liberation(s_etat_processus, s_objet_argument_2);
832:
833: if (presence_nom == d_faux)
834: {
835: liberation(s_etat_processus, s_objet_argument_3);
836: }
837:
838: (*s_etat_processus).erreur_execution =
839: d_ex_dimensions_invalides;
840: return;
841: }
842:
843: l_element_courant = (struct_liste_chainee *)
844: (*s_objet_argument_2).objet;
845: i = 0;
846:
847: while(l_element_courant != NULL)
848: {
849: position = (*((integer8 *) (*(*l_element_courant)
850: .donnee).objet));
851:
852: if ((position < 1) || (position > (integer8)
853: (*((struct_matrice *) (*s_objet_argument_3).objet))
854: .nombre_colonnes))
855: {
856: if (variable_partagee == d_vrai)
857: {
858: if (pthread_mutex_unlock(&((*(*s_etat_processus)
859: .s_liste_variables_partagees).mutex)) != 0)
860: {
861: (*s_etat_processus).erreur_systeme = d_es_processus;
862: return;
863: }
864: }
865:
866: liberation(s_etat_processus, s_objet_argument_1);
867: liberation(s_etat_processus, s_objet_argument_2);
868:
869: if (presence_nom == d_faux)
870: {
871: liberation(s_etat_processus, s_objet_argument_3);
872: }
873:
874: (*s_etat_processus).erreur_execution =
875: d_ex_argument_invalide;
876: return;
877: }
878:
879: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
880: .objet)).nombre_lignes; j++)
881: {
882: ((real8 **) (*((struct_matrice *) (*s_objet_argument_3)
883: .objet)).tableau)[j][position - 1] =
884: ((real8 **) (*((struct_matrice *)
885: (*s_objet_argument_1).objet)).tableau)[j][i];
886: }
887:
888: l_element_courant = (*l_element_courant).suivant;
889: i++;
890: }
891: }
892: }
893: else if ((*s_objet_argument_3).type == MCX)
894: {
895: if ((*s_objet_argument_1).type == MIN)
896: {
897: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
898: .nombre_lignes != (*((struct_matrice *)
899: (*s_objet_argument_3).objet)).nombre_lignes)
900: {
901: if (variable_partagee == d_vrai)
902: {
903: if (pthread_mutex_unlock(&((*(*s_etat_processus)
904: .s_liste_variables_partagees).mutex)) != 0)
905: {
906: (*s_etat_processus).erreur_systeme = d_es_processus;
907: return;
908: }
909: }
910:
911: liberation(s_etat_processus, s_objet_argument_1);
912: liberation(s_etat_processus, s_objet_argument_2);
913:
914: if (presence_nom == d_faux)
915: {
916: liberation(s_etat_processus, s_objet_argument_3);
917: }
918:
919: (*s_etat_processus).erreur_execution =
920: d_ex_dimensions_invalides;
921: return;
922: }
923:
924: l_element_courant = (struct_liste_chainee *)
925: (*s_objet_argument_2).objet;
926: i = 0;
927:
928: while(l_element_courant != NULL)
929: {
930: position = (*((integer8 *) (*(*l_element_courant)
931: .donnee).objet));
932:
933: if ((position < 1) || (position > (integer8)
934: (*((struct_matrice *) (*s_objet_argument_3).objet))
935: .nombre_colonnes))
936: {
937: if (variable_partagee == d_vrai)
938: {
939: if (pthread_mutex_unlock(&((*(*s_etat_processus)
940: .s_liste_variables_partagees).mutex)) != 0)
941: {
942: (*s_etat_processus).erreur_systeme = d_es_processus;
943: return;
944: }
945: }
946:
947: liberation(s_etat_processus, s_objet_argument_1);
948: liberation(s_etat_processus, s_objet_argument_2);
949:
950: if (presence_nom == d_faux)
951: {
952: liberation(s_etat_processus, s_objet_argument_3);
953: }
954:
955: (*s_etat_processus).erreur_execution =
956: d_ex_argument_invalide;
957: return;
958: }
959:
960: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
961: .objet)).nombre_lignes; j++)
962: {
963: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
964: .objet)).tableau)[j][position - 1].partie_reelle =
965: (real8) ((integer8 **) (*((struct_matrice *)
966: (*s_objet_argument_1).objet)).tableau)[j][i];
967: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
968: .objet)).tableau)[j][position - 1]
969: .partie_imaginaire = 0;
970: }
971:
972: l_element_courant = (*l_element_courant).suivant;
973: i++;
974: }
975: }
976: else if ((*s_objet_argument_1).type == MRL)
977: {
978: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
979: .nombre_lignes != (*((struct_matrice *)
980: (*s_objet_argument_3).objet)).nombre_lignes)
981: {
982: if (variable_partagee == d_vrai)
983: {
984: if (pthread_mutex_unlock(&((*(*s_etat_processus)
985: .s_liste_variables_partagees).mutex)) != 0)
986: {
987: (*s_etat_processus).erreur_systeme = d_es_processus;
988: return;
989: }
990: }
991:
992: liberation(s_etat_processus, s_objet_argument_1);
993: liberation(s_etat_processus, s_objet_argument_2);
994:
995: if (presence_nom == d_faux)
996: {
997: liberation(s_etat_processus, s_objet_argument_3);
998: }
999:
1000: (*s_etat_processus).erreur_execution =
1001: d_ex_dimensions_invalides;
1002: return;
1003: }
1004:
1005: l_element_courant = (struct_liste_chainee *)
1006: (*s_objet_argument_2).objet;
1007: i = 0;
1008:
1009: while(l_element_courant != NULL)
1010: {
1011: position = (*((integer8 *) (*(*l_element_courant)
1012: .donnee).objet));
1013:
1014: if ((position < 1) || (position > (integer8)
1015: (*((struct_matrice *) (*s_objet_argument_3).objet))
1016: .nombre_colonnes))
1017: {
1018: if (variable_partagee == d_vrai)
1019: {
1020: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1021: .s_liste_variables_partagees).mutex)) != 0)
1022: {
1023: (*s_etat_processus).erreur_systeme = d_es_processus;
1024: return;
1025: }
1026: }
1027:
1028: liberation(s_etat_processus, s_objet_argument_1);
1029: liberation(s_etat_processus, s_objet_argument_2);
1030:
1031: if (presence_nom == d_faux)
1032: {
1033: liberation(s_etat_processus, s_objet_argument_3);
1034: }
1035:
1036: (*s_etat_processus).erreur_execution =
1037: d_ex_argument_invalide;
1038: return;
1039: }
1040:
1041: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1042: .objet)).nombre_lignes; j++)
1043: {
1044: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1045: .objet)).tableau)[j][position - 1].partie_reelle =
1046: ((real8 **) (*((struct_matrice *)
1047: (*s_objet_argument_1).objet)).tableau)[j][i];
1048: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1049: .objet)).tableau)[j][position - 1]
1050: .partie_imaginaire = 0;
1051: }
1052:
1053: l_element_courant = (*l_element_courant).suivant;
1054: i++;
1055: }
1056: }
1057: else // Matrice complexe
1058: {
1059: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
1060: .nombre_lignes != (*((struct_matrice *)
1061: (*s_objet_argument_3).objet)).nombre_lignes)
1062: {
1063: if (variable_partagee == d_vrai)
1064: {
1065: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1066: .s_liste_variables_partagees).mutex)) != 0)
1067: {
1068: (*s_etat_processus).erreur_systeme = d_es_processus;
1069: return;
1070: }
1071: }
1072:
1073: liberation(s_etat_processus, s_objet_argument_1);
1074: liberation(s_etat_processus, s_objet_argument_2);
1075:
1076: if (presence_nom == d_faux)
1077: {
1078: liberation(s_etat_processus, s_objet_argument_3);
1079: }
1080:
1081: (*s_etat_processus).erreur_execution =
1082: d_ex_dimensions_invalides;
1083: return;
1084: }
1085:
1086: l_element_courant = (struct_liste_chainee *)
1087: (*s_objet_argument_2).objet;
1088: i = 0;
1089:
1090: while(l_element_courant != NULL)
1091: {
1092: position = (*((integer8 *) (*(*l_element_courant)
1093: .donnee).objet));
1094:
1095: if ((position < 1) || (position > (integer8)
1096: (*((struct_matrice *) (*s_objet_argument_3).objet))
1097: .nombre_colonnes))
1098: {
1099: if (variable_partagee == d_vrai)
1100: {
1101: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1102: .s_liste_variables_partagees).mutex)) != 0)
1103: {
1104: (*s_etat_processus).erreur_systeme = d_es_processus;
1105: return;
1106: }
1107: }
1108:
1109: liberation(s_etat_processus, s_objet_argument_1);
1110: liberation(s_etat_processus, s_objet_argument_2);
1111:
1112: if (presence_nom == d_faux)
1113: {
1114: liberation(s_etat_processus, s_objet_argument_3);
1115: }
1116:
1117: (*s_etat_processus).erreur_execution =
1118: d_ex_argument_invalide;
1119: return;
1120: }
1121:
1122: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1123: .objet)).nombre_lignes; j++)
1124: {
1125: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1126: .objet)).tableau)[j][position - 1].partie_reelle =
1127: ((complex16 **) (*((struct_matrice *)
1128: (*s_objet_argument_1).objet)).tableau)[j][i]
1129: .partie_reelle;
1130: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1131: .objet)).tableau)[j][position - 1]
1132: .partie_imaginaire = ((complex16 **)
1133: (*((struct_matrice *) (*s_objet_argument_1).objet))
1134: .tableau)[j][i].partie_imaginaire;
1135: }
1136:
1137: l_element_courant = (*l_element_courant).suivant;
1138: i++;
1139: }
1140: }
1141: }
1142: else
1143: {
1144: if (variable_partagee == d_vrai)
1145: {
1146: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1147: .s_liste_variables_partagees).mutex)) != 0)
1148: {
1149: (*s_etat_processus).erreur_systeme = d_es_processus;
1150: return;
1151: }
1152: }
1153:
1154: liberation(s_etat_processus, s_objet_argument_1);
1155: liberation(s_etat_processus, s_objet_argument_2);
1156:
1157: if (presence_nom == d_faux)
1158: {
1159: liberation(s_etat_processus, s_objet_argument_3);
1160: }
1161:
1162: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1163: return;
1164: }
1165:
1166: if (presence_nom == d_faux)
1167: {
1168: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1169: s_objet_argument_3) == d_erreur)
1170: {
1171: return;
1172: }
1173: }
1174: else if (variable_partagee == d_vrai)
1175: {
1176: (*(*s_etat_processus).s_liste_variables_partagees).table
1177: [(*(*s_etat_processus).s_liste_variables_partagees)
1178: .position_variable].objet = s_objet_argument_3;
1179:
1180: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1181: .s_liste_variables_partagees).mutex)) != 0)
1182: {
1183: (*s_etat_processus).erreur_systeme = d_es_processus;
1184: return;
1185: }
1186: }
1187:
1188: liberation(s_etat_processus, s_objet_argument_1);
1189: liberation(s_etat_processus, s_objet_argument_2);
1190:
1191: return;
1192: }
1193:
1194:
1195: /*
1196: ================================================================================
1197: Fonction 'putr'
1198: ================================================================================
1199: Entrées :
1200: --------------------------------------------------------------------------------
1201: Sorties :
1202: --------------------------------------------------------------------------------
1203: Effets de bord : néant
1204: ================================================================================
1205: */
1206:
1207: void
1208: instruction_putr(struct_processus *s_etat_processus)
1209: {
1210: integer8 position;
1211:
1212: logical1 presence_nom;
1213: logical1 variable_partagee;
1214:
1215: struct_liste_chainee *l_element_courant;
1216:
1217: struct_objet *s_copie_argument_3;
1218: struct_objet *s_objet_argument_1;
1219: struct_objet *s_objet_argument_2;
1220: struct_objet *s_objet_argument_3;
1221:
1222: unsigned long i;
1223: unsigned long j;
1224: unsigned long nombre_elements;
1225:
1226: void *tampon;
1227:
1228: (*s_etat_processus).erreur_execution = d_ex;
1229:
1230: if ((*s_etat_processus).affichage_arguments == 'Y')
1231: {
1232: printf("\n PUTR ");
1233:
1234: if ((*s_etat_processus).langue == 'F')
1235: {
1236: printf("(change une ligne)\n\n");
1237: }
1238: else
1239: {
1240: printf("(change row)\n\n");
1241: }
1242:
1243: printf(" 3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1244: printf(" 2: %s\n", d_LST);
1245: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1246: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
1247:
1248: printf(" 3: %s\n", d_NOM);
1249: printf(" 2: %s\n", d_LST);
1250: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1251:
1252: return;
1253: }
1254: else if ((*s_etat_processus).test_instruction == 'Y')
1255: {
1256: (*s_etat_processus).nombre_arguments = -1;
1257: return;
1258: }
1259:
1260: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1261: {
1262: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1263: {
1264: return;
1265: }
1266: }
1267:
1268: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1269: &s_objet_argument_1) == d_erreur)
1270: {
1271: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1272: return;
1273: }
1274:
1275: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1276: &s_objet_argument_2) == d_erreur)
1277: {
1278: liberation(s_etat_processus, s_objet_argument_1);
1279:
1280: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1281: return;
1282: }
1283:
1284: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1285: &s_objet_argument_3) == d_erreur)
1286: {
1287: liberation(s_etat_processus, s_objet_argument_1);
1288: liberation(s_etat_processus, s_objet_argument_2);
1289:
1290: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1291: return;
1292: }
1293:
1294: if (((*s_objet_argument_1).type != MIN) &&
1295: ((*s_objet_argument_1).type != MRL) &&
1296: ((*s_objet_argument_1).type != MCX))
1297: {
1298: liberation(s_etat_processus, s_objet_argument_1);
1299: liberation(s_etat_processus, s_objet_argument_2);
1300: liberation(s_etat_processus, s_objet_argument_3);
1301:
1302: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1303: return;
1304: }
1305:
1306: if ((*s_objet_argument_2).type != LST)
1307: {
1308: liberation(s_etat_processus, s_objet_argument_1);
1309: liberation(s_etat_processus, s_objet_argument_2);
1310: liberation(s_etat_processus, s_objet_argument_3);
1311:
1312: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1313: return;
1314: }
1315:
1316: nombre_elements = 0;
1317: l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet;
1318:
1319: while(l_element_courant != NULL)
1320: {
1321: if ((*(*l_element_courant).donnee).type != INT)
1322: {
1323: liberation(s_etat_processus, s_objet_argument_1);
1324: liberation(s_etat_processus, s_objet_argument_2);
1325: liberation(s_etat_processus, s_objet_argument_3);
1326:
1327: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1328: return;
1329: }
1330:
1331: nombre_elements++;
1332: l_element_courant = (*l_element_courant).suivant;
1333: }
1334:
1335: if ((nombre_elements == 0) || (nombre_elements != (*((struct_matrice *)
1336: (*s_objet_argument_1).objet)).nombre_lignes))
1337: {
1338: liberation(s_etat_processus, s_objet_argument_1);
1339: liberation(s_etat_processus, s_objet_argument_2);
1340: liberation(s_etat_processus, s_objet_argument_3);
1341:
1342: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1343: return;
1344: }
1345:
1346: variable_partagee = d_faux;
1347:
1348: if ((*s_objet_argument_3).type == NOM)
1349: {
1350: presence_nom = d_vrai;
1351:
1352: if (recherche_variable(s_etat_processus, (*((struct_nom *)
1353: (*s_objet_argument_3).objet)).nom) == d_faux)
1354: {
1355: (*s_etat_processus).erreur_systeme = d_es;
1356: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1357:
1358: liberation(s_etat_processus, s_objet_argument_1);
1359: liberation(s_etat_processus, s_objet_argument_2);
1360: liberation(s_etat_processus, s_objet_argument_3);
1361:
1362: return;
1363: }
1364:
1365: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
1366: .position_variable_courante].variable_verrouillee == d_vrai)
1367: {
1368: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
1369:
1370: liberation(s_etat_processus, s_objet_argument_1);
1371: liberation(s_etat_processus, s_objet_argument_2);
1372: liberation(s_etat_processus, s_objet_argument_3);
1373:
1374: return;
1375: }
1376:
1377: liberation(s_etat_processus, s_objet_argument_3);
1378: s_objet_argument_3 = (*s_etat_processus).s_liste_variables
1379: [(*s_etat_processus).position_variable_courante].objet;
1380:
1381: if (s_objet_argument_3 == NULL)
1382: {
1383: if (pthread_mutex_lock(&((*(*s_etat_processus)
1384: .s_liste_variables_partagees).mutex)) != 0)
1385: {
1386: (*s_etat_processus).erreur_systeme = d_es_processus;
1387: return;
1388: }
1389:
1390: if (recherche_variable_partagee(s_etat_processus,
1391: (*s_etat_processus).s_liste_variables
1392: [(*s_etat_processus).position_variable_courante].nom,
1393: (*s_etat_processus).s_liste_variables
1394: [(*s_etat_processus).position_variable_courante]
1395: .variable_partagee, (*s_etat_processus).s_liste_variables
1396: [(*s_etat_processus).position_variable_courante].origine)
1397: == d_faux)
1398: {
1399: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1400: .s_liste_variables_partagees).mutex)) != 0)
1401: {
1402: (*s_etat_processus).erreur_systeme = d_es_processus;
1403: return;
1404: }
1405:
1406: (*s_etat_processus).erreur_systeme = d_es;
1407: (*s_etat_processus).erreur_execution =
1408: d_ex_variable_non_definie;
1409:
1410: liberation(s_etat_processus, s_objet_argument_1);
1411: liberation(s_etat_processus, s_objet_argument_2);
1412:
1413: return;
1414: }
1415:
1416: s_objet_argument_3 = (*(*s_etat_processus)
1417: .s_liste_variables_partagees).table[(*(*s_etat_processus)
1418: .s_liste_variables_partagees).position_variable].objet;
1419: variable_partagee = d_vrai;
1420: }
1421:
1422: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
1423: s_objet_argument_3, 'Q')) == NULL)
1424: {
1425: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1426: return;
1427: }
1428:
1429: liberation(s_etat_processus, s_objet_argument_3);
1430: s_objet_argument_3 = s_copie_argument_3;
1431:
1432: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1433: .position_variable_courante].objet = s_objet_argument_3;
1434: }
1435: else
1436: {
1437: presence_nom = d_faux;
1438:
1439: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
1440: s_objet_argument_3, 'Q')) == NULL)
1441: {
1442: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1443: return;
1444: }
1445:
1446: liberation(s_etat_processus, s_objet_argument_3);
1447: s_objet_argument_3 = s_copie_argument_3;
1448: }
1449:
1450: if ((*s_objet_argument_1).type == MRL)
1451: {
1452: if ((*s_objet_argument_3).type == MIN)
1453: {
1454: // Conversion de la matrice entière en matrice réelle
1455:
1456: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
1457: .nombre_lignes; i++)
1458: {
1459: tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
1460: .tableau[i];
1461:
1462: if (((*((struct_matrice *) (*s_objet_argument_3).objet))
1463: .tableau[i] = malloc((*((struct_matrice *)
1464: (*s_objet_argument_3).objet)).nombre_colonnes *
1465: sizeof(real8))) == NULL)
1466: {
1467: if (variable_partagee == d_vrai)
1468: {
1469: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1470: .s_liste_variables_partagees).mutex)) != 0)
1471: {
1472: (*s_etat_processus).erreur_systeme = d_es_processus;
1473: return;
1474: }
1475: }
1476:
1477: (*s_etat_processus).erreur_systeme =
1478: d_es_allocation_memoire;
1479: return;
1480: }
1481:
1482: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1483: .objet)).nombre_colonnes; j++)
1484: {
1485: ((real8 **) (*((struct_matrice *) (*s_objet_argument_3)
1486: .objet)).tableau)[i][j] = (real8) (((integer8 *)
1487: tampon)[j]);
1488: }
1489:
1490: free(tampon);
1491: }
1492:
1493: (*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'R';
1494: (*s_objet_argument_3).type = MRL;
1495: }
1496: }
1497: else if ((*s_objet_argument_1).type == MCX)
1498: {
1499: if ((*s_objet_argument_3).type == MIN)
1500: {
1501: // Conversion de la matrice entière en matrice complexe
1502:
1503: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
1504: .nombre_lignes; i++)
1505: {
1506: tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
1507: .tableau[i];
1508:
1509: if (((*((struct_matrice *) (*s_objet_argument_3).objet))
1510: .tableau[i] = malloc((*((struct_matrice *)
1511: (*s_objet_argument_3).objet)).nombre_colonnes *
1512: sizeof(complex16))) == NULL)
1513: {
1514: if (variable_partagee == d_vrai)
1515: {
1516: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1517: .s_liste_variables_partagees).mutex)) != 0)
1518: {
1519: (*s_etat_processus).erreur_systeme = d_es_processus;
1520: return;
1521: }
1522: }
1523:
1524: (*s_etat_processus).erreur_systeme =
1525: d_es_allocation_memoire;
1526: return;
1527: }
1528:
1529: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1530: .objet)).nombre_colonnes; j++)
1531: {
1532: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1533: .objet)).tableau)[i][j].partie_reelle =
1534: (real8) (((integer8 *) tampon)[j]);
1535: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1536: .objet)).tableau)[i][j].partie_imaginaire = 0;
1537: }
1538:
1539: free(tampon);
1540: }
1541:
1542: (*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'C';
1543: (*s_objet_argument_3).type = MCX;
1544: }
1545: else if ((*s_objet_argument_3).type == MRL)
1546: {
1547: // Conversion de la matrice réelle en matrice complexe
1548:
1549: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
1550: .nombre_lignes; i++)
1551: {
1552: tampon = (*((struct_matrice *) (*s_objet_argument_3).objet))
1553: .tableau[i];
1554:
1555: if (((*((struct_matrice *) (*s_objet_argument_3).objet))
1556: .tableau[i] = malloc((*((struct_matrice *)
1557: (*s_objet_argument_3).objet)).nombre_colonnes *
1558: sizeof(complex16))) == NULL)
1559: {
1560: if (variable_partagee == d_vrai)
1561: {
1562: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1563: .s_liste_variables_partagees).mutex)) != 0)
1564: {
1565: (*s_etat_processus).erreur_systeme = d_es_processus;
1566: return;
1567: }
1568: }
1569:
1570: (*s_etat_processus).erreur_systeme =
1571: d_es_allocation_memoire;
1572: return;
1573: }
1574:
1575: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1576: .objet)).nombre_colonnes; j++)
1577: {
1578: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1579: .objet)).tableau)[i][j].partie_reelle =
1580: ((real8 *) tampon)[j];
1581: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1582: .objet)).tableau)[i][j].partie_imaginaire = 0;
1583: }
1584:
1585: free(tampon);
1586: }
1587:
1588: (*((struct_matrice *) (*s_objet_argument_3).objet)).type = 'C';
1589: (*s_objet_argument_3).type = MCX;
1590: }
1591: }
1592:
1593: if ((*s_objet_argument_3).type == MIN)
1594: {
1595: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_colonnes
1596: != (*((struct_matrice *) (*s_objet_argument_3).objet))
1597: .nombre_colonnes)
1598: {
1599: if (variable_partagee == d_vrai)
1600: {
1601: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1602: .s_liste_variables_partagees).mutex)) != 0)
1603: {
1604: (*s_etat_processus).erreur_systeme = d_es_processus;
1605: return;
1606: }
1607: }
1608:
1609: liberation(s_etat_processus, s_objet_argument_1);
1610: liberation(s_etat_processus, s_objet_argument_2);
1611:
1612: if (presence_nom == d_faux)
1613: {
1614: liberation(s_etat_processus, s_objet_argument_3);
1615: }
1616:
1617: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1618: return;
1619: }
1620:
1621: l_element_courant = (struct_liste_chainee *)
1622: (*s_objet_argument_2).objet;
1623: i = 0;
1624:
1625: while(l_element_courant != NULL)
1626: {
1627: position = (*((integer8 *) (*(*l_element_courant).donnee).objet));
1628:
1629: if ((position < 1) || (position > (integer8) (*((struct_matrice *)
1630: (*s_objet_argument_3).objet)).nombre_lignes))
1631: {
1632: if (variable_partagee == d_vrai)
1633: {
1634: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1635: .s_liste_variables_partagees).mutex)) != 0)
1636: {
1637: (*s_etat_processus).erreur_systeme = d_es_processus;
1638: return;
1639: }
1640: }
1641:
1642: liberation(s_etat_processus, s_objet_argument_1);
1643: liberation(s_etat_processus, s_objet_argument_2);
1644:
1645: if (presence_nom == d_faux)
1646: {
1647: liberation(s_etat_processus, s_objet_argument_3);
1648: }
1649:
1650: (*s_etat_processus).erreur_execution =
1651: d_ex_argument_invalide;
1652: return;
1653: }
1654:
1655: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3).objet))
1656: .nombre_colonnes; j++)
1657: {
1658: ((integer8 **) (*((struct_matrice *) (*s_objet_argument_3)
1659: .objet)).tableau)[position - 1][j] = ((integer8 **)
1660: (*((struct_matrice *) (*s_objet_argument_1).objet))
1661: .tableau)[i][j];
1662: }
1663:
1664: l_element_courant = (*l_element_courant).suivant;
1665: i++;
1666: }
1667: }
1668: else if ((*s_objet_argument_3).type == MRL)
1669: {
1670: if ((*s_objet_argument_1).type == MIN)
1671: {
1672: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
1673: .nombre_colonnes != (*((struct_matrice *)
1674: (*s_objet_argument_3).objet)).nombre_colonnes)
1675: {
1676: if (variable_partagee == d_vrai)
1677: {
1678: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1679: .s_liste_variables_partagees).mutex)) != 0)
1680: {
1681: (*s_etat_processus).erreur_systeme = d_es_processus;
1682: return;
1683: }
1684: }
1685:
1686: liberation(s_etat_processus, s_objet_argument_1);
1687: liberation(s_etat_processus, s_objet_argument_2);
1688:
1689: if (presence_nom == d_faux)
1690: {
1691: liberation(s_etat_processus, s_objet_argument_3);
1692: }
1693:
1694: (*s_etat_processus).erreur_execution =
1695: d_ex_dimensions_invalides;
1696: return;
1697: }
1698:
1699: l_element_courant = (struct_liste_chainee *)
1700: (*s_objet_argument_2).objet;
1701: i = 0;
1702:
1703: while(l_element_courant != NULL)
1704: {
1705: position = (*((integer8 *) (*(*l_element_courant)
1706: .donnee).objet));
1707:
1708: if ((position < 1) || (position > (integer8)
1709: (*((struct_matrice *) (*s_objet_argument_3).objet))
1710: .nombre_lignes))
1711: {
1712: if (variable_partagee == d_vrai)
1713: {
1714: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1715: .s_liste_variables_partagees).mutex)) != 0)
1716: {
1717: (*s_etat_processus).erreur_systeme = d_es_processus;
1718: return;
1719: }
1720: }
1721:
1722: liberation(s_etat_processus, s_objet_argument_1);
1723: liberation(s_etat_processus, s_objet_argument_2);
1724:
1725: if (presence_nom == d_faux)
1726: {
1727: liberation(s_etat_processus, s_objet_argument_3);
1728: }
1729:
1730: (*s_etat_processus).erreur_execution =
1731: d_ex_argument_invalide;
1732: return;
1733: }
1734:
1735: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1736: .objet)).nombre_colonnes; j++)
1737: {
1738: ((real8 **) (*((struct_matrice *) (*s_objet_argument_3)
1739: .objet)).tableau)[position - 1][j] = (real8)
1740: ((integer8 **) (*((struct_matrice *)
1741: (*s_objet_argument_1).objet)).tableau)[i][j];
1742: }
1743:
1744: l_element_courant = (*l_element_courant).suivant;
1745: i++;
1746: }
1747: }
1748: else // Matrice réelle
1749: {
1750: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
1751: .nombre_colonnes != (*((struct_matrice *)
1752: (*s_objet_argument_3).objet)).nombre_colonnes)
1753: {
1754: if (variable_partagee == d_vrai)
1755: {
1756: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1757: .s_liste_variables_partagees).mutex)) != 0)
1758: {
1759: (*s_etat_processus).erreur_systeme = d_es_processus;
1760: return;
1761: }
1762: }
1763:
1764: liberation(s_etat_processus, s_objet_argument_1);
1765: liberation(s_etat_processus, s_objet_argument_2);
1766:
1767: if (presence_nom == d_faux)
1768: {
1769: liberation(s_etat_processus, s_objet_argument_3);
1770: }
1771:
1772: (*s_etat_processus).erreur_execution =
1773: d_ex_dimensions_invalides;
1774: return;
1775: }
1776:
1777: l_element_courant = (struct_liste_chainee *)
1778: (*s_objet_argument_2).objet;
1779: i = 0;
1780:
1781: while(l_element_courant != NULL)
1782: {
1783: position = (*((integer8 *) (*(*l_element_courant)
1784: .donnee).objet));
1785:
1786: if ((position < 1) || (position > (integer8)
1787: (*((struct_matrice *) (*s_objet_argument_3).objet))
1788: .nombre_lignes))
1789: {
1790: if (variable_partagee == d_vrai)
1791: {
1792: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1793: .s_liste_variables_partagees).mutex)) != 0)
1794: {
1795: (*s_etat_processus).erreur_systeme = d_es_processus;
1796: return;
1797: }
1798: }
1799:
1800: liberation(s_etat_processus, s_objet_argument_1);
1801: liberation(s_etat_processus, s_objet_argument_2);
1802:
1803: if (presence_nom == d_faux)
1804: {
1805: liberation(s_etat_processus, s_objet_argument_3);
1806: }
1807:
1808: (*s_etat_processus).erreur_execution =
1809: d_ex_argument_invalide;
1810: return;
1811: }
1812:
1813: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1814: .objet)).nombre_colonnes; j++)
1815: {
1816: ((real8 **) (*((struct_matrice *) (*s_objet_argument_3)
1817: .objet)).tableau)[position - 1][j] =
1818: ((real8 **) (*((struct_matrice *)
1819: (*s_objet_argument_1).objet)).tableau)[i][j];
1820: }
1821:
1822: l_element_courant = (*l_element_courant).suivant;
1823: i++;
1824: }
1825: }
1826: }
1827: else if ((*s_objet_argument_3).type == MCX)
1828: {
1829: if ((*s_objet_argument_1).type == MIN)
1830: {
1831: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
1832: .nombre_colonnes != (*((struct_matrice *)
1833: (*s_objet_argument_3).objet)).nombre_colonnes)
1834: {
1835: if (variable_partagee == d_vrai)
1836: {
1837: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1838: .s_liste_variables_partagees).mutex)) != 0)
1839: {
1840: (*s_etat_processus).erreur_systeme = d_es_processus;
1841: return;
1842: }
1843: }
1844:
1845: liberation(s_etat_processus, s_objet_argument_1);
1846: liberation(s_etat_processus, s_objet_argument_2);
1847:
1848: if (presence_nom == d_faux)
1849: {
1850: liberation(s_etat_processus, s_objet_argument_3);
1851: }
1852:
1853: (*s_etat_processus).erreur_execution =
1854: d_ex_dimensions_invalides;
1855: return;
1856: }
1857:
1858: l_element_courant = (struct_liste_chainee *)
1859: (*s_objet_argument_2).objet;
1860: i = 0;
1861:
1862: while(l_element_courant != NULL)
1863: {
1864: position = (*((integer8 *) (*(*l_element_courant)
1865: .donnee).objet));
1866:
1867: if ((position < 1) || (position > (integer8)
1868: (*((struct_matrice *) (*s_objet_argument_3).objet))
1869: .nombre_lignes))
1870: {
1871: if (variable_partagee == d_vrai)
1872: {
1873: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1874: .s_liste_variables_partagees).mutex)) != 0)
1875: {
1876: (*s_etat_processus).erreur_systeme = d_es_processus;
1877: return;
1878: }
1879: }
1880:
1881: liberation(s_etat_processus, s_objet_argument_1);
1882: liberation(s_etat_processus, s_objet_argument_2);
1883:
1884: if (presence_nom == d_faux)
1885: {
1886: liberation(s_etat_processus, s_objet_argument_3);
1887: }
1888:
1889: (*s_etat_processus).erreur_execution =
1890: d_ex_argument_invalide;
1891: return;
1892: }
1893:
1894: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1895: .objet)).nombre_colonnes; j++)
1896: {
1897: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1898: .objet)).tableau)[position - 1][j].partie_reelle =
1899: (real8) ((integer8 **) (*((struct_matrice *)
1900: (*s_objet_argument_1).objet)).tableau)[i][j];
1901: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1902: .objet)).tableau)[position - 1][j]
1903: .partie_imaginaire = 0;
1904: }
1905:
1906: l_element_courant = (*l_element_courant).suivant;
1907: i++;
1908: }
1909: }
1910: else if ((*s_objet_argument_1).type == MRL)
1911: {
1912: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
1913: .nombre_colonnes != (*((struct_matrice *)
1914: (*s_objet_argument_3).objet)).nombre_colonnes)
1915: {
1916: if (variable_partagee == d_vrai)
1917: {
1918: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1919: .s_liste_variables_partagees).mutex)) != 0)
1920: {
1921: (*s_etat_processus).erreur_systeme = d_es_processus;
1922: return;
1923: }
1924: }
1925:
1926: liberation(s_etat_processus, s_objet_argument_1);
1927: liberation(s_etat_processus, s_objet_argument_2);
1928:
1929: if (presence_nom == d_faux)
1930: {
1931: liberation(s_etat_processus, s_objet_argument_3);
1932: }
1933:
1934: (*s_etat_processus).erreur_execution =
1935: d_ex_dimensions_invalides;
1936: return;
1937: }
1938:
1939: l_element_courant = (struct_liste_chainee *)
1940: (*s_objet_argument_2).objet;
1941: i = 0;
1942:
1943: while(l_element_courant != NULL)
1944: {
1945: position = (*((integer8 *) (*(*l_element_courant)
1946: .donnee).objet));
1947:
1948: if ((position < 1) || (position > (integer8)
1949: (*((struct_matrice *) (*s_objet_argument_3).objet))
1950: .nombre_lignes))
1951: {
1952: if (variable_partagee == d_vrai)
1953: {
1954: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1955: .s_liste_variables_partagees).mutex)) != 0)
1956: {
1957: (*s_etat_processus).erreur_systeme = d_es_processus;
1958: return;
1959: }
1960: }
1961:
1962: liberation(s_etat_processus, s_objet_argument_1);
1963: liberation(s_etat_processus, s_objet_argument_2);
1964:
1965: if (presence_nom == d_faux)
1966: {
1967: liberation(s_etat_processus, s_objet_argument_3);
1968: }
1969:
1970: (*s_etat_processus).erreur_execution =
1971: d_ex_argument_invalide;
1972: return;
1973: }
1974:
1975: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
1976: .objet)).nombre_colonnes; j++)
1977: {
1978: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1979: .objet)).tableau)[position - 1][j].partie_reelle =
1980: ((real8 **) (*((struct_matrice *)
1981: (*s_objet_argument_1).objet)).tableau)[i][j];
1982: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
1983: .objet)).tableau)[position - 1][j]
1984: .partie_imaginaire = 0;
1985: }
1986:
1987: l_element_courant = (*l_element_courant).suivant;
1988: i++;
1989: }
1990: }
1991: else // Matrice complexe
1992: {
1993: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
1994: .nombre_colonnes != (*((struct_matrice *)
1995: (*s_objet_argument_3).objet)).nombre_colonnes)
1996: {
1997: if (variable_partagee == d_vrai)
1998: {
1999: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2000: .s_liste_variables_partagees).mutex)) != 0)
2001: {
2002: (*s_etat_processus).erreur_systeme = d_es_processus;
2003: return;
2004: }
2005: }
2006:
2007: liberation(s_etat_processus, s_objet_argument_1);
2008: liberation(s_etat_processus, s_objet_argument_2);
2009:
2010: if (presence_nom == d_faux)
2011: {
2012: liberation(s_etat_processus, s_objet_argument_3);
2013: }
2014:
2015: (*s_etat_processus).erreur_execution =
2016: d_ex_dimensions_invalides;
2017: return;
2018: }
2019:
2020: l_element_courant = (struct_liste_chainee *)
2021: (*s_objet_argument_2).objet;
2022: i = 0;
2023:
2024: while(l_element_courant != NULL)
2025: {
2026: position = (*((integer8 *) (*(*l_element_courant)
2027: .donnee).objet));
2028:
2029: if ((position < 1) || (position > (integer8)
2030: (*((struct_matrice *) (*s_objet_argument_3).objet))
2031: .nombre_lignes))
2032: {
2033: if (variable_partagee == d_vrai)
2034: {
2035: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2036: .s_liste_variables_partagees).mutex)) != 0)
2037: {
2038: (*s_etat_processus).erreur_systeme = d_es_processus;
2039: return;
2040: }
2041: }
2042:
2043: liberation(s_etat_processus, s_objet_argument_1);
2044: liberation(s_etat_processus, s_objet_argument_2);
2045:
2046: if (presence_nom == d_faux)
2047: {
2048: liberation(s_etat_processus, s_objet_argument_3);
2049: }
2050:
2051: (*s_etat_processus).erreur_execution =
2052: d_ex_argument_invalide;
2053: return;
2054: }
2055:
2056: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_3)
2057: .objet)).nombre_colonnes; j++)
2058: {
2059: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
2060: .objet)).tableau)[position - 1][j].partie_reelle =
2061: ((complex16 **) (*((struct_matrice *)
2062: (*s_objet_argument_1).objet)).tableau)[i][j]
2063: .partie_reelle;
2064: ((complex16 **) (*((struct_matrice *) (*s_objet_argument_3)
2065: .objet)).tableau)[position - 1][j]
2066: .partie_imaginaire = ((complex16 **)
2067: (*((struct_matrice *) (*s_objet_argument_1).objet))
2068: .tableau)[i][j].partie_imaginaire;
2069: }
2070:
2071: l_element_courant = (*l_element_courant).suivant;
2072: i++;
2073: }
2074: }
2075: }
2076: else
2077: {
2078: if (variable_partagee == d_vrai)
2079: {
2080: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2081: .s_liste_variables_partagees).mutex)) != 0)
2082: {
2083: (*s_etat_processus).erreur_systeme = d_es_processus;
2084: return;
2085: }
2086: }
2087:
2088: liberation(s_etat_processus, s_objet_argument_1);
2089: liberation(s_etat_processus, s_objet_argument_2);
2090:
2091: if (presence_nom == d_faux)
2092: {
2093: liberation(s_etat_processus, s_objet_argument_3);
2094: }
2095:
2096: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2097: return;
2098: }
2099:
2100: if (presence_nom == d_faux)
2101: {
2102: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2103: s_objet_argument_3) == d_erreur)
2104: {
2105: return;
2106: }
2107: }
2108: else if (variable_partagee == d_vrai)
2109: {
2110: (*(*s_etat_processus).s_liste_variables_partagees).table
2111: [(*(*s_etat_processus).s_liste_variables_partagees)
2112: .position_variable].objet = s_objet_argument_3;
2113:
2114: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2115: .s_liste_variables_partagees).mutex)) != 0)
2116: {
2117: (*s_etat_processus).erreur_systeme = d_es_processus;
2118: return;
2119: }
2120: }
2121:
2122: liberation(s_etat_processus, s_objet_argument_1);
2123: liberation(s_etat_processus, s_objet_argument_2);
2124:
2125: return;
2126: }
2127:
2128: // vim: ts=4