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