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