1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.12
4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction '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: unsigned long i;
52: unsigned long j;
53: unsigned long 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((*((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((*((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((*((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 > ((signed long) (*((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((((*((struct_matrice *) (*s_copie_argument_3)
474: .objet)).nombre_colonnes) + 1) * sizeof(integer8))) == NULL)
475: {
476: if (variable_partagee == d_vrai)
477: {
478: if (pthread_mutex_unlock(&((*(*s_etat_processus)
479: .pointeur_variable_partagee_courante).mutex)) != 0)
480: {
481: (*s_etat_processus).erreur_systeme = d_es_processus;
482: return;
483: }
484: }
485:
486: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
487: return;
488: }
489:
490: for(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
491: .objet)).nombre_colonnes; j++)
492: {
493: if ((signed long) j == (position - 1))
494: {
495: ((integer8 **) (*((struct_matrice *) (*s_copie_argument_3)
496: .objet)).tableau)[i][j] = ((integer8 **)
497: (*((struct_matrice *) (*s_objet_argument_1).objet))
498: .tableau)[i][0];
499: l = 1;
500: }
501:
502: ((integer8 **) (*((struct_matrice *) (*s_copie_argument_3)
503: .objet)).tableau)[i][j + l] = ((integer8 *) tampon)[j];
504: }
505:
506: if (l == 0)
507: {
508: ((integer8 **) (*((struct_matrice *) (*s_copie_argument_3)
509: .objet)).tableau)[i][(*((struct_matrice *)
510: (*s_copie_argument_3).objet)).nombre_colonnes] =
511: ((integer8 **) (*((struct_matrice *)
512: (*s_objet_argument_1).objet)).tableau)[i][0];
513: }
514:
515: free(tampon);
516: }
517:
518: (*((struct_matrice *) (*s_copie_argument_3).objet)).nombre_colonnes++;
519: }
520: else if ((*s_copie_argument_3).type == MRL)
521: {
522: if ((*s_objet_argument_1).type == MIN)
523: {
524: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
525: .nombre_lignes != (*((struct_matrice *)
526: (*s_copie_argument_3).objet)).nombre_lignes)
527: {
528: if (variable_partagee == d_vrai)
529: {
530: if (pthread_mutex_unlock(&((*(*s_etat_processus)
531: .pointeur_variable_partagee_courante).mutex)) != 0)
532: {
533: (*s_etat_processus).erreur_systeme = d_es_processus;
534: return;
535: }
536: }
537:
538: liberation(s_etat_processus, s_objet_argument_1);
539: liberation(s_etat_processus, s_objet_argument_2);
540: liberation(s_etat_processus, s_objet_argument_3);
541:
542: if (presence_nom == d_faux)
543: {
544: liberation(s_etat_processus, s_copie_argument_3);
545: }
546:
547: (*s_etat_processus).erreur_execution =
548: d_ex_dimensions_invalides;
549: return;
550: }
551:
552: if ((position < 1) || (position > ((signed long)
553: (*((struct_matrice *) (*s_copie_argument_3).objet))
554: .nombre_colonnes + 1)))
555: {
556: if (variable_partagee == d_vrai)
557: {
558: if (pthread_mutex_unlock(&((*(*s_etat_processus)
559: .pointeur_variable_partagee_courante).mutex)) != 0)
560: {
561: (*s_etat_processus).erreur_systeme = d_es_processus;
562: return;
563: }
564: }
565:
566: liberation(s_etat_processus, s_objet_argument_1);
567: liberation(s_etat_processus, s_objet_argument_2);
568: liberation(s_etat_processus, s_objet_argument_3);
569:
570: if (presence_nom == d_faux)
571: {
572: liberation(s_etat_processus, s_copie_argument_3);
573: }
574:
575: (*s_etat_processus).erreur_execution =
576: d_ex_argument_invalide;
577: return;
578: }
579:
580: for(i = 0; i < (*((struct_matrice *) (*s_copie_argument_3).objet))
581: .nombre_lignes; i++)
582: {
583: tampon = (*((struct_matrice *) (*s_copie_argument_3).objet))
584: .tableau[i];
585:
586: if (((*((struct_matrice *) (*s_copie_argument_3).objet))
587: .tableau[i] = malloc((((*((struct_matrice *)
588: (*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
589: sizeof(real8))) == NULL)
590: {
591: if (variable_partagee == d_vrai)
592: {
593: if (pthread_mutex_unlock(&((*(*s_etat_processus)
594: .pointeur_variable_partagee_courante).mutex))
595: != 0)
596: {
597: (*s_etat_processus).erreur_systeme = d_es_processus;
598: return;
599: }
600: }
601:
602: (*s_etat_processus).erreur_systeme =
603: d_es_allocation_memoire;
604: return;
605: }
606:
607: for(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
608: .objet)).nombre_colonnes; j++)
609: {
610: if ((signed long) j == (position - 1))
611: {
612: ((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
613: .objet)).tableau)[i][j] = ((integer8 **)
614: (*((struct_matrice *) (*s_objet_argument_1)
615: .objet)).tableau)[i][0];
616: l = 1;
617: }
618:
619: ((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
620: .objet)).tableau)[i][j + l] = ((real8 *) tampon)[j];
621: }
622:
623: if (l == 0)
624: {
625: ((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
626: .objet)).tableau)[i][(*((struct_matrice *)
627: (*s_copie_argument_3).objet)).nombre_colonnes] =
628: ((integer8 **) (*((struct_matrice *)
629: (*s_objet_argument_1).objet)).tableau)[i][0];
630: }
631:
632: free(tampon);
633: }
634:
635: (*((struct_matrice *) (*s_copie_argument_3).objet))
636: .nombre_colonnes++;
637: }
638: else // Matrice réelle
639: {
640: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
641: .nombre_lignes != (*((struct_matrice *)
642: (*s_copie_argument_3).objet)).nombre_lignes)
643: {
644: if (variable_partagee == d_vrai)
645: {
646: if (pthread_mutex_unlock(&((*(*s_etat_processus)
647: .pointeur_variable_partagee_courante).mutex)) != 0)
648: {
649: (*s_etat_processus).erreur_systeme = d_es_processus;
650: return;
651: }
652: }
653:
654: liberation(s_etat_processus, s_objet_argument_1);
655: liberation(s_etat_processus, s_objet_argument_2);
656: liberation(s_etat_processus, s_objet_argument_3);
657:
658: if (presence_nom == d_faux)
659: {
660: liberation(s_etat_processus, s_copie_argument_3);
661: }
662:
663: (*s_etat_processus).erreur_execution =
664: d_ex_dimensions_invalides;
665: return;
666: }
667:
668: if ((position < 1) || (position > ((signed long)
669: (*((struct_matrice *) (*s_copie_argument_3).objet))
670: .nombre_colonnes + 1)))
671: {
672: if (variable_partagee == d_vrai)
673: {
674: if (pthread_mutex_unlock(&((*(*s_etat_processus)
675: .pointeur_variable_partagee_courante).mutex)) != 0)
676: {
677: (*s_etat_processus).erreur_systeme = d_es_processus;
678: return;
679: }
680: }
681:
682: liberation(s_etat_processus, s_objet_argument_1);
683: liberation(s_etat_processus, s_objet_argument_2);
684: liberation(s_etat_processus, s_objet_argument_3);
685:
686: if (presence_nom == d_faux)
687: {
688: liberation(s_etat_processus, s_copie_argument_3);
689: }
690:
691: (*s_etat_processus).erreur_execution =
692: d_ex_argument_invalide;
693: return;
694: }
695:
696: for(i = 0; i < (*((struct_matrice *) (*s_copie_argument_3).objet))
697: .nombre_lignes; i++)
698: {
699: tampon = (*((struct_matrice *) (*s_copie_argument_3).objet))
700: .tableau[i];
701:
702: if (((*((struct_matrice *) (*s_copie_argument_3).objet))
703: .tableau[i] = malloc((((*((struct_matrice *)
704: (*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
705: sizeof(real8))) == NULL)
706: {
707: if (variable_partagee == d_vrai)
708: {
709: if (pthread_mutex_unlock(&((*(*s_etat_processus)
710: .pointeur_variable_partagee_courante).mutex))
711: != 0)
712: {
713: (*s_etat_processus).erreur_systeme = d_es_processus;
714: return;
715: }
716: }
717:
718: (*s_etat_processus).erreur_systeme =
719: d_es_allocation_memoire;
720: return;
721: }
722:
723: for(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
724: .objet)).nombre_colonnes; j++)
725: {
726: if ((signed long) j == (position - 1))
727: {
728: ((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
729: .objet)).tableau)[i][j] = ((real8 **)
730: (*((struct_matrice *) (*s_objet_argument_1)
731: .objet)).tableau)[i][0];
732: l = 1;
733: }
734:
735: ((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
736: .objet)).tableau)[i][j + l] = ((real8 *) tampon)[j];
737: }
738:
739: if (l == 0)
740: {
741: ((real8 **) (*((struct_matrice *) (*s_copie_argument_3)
742: .objet)).tableau)[i][(*((struct_matrice *)
743: (*s_copie_argument_3).objet)).nombre_colonnes] =
744: ((real8 **) (*((struct_matrice *)
745: (*s_objet_argument_1).objet)).tableau)[i][0];
746: }
747:
748: free(tampon);
749: }
750:
751: (*((struct_matrice *) (*s_copie_argument_3).objet))
752: .nombre_colonnes++;
753: }
754: }
755: else if ((*s_copie_argument_3).type == MCX)
756: {
757: if ((*s_objet_argument_1).type == MIN)
758: {
759: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
760: .nombre_lignes != (*((struct_matrice *)
761: (*s_copie_argument_3).objet)).nombre_lignes)
762: {
763: if (variable_partagee == d_vrai)
764: {
765: if (pthread_mutex_unlock(&((*(*s_etat_processus)
766: .pointeur_variable_partagee_courante).mutex)) != 0)
767: {
768: (*s_etat_processus).erreur_systeme = d_es_processus;
769: return;
770: }
771: }
772:
773: liberation(s_etat_processus, s_objet_argument_1);
774: liberation(s_etat_processus, s_objet_argument_2);
775: liberation(s_etat_processus, s_objet_argument_3);
776:
777: if (presence_nom == d_faux)
778: {
779: liberation(s_etat_processus, s_copie_argument_3);
780: }
781:
782: (*s_etat_processus).erreur_execution =
783: d_ex_dimensions_invalides;
784: return;
785: }
786:
787: if ((position < 1) || (position > ((signed long)
788: (*((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((((*((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 ((signed long) j == (position - 1))
846: {
847: ((complex16 **) (*((struct_matrice *)
848: (*s_copie_argument_3).objet)).tableau)[i][j]
849: .partie_reelle = ((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 = ((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 > ((signed long)
917: (*((struct_matrice *)
918: (*s_copie_argument_3).objet)).nombre_colonnes + 1)))
919: {
920: if (variable_partagee == d_vrai)
921: {
922: if (pthread_mutex_unlock(&((*(*s_etat_processus)
923: .pointeur_variable_partagee_courante).mutex)) != 0)
924: {
925: (*s_etat_processus).erreur_systeme = d_es_processus;
926: return;
927: }
928: }
929:
930: liberation(s_etat_processus, s_objet_argument_1);
931: liberation(s_etat_processus, s_objet_argument_2);
932: liberation(s_etat_processus, s_objet_argument_3);
933:
934: if (presence_nom == d_faux)
935: {
936: liberation(s_etat_processus, s_copie_argument_3);
937: }
938:
939: (*s_etat_processus).erreur_execution =
940: d_ex_argument_invalide;
941: return;
942: }
943:
944: for(i = 0; i < (*((struct_matrice *) (*s_copie_argument_3).objet))
945: .nombre_lignes; i++)
946: {
947: tampon = (*((struct_matrice *) (*s_copie_argument_3).objet))
948: .tableau[i];
949:
950: if (((*((struct_matrice *) (*s_copie_argument_3).objet))
951: .tableau[i] = malloc((((*((struct_matrice *)
952: (*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
953: sizeof(complex16))) == NULL)
954: {
955: if (variable_partagee == d_vrai)
956: {
957: if (pthread_mutex_unlock(&((*(*s_etat_processus)
958: .pointeur_variable_partagee_courante).mutex))
959: != 0)
960: {
961: (*s_etat_processus).erreur_systeme = d_es_processus;
962: return;
963: }
964: }
965:
966: (*s_etat_processus).erreur_systeme =
967: d_es_allocation_memoire;
968: return;
969: }
970:
971: for(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
972: .objet)).nombre_colonnes; j++)
973: {
974: if ((signed long) j == (position - 1))
975: {
976: ((complex16 **) (*((struct_matrice *)
977: (*s_copie_argument_3).objet)).tableau)[i][j]
978: .partie_reelle = ((real8 **)
979: (*((struct_matrice *) (*s_objet_argument_1)
980: .objet)).tableau)[i][0];
981: ((complex16 **) (*((struct_matrice *)
982: (*s_copie_argument_3).objet)).tableau)[i][j]
983: .partie_imaginaire = 0;
984: l = 1;
985: }
986:
987: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
988: .objet)).tableau)[i][j + l].partie_reelle =
989: ((complex16 *) tampon)[j].partie_reelle;
990: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
991: .objet)).tableau)[i][j + l].partie_imaginaire =
992: ((complex16 *) tampon)[j].partie_imaginaire;
993: }
994:
995: if (l == 0)
996: {
997: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
998: .objet)).tableau)[i][(*((struct_matrice *)
999: (*s_copie_argument_3).objet)).nombre_colonnes]
1000: .partie_reelle = ((real8 **)
1001: (*((struct_matrice *) (*s_objet_argument_1).objet))
1002: .tableau)[i][0];
1003: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
1004: .objet)).tableau)[i][(*((struct_matrice *)
1005: (*s_copie_argument_3).objet)).nombre_colonnes]
1006: .partie_imaginaire = 0;
1007: }
1008:
1009: free(tampon);
1010: }
1011:
1012: (*((struct_matrice *) (*s_copie_argument_3).objet))
1013: .nombre_colonnes++;
1014: }
1015: else // Matrice complexe
1016: {
1017: if ((*((struct_matrice *) (*s_objet_argument_1).objet))
1018: .nombre_lignes != (*((struct_matrice *)
1019: (*s_copie_argument_3).objet)).nombre_lignes)
1020: {
1021: if (variable_partagee == d_vrai)
1022: {
1023: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1024: .pointeur_variable_partagee_courante).mutex)) != 0)
1025: {
1026: (*s_etat_processus).erreur_systeme = d_es_processus;
1027: return;
1028: }
1029: }
1030:
1031: liberation(s_etat_processus, s_objet_argument_1);
1032: liberation(s_etat_processus, s_objet_argument_2);
1033: liberation(s_etat_processus, s_objet_argument_3);
1034:
1035: if (presence_nom == d_faux)
1036: {
1037: liberation(s_etat_processus, s_copie_argument_3);
1038: }
1039:
1040: (*s_etat_processus).erreur_execution =
1041: d_ex_dimensions_invalides;
1042: return;
1043: }
1044:
1045: if ((position < 1) || (position > ((signed long)
1046: (*((struct_matrice *)
1047: (*s_copie_argument_3).objet)).nombre_colonnes + 1)))
1048: {
1049: if (variable_partagee == d_vrai)
1050: {
1051: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1052: .pointeur_variable_partagee_courante).mutex)) != 0)
1053: {
1054: (*s_etat_processus).erreur_systeme = d_es_processus;
1055: return;
1056: }
1057: }
1058:
1059: liberation(s_etat_processus, s_objet_argument_1);
1060: liberation(s_etat_processus, s_objet_argument_2);
1061: liberation(s_etat_processus, s_objet_argument_3);
1062:
1063: if (presence_nom == d_faux)
1064: {
1065: liberation(s_etat_processus, s_copie_argument_3);
1066: }
1067:
1068: (*s_etat_processus).erreur_execution =
1069: d_ex_argument_invalide;
1070: return;
1071: }
1072:
1073: for(i = 0; i < (*((struct_matrice *) (*s_copie_argument_3).objet))
1074: .nombre_lignes; i++)
1075: {
1076: tampon = (*((struct_matrice *) (*s_copie_argument_3).objet))
1077: .tableau[i];
1078:
1079: if (((*((struct_matrice *) (*s_copie_argument_3).objet))
1080: .tableau[i] = malloc((((*((struct_matrice *)
1081: (*s_copie_argument_3).objet)).nombre_colonnes) + 1) *
1082: sizeof(complex16))) == NULL)
1083: {
1084: if (variable_partagee == d_vrai)
1085: {
1086: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1087: .pointeur_variable_partagee_courante).mutex))
1088: != 0)
1089: {
1090: (*s_etat_processus).erreur_systeme = d_es_processus;
1091: return;
1092: }
1093: }
1094:
1095: (*s_etat_processus).erreur_systeme =
1096: d_es_allocation_memoire;
1097: return;
1098: }
1099:
1100: for(l = j = 0; j < (*((struct_matrice *) (*s_copie_argument_3)
1101: .objet)).nombre_colonnes; j++)
1102: {
1103: if ((signed long) j == (position - 1))
1104: {
1105: ((complex16 **) (*((struct_matrice *)
1106: (*s_copie_argument_3).objet)).tableau)[i][j]
1107: .partie_reelle = ((complex16 **)
1108: (*((struct_matrice *) (*s_objet_argument_1)
1109: .objet)).tableau)[i][0].partie_reelle;
1110: ((complex16 **) (*((struct_matrice *)
1111: (*s_copie_argument_3).objet)).tableau)[i][j]
1112: .partie_imaginaire = ((complex16 **)
1113: (*((struct_matrice *) (*s_objet_argument_1)
1114: .objet)).tableau)[i][0].partie_imaginaire;
1115: l = 1;
1116: }
1117:
1118: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
1119: .objet)).tableau)[i][j + l].partie_reelle =
1120: ((complex16 *) tampon)[j].partie_reelle;
1121: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
1122: .objet)).tableau)[i][j + l].partie_imaginaire =
1123: ((complex16 *) tampon)[j].partie_imaginaire;
1124: }
1125:
1126: if (l == 0)
1127: {
1128: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
1129: .objet)).tableau)[i][(*((struct_matrice *)
1130: (*s_copie_argument_3).objet)).nombre_colonnes]
1131: .partie_reelle = ((complex16 **)
1132: (*((struct_matrice *) (*s_objet_argument_1).objet))
1133: .tableau)[i][0].partie_reelle;
1134: ((complex16 **) (*((struct_matrice *) (*s_copie_argument_3)
1135: .objet)).tableau)[i][(*((struct_matrice *)
1136: (*s_copie_argument_3).objet)).nombre_colonnes]
1137: .partie_imaginaire = ((complex16 **)
1138: (*((struct_matrice *) (*s_objet_argument_1).objet))
1139: .tableau)[i][0].partie_imaginaire;
1140: }
1141:
1142: free(tampon);
1143: }
1144:
1145: (*((struct_matrice *) (*s_copie_argument_3).objet))
1146: .nombre_colonnes++;
1147: }
1148: }
1149: else
1150: {
1151: liberation(s_etat_processus, s_objet_argument_1);
1152: liberation(s_etat_processus, s_objet_argument_2);
1153: liberation(s_etat_processus, s_objet_argument_3);
1154:
1155: if (presence_nom == d_faux)
1156: {
1157: liberation(s_etat_processus, s_copie_argument_3);
1158: }
1159:
1160: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1161: return;
1162: }
1163:
1164: if (presence_nom == d_faux)
1165: {
1166: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1167: s_copie_argument_3) == d_erreur)
1168: {
1169: return;
1170: }
1171: }
1172: else
1173: {
1174: if (variable_partagee == d_faux)
1175: {
1176: (*(*s_etat_processus).pointeur_variable_courante).objet =
1177: s_copie_argument_3;
1178: }
1179: else
1180: {
1181: (*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
1182: s_copie_argument_3;
1183: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1184:
1185: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1186: .pointeur_variable_partagee_courante).mutex)) != 0)
1187: {
1188: (*s_etat_processus).erreur_systeme = d_es_processus;
1189: return;
1190: }
1191: }
1192: }
1193:
1194: liberation(s_etat_processus, s_objet_argument_1);
1195: liberation(s_etat_processus, s_objet_argument_2);
1196: liberation(s_etat_processus, s_objet_argument_3);
1197:
1198: return;
1199: }
1200:
1201:
1202: /*
1203: ================================================================================
1204: Fonction 'col-'
1205: ================================================================================
1206: Entrées : pointeur sur une structure struct_processus
1207: --------------------------------------------------------------------------------
1208: Sorties :
1209: --------------------------------------------------------------------------------
1210: Effets de bord : néant
1211: ================================================================================
1212: */
1213:
1214: void
1215: instruction_col_moins(struct_processus *s_etat_processus)
1216: {
1217: integer8 position;
1218:
1219: logical1 presence_variable;
1220: logical1 variable_partagee;
1221:
1222: struct_objet *s_copie_argument_2;
1223: struct_objet *s_objet_argument_1;
1224: struct_objet *s_objet_argument_2;
1225: struct_objet *s_objet_resultat;
1226:
1227: unsigned long i;
1228: unsigned long j;
1229: unsigned long k;
1230: unsigned long colonne;
1231:
1232: void *tampon;
1233:
1234: (*s_etat_processus).erreur_execution = d_ex;
1235:
1236: if ((*s_etat_processus).affichage_arguments == 'Y')
1237: {
1238: printf("\n COL- ");
1239:
1240: if ((*s_etat_processus).langue == 'F')
1241: {
1242: printf("(retrait d'une colonne dans une matrice)\n\n");
1243: }
1244: else
1245: {
1246: printf("(remove a column from a matrix)\n\n");
1247: }
1248:
1249: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1250: printf(" 1: %s\n", d_INT);
1251: printf("-> 2: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
1252: printf(" 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
1253:
1254: printf(" 2: %s\n", d_NOM);
1255: printf(" 1: %s\n", d_INT);
1256: printf("-> 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1257:
1258: return;
1259: }
1260: else if ((*s_etat_processus).test_instruction == 'Y')
1261: {
1262: (*s_etat_processus).nombre_arguments = -1;
1263: return;
1264: }
1265:
1266: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1267: {
1268: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1269: {
1270: return;
1271: }
1272: }
1273:
1274: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1275: &s_objet_argument_1) == d_erreur)
1276: {
1277: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1278: return;
1279: }
1280:
1281: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1282: &s_objet_argument_2) == d_erreur)
1283: {
1284: liberation(s_etat_processus, s_objet_argument_1);
1285:
1286: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1287: return;
1288: }
1289:
1290: variable_partagee = d_faux;
1291:
1292: if ((*s_objet_argument_2).type == NOM)
1293: {
1294: if (recherche_variable(s_etat_processus, (*((struct_nom *)
1295: (*s_objet_argument_2).objet)).nom) == d_faux)
1296: {
1297: (*s_etat_processus).erreur_systeme = d_es;
1298: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1299:
1300: liberation(s_etat_processus, s_objet_argument_1);
1301: liberation(s_etat_processus, s_objet_argument_2);
1302:
1303: return;
1304: }
1305:
1306: liberation(s_etat_processus, s_objet_argument_2);
1307:
1308: if ((*(*s_etat_processus).pointeur_variable_courante)
1309: .variable_verrouillee == d_vrai)
1310: {
1311: liberation(s_etat_processus, s_objet_argument_1);
1312:
1313: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
1314: return;
1315: }
1316:
1317: if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
1318: {
1319: if (recherche_variable_partagee(s_etat_processus,
1320: (*(*s_etat_processus).pointeur_variable_courante).nom,
1321: (*(*s_etat_processus).pointeur_variable_courante)
1322: .variable_partagee, (*(*s_etat_processus)
1323: .pointeur_variable_courante).origine) == NULL)
1324: {
1325: (*s_etat_processus).erreur_systeme = d_es;
1326: (*s_etat_processus).erreur_execution =
1327: d_ex_variable_non_definie;
1328:
1329: liberation(s_etat_processus, s_objet_argument_1);
1330: return;
1331: }
1332:
1333: variable_partagee = d_vrai;
1334: s_objet_argument_2 = (*(*s_etat_processus)
1335: .pointeur_variable_partagee_courante).objet;
1336: }
1337: else
1338: {
1339: s_objet_argument_2 = (*(*s_etat_processus)
1340: .pointeur_variable_courante).objet;
1341: }
1342:
1343: presence_variable = d_vrai;
1344: }
1345: else
1346: {
1347: presence_variable = d_faux;
1348: }
1349:
1350: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
1351: s_objet_argument_2, 'Q')) == NULL)
1352: {
1353: if (variable_partagee == d_vrai)
1354: {
1355: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1356: .pointeur_variable_partagee_courante).mutex)) != 0)
1357: {
1358: (*s_etat_processus).erreur_systeme = d_es_processus;
1359: return;
1360: }
1361: }
1362:
1363: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1364: return;
1365: }
1366:
1367: if (((*s_copie_argument_2).type == MIN) ||
1368: ((*s_copie_argument_2).type == MRL) ||
1369: ((*s_copie_argument_2).type == MCX))
1370: {
1371: if ((*s_objet_argument_1).type == INT)
1372: {
1373: position = (*((integer8 *) (*s_objet_argument_1).objet));
1374:
1375: if ((position <= 0) || (position > (signed long)
1376: (*((struct_matrice *)
1377: (*s_copie_argument_2).objet)).nombre_colonnes))
1378: {
1379: if (variable_partagee == d_vrai)
1380: {
1381: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1382: .pointeur_variable_partagee_courante).mutex)) != 0)
1383: {
1384: (*s_etat_processus).erreur_systeme = d_es_processus;
1385: return;
1386: }
1387: }
1388:
1389: liberation(s_etat_processus, s_objet_argument_1);
1390: liberation(s_etat_processus, s_objet_argument_2);
1391:
1392: if (presence_variable == d_faux)
1393: {
1394: liberation(s_etat_processus, s_copie_argument_2);
1395: }
1396:
1397: (*s_etat_processus).erreur_execution =
1398: d_ex_argument_invalide;
1399: return;
1400: }
1401:
1402: if ((s_objet_resultat = allocation(s_etat_processus, NON))
1403: == NULL)
1404: {
1405: if (variable_partagee == d_vrai)
1406: {
1407: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1408: .pointeur_variable_partagee_courante).mutex)) != 0)
1409: {
1410: (*s_etat_processus).erreur_systeme = d_es_processus;
1411: return;
1412: }
1413: }
1414:
1415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1416: return;
1417: }
1418:
1419: if (((*s_objet_resultat).objet =
1420: malloc(sizeof(struct_matrice))) == NULL)
1421: {
1422: if (variable_partagee == d_vrai)
1423: {
1424: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1425: .pointeur_variable_partagee_courante).mutex)) != 0)
1426: {
1427: (*s_etat_processus).erreur_systeme = d_es_processus;
1428: return;
1429: }
1430: }
1431:
1432: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1433: return;
1434: }
1435:
1436: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
1437: 1;
1438: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
1439: (*((struct_matrice *) (*s_copie_argument_2).objet))
1440: .nombre_lignes;
1441: (*((struct_matrice *) (*s_objet_resultat).objet)).type =
1442: (*((struct_matrice *) (*s_copie_argument_2).objet)).type;
1443:
1444: switch((*((struct_matrice *) (*s_objet_resultat).objet)).type)
1445: {
1446: case 'I' :
1447: {
1448: (*s_objet_resultat).type = MIN;
1449:
1450: if (((*((struct_matrice *) (*s_objet_resultat).objet))
1451: .tableau = malloc((*((struct_matrice *)
1452: (*s_objet_resultat).objet)).nombre_lignes *
1453: sizeof(integer8 *))) == NULL)
1454: {
1455: if (variable_partagee == d_vrai)
1456: {
1457: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1458: .pointeur_variable_partagee_courante)
1459: .mutex)) != 0)
1460: {
1461: (*s_etat_processus).erreur_systeme =
1462: d_es_processus;
1463: return;
1464: }
1465: }
1466:
1467: (*s_etat_processus).erreur_systeme =
1468: d_es_allocation_memoire;
1469: return;
1470: }
1471:
1472: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
1473: .objet)).nombre_lignes; i++)
1474: {
1475: if (((*((struct_matrice *) (*s_objet_resultat).objet))
1476: .tableau[i] = malloc(sizeof(integer8))) == NULL)
1477: {
1478: if (variable_partagee == d_vrai)
1479: {
1480: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1481: .pointeur_variable_partagee_courante)
1482: .mutex)) != 0)
1483: {
1484: (*s_etat_processus).erreur_systeme =
1485: d_es_processus;
1486: return;
1487: }
1488: }
1489:
1490: (*s_etat_processus).erreur_systeme =
1491: d_es_allocation_memoire;
1492: return;
1493: }
1494:
1495: }
1496:
1497: colonne = position - 1;
1498:
1499: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
1500: .objet)).nombre_lignes; i++)
1501: {
1502: ((integer8 **) (*((struct_matrice *)
1503: (*s_objet_resultat).objet)).tableau)[i][0] =
1504: ((integer8 **) (*((struct_matrice *)
1505: (*s_copie_argument_2).objet))
1506: .tableau)[i][colonne];
1507:
1508: tampon = ((integer8 **) (*((struct_matrice *)
1509: (*s_copie_argument_2).objet)).tableau)[i];
1510:
1511: if ((((*((struct_matrice *) (*s_copie_argument_2)
1512: .objet)).tableau)[i] = malloc(
1513: ((*((struct_matrice *) (*s_copie_argument_2)
1514: .objet)).nombre_colonnes - 1) *
1515: sizeof(integer8))) == NULL)
1516: {
1517: if (variable_partagee == d_vrai)
1518: {
1519: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1520: .pointeur_variable_partagee_courante)
1521: .mutex)) != 0)
1522: {
1523: (*s_etat_processus).erreur_systeme =
1524: d_es_processus;
1525: return;
1526: }
1527: }
1528:
1529: (*s_etat_processus).erreur_systeme =
1530: d_es_allocation_memoire;
1531: return;
1532: }
1533:
1534: for(j = k = 0; j < (*((struct_matrice *)
1535: (*s_copie_argument_2).objet)).nombre_colonnes
1536: - 1; j++)
1537: {
1538: if (j == colonne)
1539: {
1540: k = 1;
1541: }
1542:
1543: ((integer8 **) (*((struct_matrice *)
1544: (*s_copie_argument_2).objet)).tableau)
1545: [i][j] = ((integer8 *) tampon)[j + k];
1546: }
1547:
1548: free(tampon);
1549: }
1550:
1551: (*((struct_matrice *) (*s_copie_argument_2).objet))
1552: .nombre_colonnes--;
1553: break;
1554: }
1555:
1556: case 'R' :
1557: {
1558: (*s_objet_resultat).type = MRL;
1559:
1560: if (((*((struct_matrice *) (*s_objet_resultat).objet))
1561: .tableau = malloc((*((struct_matrice *)
1562: (*s_objet_resultat).objet)).nombre_lignes *
1563: sizeof(real8 *))) == NULL)
1564: {
1565: if (variable_partagee == d_vrai)
1566: {
1567: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1568: .pointeur_variable_partagee_courante)
1569: .mutex)) != 0)
1570: {
1571: (*s_etat_processus).erreur_systeme =
1572: d_es_processus;
1573: return;
1574: }
1575: }
1576:
1577: (*s_etat_processus).erreur_systeme =
1578: d_es_allocation_memoire;
1579: return;
1580: }
1581:
1582: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
1583: .objet)).nombre_lignes; i++)
1584: {
1585: if (((*((struct_matrice *) (*s_objet_resultat).objet))
1586: .tableau[i] = malloc(sizeof(real8))) == NULL)
1587: {
1588: if (variable_partagee == d_vrai)
1589: {
1590: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1591: .pointeur_variable_partagee_courante)
1592: .mutex)) != 0)
1593: {
1594: (*s_etat_processus).erreur_systeme =
1595: d_es_processus;
1596: return;
1597: }
1598: }
1599:
1600: (*s_etat_processus).erreur_systeme =
1601: d_es_allocation_memoire;
1602: return;
1603: }
1604:
1605: }
1606:
1607: colonne = position - 1;
1608:
1609: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
1610: .objet)).nombre_lignes; i++)
1611: {
1612: ((real8 **) (*((struct_matrice *)
1613: (*s_objet_resultat).objet)).tableau)[i][0] =
1614: ((real8 **) (*((struct_matrice *)
1615: (*s_copie_argument_2).objet))
1616: .tableau)[i][colonne];
1617:
1618: tampon = ((real8 **) (*((struct_matrice *)
1619: (*s_copie_argument_2).objet)).tableau)[i];
1620:
1621: if ((((*((struct_matrice *) (*s_copie_argument_2)
1622: .objet)).tableau)[i] = malloc(
1623: ((*((struct_matrice *) (*s_copie_argument_2)
1624: .objet)).nombre_colonnes - 1) *
1625: sizeof(real8))) == NULL)
1626: {
1627: if (variable_partagee == d_vrai)
1628: {
1629: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1630: .pointeur_variable_partagee_courante)
1631: .mutex)) != 0)
1632: {
1633: (*s_etat_processus).erreur_systeme =
1634: d_es_processus;
1635: return;
1636: }
1637: }
1638:
1639: (*s_etat_processus).erreur_systeme =
1640: d_es_allocation_memoire;
1641: return;
1642: }
1643:
1644: for(j = k = 0; j < (*((struct_matrice *)
1645: (*s_copie_argument_2).objet)).nombre_colonnes
1646: - 1; j++)
1647: {
1648: if (j == colonne)
1649: {
1650: k = 1;
1651: }
1652:
1653: ((real8 **) (*((struct_matrice *)
1654: (*s_copie_argument_2).objet)).tableau)
1655: [i][j] = ((real8 *) tampon)[j + k];
1656: }
1657:
1658: free(tampon);
1659: }
1660:
1661: (*((struct_matrice *) (*s_copie_argument_2).objet))
1662: .nombre_colonnes--;
1663: break;
1664: }
1665:
1666: case 'C' :
1667: {
1668: (*s_objet_resultat).type = MCX;
1669:
1670: if (((*((struct_matrice *) (*s_objet_resultat).objet))
1671: .tableau = malloc((*((struct_matrice *)
1672: (*s_objet_resultat).objet)).nombre_lignes *
1673: sizeof(complex16 *))) == NULL)
1674: {
1675: if (variable_partagee == d_vrai)
1676: {
1677: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1678: .pointeur_variable_partagee_courante)
1679: .mutex)) != 0)
1680: {
1681: (*s_etat_processus).erreur_systeme =
1682: d_es_processus;
1683: return;
1684: }
1685: }
1686:
1687: (*s_etat_processus).erreur_systeme =
1688: d_es_allocation_memoire;
1689: return;
1690: }
1691:
1692: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
1693: .objet)).nombre_lignes; i++)
1694: {
1695: if (((*((struct_matrice *) (*s_objet_resultat).objet))
1696: .tableau[i] = malloc(sizeof(complex16)))
1697: == NULL)
1698: {
1699: if (variable_partagee == d_vrai)
1700: {
1701: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1702: .pointeur_variable_partagee_courante)
1703: .mutex)) != 0)
1704: {
1705: (*s_etat_processus).erreur_systeme =
1706: d_es_processus;
1707: return;
1708: }
1709: }
1710:
1711: (*s_etat_processus).erreur_systeme =
1712: d_es_allocation_memoire;
1713: return;
1714: }
1715:
1716: }
1717:
1718: colonne = position - 1;
1719:
1720: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat)
1721: .objet)).nombre_lignes; i++)
1722: {
1723: ((complex16 **) (*((struct_matrice *)
1724: (*s_objet_resultat).objet)).tableau)[i][0]
1725: .partie_reelle =
1726: ((complex16 **) (*((struct_matrice *)
1727: (*s_copie_argument_2).objet))
1728: .tableau)[i][colonne].partie_reelle;
1729: ((complex16 **) (*((struct_matrice *)
1730: (*s_objet_resultat).objet)).tableau)[i][0]
1731: .partie_imaginaire =
1732: ((complex16 **) (*((struct_matrice *)
1733: (*s_copie_argument_2).objet))
1734: .tableau)[i][colonne].partie_imaginaire;
1735:
1736: tampon = ((complex16 **) (*((struct_matrice *)
1737: (*s_copie_argument_2).objet)).tableau)[i];
1738:
1739: if ((((*((struct_matrice *) (*s_copie_argument_2)
1740: .objet)).tableau)[i] = malloc(
1741: ((*((struct_matrice *) (*s_copie_argument_2)
1742: .objet)).nombre_colonnes - 1) *
1743: sizeof(complex16))) == NULL)
1744: {
1745: if (variable_partagee == d_vrai)
1746: {
1747: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1748: .pointeur_variable_partagee_courante)
1749: .mutex)) != 0)
1750: {
1751: (*s_etat_processus).erreur_systeme =
1752: d_es_processus;
1753: return;
1754: }
1755: }
1756:
1757: (*s_etat_processus).erreur_systeme =
1758: d_es_allocation_memoire;
1759: return;
1760: }
1761:
1762: for(j = k = 0; j < (*((struct_matrice *)
1763: (*s_copie_argument_2).objet)).nombre_colonnes
1764: - 1; j++)
1765: {
1766: if (j == colonne)
1767: {
1768: k = 1;
1769: }
1770:
1771: ((complex16 **) (*((struct_matrice *)
1772: (*s_copie_argument_2).objet)).tableau)
1773: [i][j].partie_reelle = ((complex16 *)
1774: tampon)[j + k].partie_reelle;
1775: ((complex16 **) (*((struct_matrice *)
1776: (*s_copie_argument_2).objet)).tableau)
1777: [i][j].partie_imaginaire = ((complex16 *)
1778: tampon)[j + k].partie_imaginaire;
1779: }
1780:
1781: free(tampon);
1782: }
1783:
1784: (*((struct_matrice *) (*s_copie_argument_2).objet))
1785: .nombre_colonnes--;
1786: break;
1787: }
1788: }
1789: }
1790: else
1791: {
1792: liberation(s_etat_processus, s_objet_argument_1);
1793: liberation(s_etat_processus, s_objet_argument_2);
1794:
1795: if (presence_variable == d_faux)
1796: {
1797: liberation(s_etat_processus, s_copie_argument_2);
1798: }
1799:
1800: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1801: return;
1802: }
1803: }
1804: else
1805: {
1806: liberation(s_etat_processus, s_objet_argument_1);
1807: liberation(s_etat_processus, s_objet_argument_2);
1808:
1809: if (presence_variable == d_faux)
1810: {
1811: liberation(s_etat_processus, s_copie_argument_2);
1812: }
1813:
1814: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1815: return;
1816: }
1817:
1818: liberation(s_etat_processus, s_objet_argument_1);
1819: liberation(s_etat_processus, s_objet_argument_2);
1820:
1821: if (presence_variable == d_faux)
1822: {
1823: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1824: s_copie_argument_2) == d_erreur)
1825: {
1826: return;
1827: }
1828: }
1829: else
1830: {
1831: if (variable_partagee == d_faux)
1832: {
1833: (*(*s_etat_processus).pointeur_variable_courante).objet =
1834: s_copie_argument_2;
1835: }
1836: else
1837: {
1838: (*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
1839: s_copie_argument_2;
1840: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1841:
1842: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1843: .pointeur_variable_partagee_courante).mutex)) != 0)
1844: {
1845: (*s_etat_processus).erreur_systeme = d_es_processus;
1846: return;
1847: }
1848: }
1849: }
1850:
1851: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1852: s_objet_resultat) == d_erreur)
1853: {
1854: return;
1855: }
1856:
1857: return;
1858: }
1859:
1860: // 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