File:
[local] /
rpl /
src /
instructions_f4.c
Revision
1.21:
download - view:
text,
annotated -
select for diffs -
revision graph
Tue Jun 21 15:26:31 2011 UTC (12 years, 11 months ago) by
bertrand
Branches:
MAIN
CVS tags:
HEAD
Correction d'une réinitialisation sauvage de la pile des variables par niveau
dans la copie de la structure de description du processus. Cela corrige
la fonction SPAWN qui échouait sur un segmentation fault car la pile des
variables par niveau était vide alors même que l'arbre des variables contenait
bien les variables. Passage à la prerelease 2.
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.0.prerelease.2
4: Copyright (C) 1989-2011 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 '->table'
29: ================================================================================
30: Entrées : structure processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_fleche_table(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet;
42:
43: signed long i;
44: signed long nombre_elements;
45:
46: (*s_etat_processus).erreur_execution = d_ex;
47:
48: if ((*s_etat_processus).affichage_arguments == 'Y')
49: {
50: printf("\n ->TABLE ");
51:
52: if ((*s_etat_processus).langue == 'F')
53: {
54: printf("(création d'une table)\n\n");
55: }
56: else
57: {
58: printf("(create table)\n\n");
59: }
60:
61: printf(" n: %s, %s, %s, %s, %s, %s,\n"
62: " %s, %s, %s, %s, %s,\n"
63: " %s, %s, %s, %s, %s,\n"
64: " %s, %s\n",
65: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
66: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
67: printf(" ...\n");
68: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
69: " %s, %s, %s, %s, %s,\n"
70: " %s, %s, %s, %s, %s,\n"
71: " %s, %s\n",
72: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
73: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
74: printf(" 1: %s\n", d_INT);
75: printf("-> 1: %s\n", d_TAB);
76:
77: return;
78: }
79: else if ((*s_etat_processus).test_instruction == 'Y')
80: {
81: (*s_etat_processus).nombre_arguments = -1;
82: return;
83: }
84:
85: if (test_cfsf(s_etat_processus, 31) == d_vrai)
86: {
87: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
88: {
89: return;
90: }
91: }
92:
93: if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
94: {
95: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
96: return;
97: }
98:
99: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != INT)
100: {
101: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
102: return;
103: }
104:
105: nombre_elements = (*((integer8 *) (*(*(*s_etat_processus).l_base_pile)
106: .donnee).objet));
107:
108: if (nombre_elements < 0)
109: {
110:
111: /*
112: -- Opération absurde autorisée sur le calculateur HP-28S -----------------------
113: */
114:
115: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
116: return;
117: }
118:
119: if ((unsigned long) nombre_elements >=
120: (*s_etat_processus).hauteur_pile_operationnelle)
121: {
122: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
123: return;
124: }
125:
126: if (test_cfsf(s_etat_processus, 31) == d_vrai)
127: {
128: if (empilement_pile_last(s_etat_processus, nombre_elements + 1)
129: == d_erreur)
130: {
131: return;
132: }
133: }
134:
135: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
136: &s_objet) == d_erreur)
137: {
138: return;
139: }
140:
141: liberation(s_etat_processus, s_objet);
142:
143: if ((s_objet = allocation(s_etat_processus, TBL)) == NULL)
144: {
145: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
146: return;
147: }
148:
149: (*((struct_tableau *) (*s_objet).objet)).nombre_elements =
150: nombre_elements;
151:
152: if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
153: nombre_elements * sizeof(struct_objet *))) == NULL)
154: {
155: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
156: return;
157: }
158:
159: for(i = 0; i < nombre_elements; i++)
160: {
161: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
162: &((*((struct_tableau *) (*s_objet).objet)).elements
163: [nombre_elements - (i + 1)])) == d_erreur)
164: {
165: return;
166: }
167: }
168:
169: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
170: s_objet) == d_erreur)
171: {
172: return;
173: }
174:
175: return;
176: }
177:
178:
179: /*
180: ================================================================================
181: Fonction '->diag'
182: ================================================================================
183: Entrées : pointeur sur une structure struct_processus
184: --------------------------------------------------------------------------------
185: Sorties :
186: --------------------------------------------------------------------------------
187: Effets de bord : néant
188: ================================================================================
189: */
190:
191: void
192: instruction_fleche_diag(struct_processus *s_etat_processus)
193: {
194: struct_objet *s_objet_argument;
195: struct_objet *s_objet_resultat;
196:
197: unsigned long i;
198: unsigned long j;
199:
200: (*s_etat_processus).erreur_execution = d_ex;
201:
202: if ((*s_etat_processus).affichage_arguments == 'Y')
203: {
204: printf("\n ->DIAG ");
205:
206: if ((*s_etat_processus).langue == 'F')
207: {
208: printf("(conversion d'un vecteur en matrice diaginale)\n\n");
209: }
210: else
211: {
212: printf("(vector to diagonal matrix conversion)\n\n");
213: }
214:
215: printf("-> 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
216: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
217:
218: return;
219: }
220: else if ((*s_etat_processus).test_instruction == 'Y')
221: {
222: (*s_etat_processus).nombre_arguments = -1;
223: return;
224: }
225:
226: if (test_cfsf(s_etat_processus, 31) == d_vrai)
227: {
228: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
229: {
230: return;
231: }
232: }
233:
234: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
235: &s_objet_argument) == d_erreur)
236: {
237: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
238: return;
239: }
240:
241: /*
242: * Conversion d'un vecteur
243: */
244:
245: if ((*s_objet_argument).type == VIN)
246: {
247: if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL)
248: {
249: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
250: return;
251: }
252:
253: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
254: (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
255: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
256: (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
257:
258: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
259: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
260: .nombre_lignes * sizeof(integer8 *))) == NULL)
261: {
262: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
263: return;
264: }
265:
266: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
267: .nombre_lignes; i++)
268: {
269: if ((((integer8 **) (*((struct_matrice *)
270: (*s_objet_resultat).objet)).tableau)[i] =
271: malloc((*((struct_matrice *)
272: (*s_objet_resultat).objet)).nombre_colonnes *
273: sizeof(integer8))) == NULL)
274: {
275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
276: return;
277: }
278:
279: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
280: .nombre_colonnes; j++)
281: {
282: if (i != j)
283: {
284: ((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
285: .objet)).tableau)[i][j] = 0;
286: }
287: else
288: {
289: ((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
290: .objet)).tableau)[i][j] = ((integer8 *)
291: (*((struct_vecteur *) (*s_objet_argument)
292: .objet)).tableau)[i];
293: }
294: }
295: }
296: }
297: else if ((*s_objet_argument).type == VRL)
298: {
299: if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
300: {
301: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
302: return;
303: }
304:
305: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
306: (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
307: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
308: (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
309:
310: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
311: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
312: .nombre_lignes * sizeof(real8 *))) == NULL)
313: {
314: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
315: return;
316: }
317:
318: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
319: .nombre_lignes; i++)
320: {
321: if ((((real8 **) (*((struct_matrice *)
322: (*s_objet_resultat).objet)).tableau)[i] =
323: malloc((*((struct_matrice *)
324: (*s_objet_resultat).objet)).nombre_colonnes *
325: sizeof(real8))) == NULL)
326: {
327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
328: return;
329: }
330:
331: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
332: .nombre_colonnes; j++)
333: {
334: if (i != j)
335: {
336: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
337: .objet)).tableau)[i][j] = 0;
338: }
339: else
340: {
341: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
342: .objet)).tableau)[i][j] = ((real8 *)
343: (*((struct_vecteur *) (*s_objet_argument)
344: .objet)).tableau)[i];
345: }
346: }
347: }
348: }
349: else if ((*s_objet_argument).type == VCX)
350: {
351: if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
352: {
353: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
354: return;
355: }
356:
357: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
358: (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
359: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
360: (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
361:
362: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
363: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
364: .nombre_lignes * sizeof(complex16 *))) == NULL)
365: {
366: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
367: return;
368: }
369:
370: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
371: .nombre_lignes; i++)
372: {
373: if ((((complex16 **) (*((struct_matrice *)
374: (*s_objet_resultat).objet)).tableau)[i] =
375: malloc((*((struct_matrice *)
376: (*s_objet_resultat).objet)).nombre_colonnes *
377: sizeof(complex16))) == NULL)
378: {
379: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
380: return;
381: }
382:
383: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
384: .nombre_colonnes; j++)
385: {
386: if (i != j)
387: {
388: ((complex16 **) (*((struct_matrice *) (*s_objet_resultat)
389: .objet)).tableau)[i][j].partie_reelle = 0;
390: ((complex16 **) (*((struct_matrice *) (*s_objet_resultat)
391: .objet)).tableau)[i][j].partie_imaginaire = 0;
392: }
393: else
394: {
395: ((complex16 **) (*((struct_matrice *) (*s_objet_resultat)
396: .objet)).tableau)[i][j] = ((complex16 *)
397: (*((struct_vecteur *) (*s_objet_argument)
398: .objet)).tableau)[i];
399: }
400: }
401: }
402: }
403:
404: /*
405: * Conversion impossible impossible
406: */
407:
408: else
409: {
410: liberation(s_etat_processus, s_objet_argument);
411:
412: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
413: return;
414: }
415:
416: liberation(s_etat_processus, s_objet_argument);
417:
418: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
419: s_objet_resultat) == d_erreur)
420: {
421: return;
422: }
423:
424: return;
425: }
426:
427: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>