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