![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_c6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_c6.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.16.2.1! bertrand 3: RPL/2 (R) version 4.0.22
1.15 bertrand 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
1.1 bertrand 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 'clusr'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_clusr(struct_processus *s_etat_processus)
40: {
41: unsigned long i;
42:
43: (*s_etat_processus).erreur_execution = d_ex;
44:
45: if ((*s_etat_processus).affichage_arguments == 'Y')
46: {
47: printf("\n CLUSR ");
48:
49: if ((*s_etat_processus).langue == 'F')
50: {
51: printf("(effacement des variables)\n\n");
52: printf(" Aucun argument\n");
53: }
54: else
55: {
56: printf("(clear variables)\n\n");
57: printf(" No argument\n");
58: }
59:
60: return;
61: }
62: else if ((*s_etat_processus).test_instruction == 'Y')
63: {
64: (*s_etat_processus).nombre_arguments = -1;
65: return;
66: }
67:
68: if (test_cfsf(s_etat_processus, 31) == d_vrai)
69: {
70: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
71: {
72: return;
73: }
74: }
75:
76: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
77: {
78: if (((*s_etat_processus).s_liste_variables[i]).niveau == 1)
79: {
80: if (retrait_variable(s_etat_processus,
81: ((*s_etat_processus).s_liste_variables[i]).nom, 'G')
82: == d_erreur)
83: {
84: return;
85: }
86: }
87: }
88:
89: return;
90: }
91:
92:
93: /*
94: ================================================================================
95: Fonction 'col->'
96: ================================================================================
97: Entrées :
98: --------------------------------------------------------------------------------
99: Sorties :
100: --------------------------------------------------------------------------------
101: Effets de bord : néant
102: ================================================================================
103: */
104:
105: void
106: instruction_col_fleche(struct_processus *s_etat_processus)
107: {
108: struct_objet *s_objet;
109: struct_objet *s_objet_elementaire;
110:
111: unsigned long i;
112: unsigned long j;
113:
114: (*s_etat_processus).erreur_execution = d_ex;
115:
116: if ((*s_etat_processus).affichage_arguments == 'Y')
117: {
118: printf("\n COL-> ");
119:
120: if ((*s_etat_processus).langue == 'F')
121: {
122: printf("(extraction des colonnes d'une matrice)\n\n");
123: }
124: else
125: {
126: printf("(extract matrix columns)\n\n");
127: }
128:
129: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
130: printf("-> n: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
131: printf(" ...\n");
132: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
133: printf(" 1: %s\n", d_INT);
134:
135: return;
136: }
137: else if ((*s_etat_processus).test_instruction == 'Y')
138: {
139: (*s_etat_processus).nombre_arguments = -1;
140: return;
141: }
142:
143: if (test_cfsf(s_etat_processus, 31) == d_vrai)
144: {
145: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
146: {
147: return;
148: }
149: }
150:
151: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
152: &s_objet) == d_erreur)
153: {
154: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
155: return;
156: }
157:
158: if ((*s_objet).type == MIN)
159: {
160: for(i = 0; i < (*((struct_matrice *)
161: (*s_objet).objet)).nombre_colonnes; i++)
162: {
163: if ((s_objet_elementaire = allocation(s_etat_processus, MIN))
164: == NULL)
165: {
166: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
167: return;
168: }
169:
170: (*((struct_matrice *) (*s_objet_elementaire).objet))
171: .nombre_colonnes = 1;
172: (*((struct_matrice *) (*s_objet_elementaire).objet))
173: .nombre_lignes = (*((struct_matrice *) (*s_objet).objet))
174: .nombre_lignes;
175:
176: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
177: malloc((*((struct_matrice *) (*s_objet).objet))
178: .nombre_lignes * sizeof(integer8 *))) == NULL)
179: {
180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
181: return;
182: }
183:
184: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
185: .nombre_lignes; j++)
186: {
187: if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
188: .objet)).tableau)[j] = malloc(sizeof(integer8)))
189: == NULL)
190: {
191: (*s_etat_processus).erreur_systeme =
192: d_es_allocation_memoire;
193: return;
194: }
195:
196: ((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
197: .objet)).tableau)[j][0] = ((integer8 **)
198: (*((struct_matrice *) (*s_objet).objet)).tableau)[j][i];
199: }
200:
201: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
202: s_objet_elementaire) == d_erreur)
203: {
204: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
205: return;
206: }
207: }
208: }
209: else if ((*s_objet).type == MRL)
210: {
211: for(i = 0; i < (*((struct_matrice *)
212: (*s_objet).objet)).nombre_colonnes; i++)
213: {
214: if ((s_objet_elementaire = allocation(s_etat_processus, MRL))
215: == NULL)
216: {
217: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
218: return;
219: }
220:
221: (*((struct_matrice *) (*s_objet_elementaire).objet))
222: .nombre_colonnes = 1;
223: (*((struct_matrice *) (*s_objet_elementaire).objet))
224: .nombre_lignes = (*((struct_matrice *) (*s_objet).objet))
225: .nombre_lignes;
226:
227: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
228: malloc((*((struct_matrice *) (*s_objet).objet))
229: .nombre_lignes * sizeof(real8 *))) == NULL)
230: {
231: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
232: return;
233: }
234:
235: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
236: .nombre_lignes; j++)
237: {
238: if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
239: .objet)).tableau)[j] = malloc(sizeof(real8)))
240: == NULL)
241: {
242: (*s_etat_processus).erreur_systeme =
243: d_es_allocation_memoire;
244: return;
245: }
246:
247: ((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
248: .objet)).tableau)[j][0] = ((real8 **)
249: (*((struct_matrice *) (*s_objet).objet)).tableau)[j][i];
250: }
251:
252: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
253: s_objet_elementaire) == d_erreur)
254: {
255: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
256: return;
257: }
258: }
259: }
260: else if ((*s_objet).type == MCX)
261: {
262: for(i = 0; i < (*((struct_matrice *)
263: (*s_objet).objet)).nombre_colonnes; i++)
264: {
265: if ((s_objet_elementaire = allocation(s_etat_processus, MCX))
266: == NULL)
267: {
268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
269: return;
270: }
271:
272: (*((struct_matrice *) (*s_objet_elementaire).objet))
273: .nombre_colonnes = 1;
274: (*((struct_matrice *) (*s_objet_elementaire).objet))
275: .nombre_lignes = (*((struct_matrice *) (*s_objet).objet))
276: .nombre_lignes;
277:
278: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
279: malloc((*((struct_matrice *) (*s_objet).objet))
280: .nombre_lignes * sizeof(complex16 *))) == NULL)
281: {
282: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
283: return;
284: }
285:
286: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
287: .nombre_lignes; j++)
288: {
289: if ((((complex16 **) (*((struct_matrice *)
290: (*s_objet_elementaire).objet)).tableau)[j] =
291: malloc(sizeof(complex16))) == NULL)
292: {
293: (*s_etat_processus).erreur_systeme =
294: d_es_allocation_memoire;
295: return;
296: }
297:
298: (((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
299: .objet)).tableau)[j][0]).partie_reelle =
300: (((complex16 **) (*((struct_matrice *) (*s_objet)
301: .objet)).tableau)[j][i]).partie_reelle;
302: (((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
303: .objet)).tableau)[j][0]).partie_imaginaire =
304: (((complex16 **) (*((struct_matrice *) (*s_objet)
305: .objet)).tableau)[j][i]).partie_imaginaire;
306: }
307:
308: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
309: s_objet_elementaire) == d_erreur)
310: {
311: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
312: return;
313: }
314: }
315: }
316: else
317: {
318: liberation(s_etat_processus, s_objet);
319:
320: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
321: return;
322: }
323:
324: if ((s_objet_elementaire = allocation(s_etat_processus, INT)) == NULL)
325: {
326: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
327: return;
328: }
329:
330: (*((integer8 *) (*s_objet_elementaire).objet)) =
331: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes;
332:
333: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
334: s_objet_elementaire) == d_erreur)
335: {
336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
337: return;
338: }
339:
340: liberation(s_etat_processus, s_objet);
341:
342: return;
343: }
344:
345:
346: /*
347: ================================================================================
348: Fonction 'clrswi'
349: ================================================================================
350: Entrées : pointeur sur une structure struct_processus
351: --------------------------------------------------------------------------------
352: Sorties :
353: --------------------------------------------------------------------------------
354: Effets de bord : néant
355: ================================================================================
356: */
357:
358: void
359: instruction_clrswi(struct_processus *s_etat_processus)
360: {
361: integer8 interruption;
362:
363: struct_objet *s_objet_argument;
364:
365: (*s_etat_processus).erreur_execution = d_ex;
366:
367: if ((*s_etat_processus).affichage_arguments == 'Y')
368: {
369: printf("\n CLRSWI ");
370:
371: if ((*s_etat_processus).langue == 'F')
372: {
373: printf("(suppression d'une interruption logicielle)\n\n");
374: }
375: else
376: {
377: printf("(software interrupt deletion)\n\n");
378: }
379:
380: printf(" 1: %s\n", d_INT);
381:
382: return;
383: }
384: else if ((*s_etat_processus).test_instruction == 'Y')
385: {
386: (*s_etat_processus).nombre_arguments = -1;
387: return;
388: }
389:
390: if (test_cfsf(s_etat_processus, 31) == d_vrai)
391: {
392: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
393: {
394: return;
395: }
396: }
397:
398: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
399: &s_objet_argument) == d_erreur)
400: {
401: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
402: return;
403: }
404:
405: if ((*s_objet_argument).type == INT)
406: {
407: interruption = (*((integer8 *) (*s_objet_argument).objet));
408:
409: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
410: {
411: liberation(s_etat_processus, s_objet_argument);
412:
413: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
414: return;
415: }
416:
417: liberation(s_etat_processus, (*s_etat_processus)
418: .corps_interruptions[interruption - 1]);
419: (*s_etat_processus).corps_interruptions[interruption - 1] = NULL;
420: }
421: else
422: {
423: liberation(s_etat_processus, s_objet_argument);
424:
425: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
426: return;
427: }
428:
429: return;
430: }
431:
432:
433: /*
434: ================================================================================
435: Fonction 'clrcntxt'
436: ================================================================================
437: Entrées :
438: --------------------------------------------------------------------------------
439: Sorties :
440: --------------------------------------------------------------------------------
441: Effets de bord : néant
442: ================================================================================
443: */
444:
445: void
446: instruction_clrcntxt(struct_processus *s_etat_processus)
447: {
448: struct_liste_chainee *l_element_courant;
449: struct_liste_chainee *l_element_suivant;
450:
451: (*s_etat_processus).erreur_execution = d_ex;
452:
453: if ((*s_etat_processus).affichage_arguments == 'Y')
454: {
455: printf("\n CLCNTXT ");
456:
457: if ((*s_etat_processus).langue == 'F')
458: {
459: printf("(effacement des contextes)\n\n");
460: printf(" Aucun argument\n");
461: }
462: else
463: {
464: printf("(clear contexts)\n\n");
465: printf(" No argument\n");
466: }
467:
468: return;
469: }
470: else if ((*s_etat_processus).test_instruction == 'Y')
471: {
472: (*s_etat_processus).nombre_arguments = -1;
473: return;
474: }
475:
476: if (test_cfsf(s_etat_processus, 31) == d_vrai)
477: {
478: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
479: {
480: return;
481: }
482: }
483:
484: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
485:
486: while(l_element_courant != NULL)
487: {
488: l_element_suivant = (*l_element_courant).suivant;
489: liberation(s_etat_processus, (*l_element_courant).donnee);
490: free(l_element_courant);
491: l_element_courant = l_element_suivant;
492: }
493:
494: (*s_etat_processus).l_base_pile_contextes = NULL;
495:
496: return;
497: }
498:
499:
500: /*
501: ================================================================================
502: Fonction 'continue'
503: ================================================================================
504: Entrées :
505: --------------------------------------------------------------------------------
506: Sorties :
507: --------------------------------------------------------------------------------
508: Effets de bord : néant
509: ================================================================================
510: */
511:
512: void
513: instruction_continue(struct_processus *s_etat_processus)
514: {
515: struct_liste_chainee *l_element_courant;
516:
517: struct_objet *s_objet;
518:
519: (*s_etat_processus).erreur_execution = d_ex;
520:
521: if ((*s_etat_processus).affichage_arguments == 'Y')
522: {
523: printf("\n CONTINUE ");
524:
525: if ((*s_etat_processus).langue == 'F')
526: {
527: printf("(relance d'un processus suspendu)\n\n");
528: }
529: else
530: {
531: printf("(continue a pending process)\n\n");
532: }
533:
534: printf(" 1: %s\n", d_PRC);
535:
536: return;
537: }
538: else if ((*s_etat_processus).test_instruction == 'Y')
539: {
540: (*s_etat_processus).nombre_arguments = -1;
541: return;
542: }
543:
544: if (test_cfsf(s_etat_processus, 31) == d_vrai)
545: {
546: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
547: {
548: return;
549: }
550: }
551:
552: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
553: &s_objet) == d_erreur)
554: {
555: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
556: return;
557: }
558:
559: if ((*s_objet).type == PRC)
560: {
561: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
562: {
563: (*s_etat_processus).erreur_systeme = d_es_processus;
564: }
565: else
566: {
567: l_element_courant = (struct_liste_chainee *)
568: (*s_etat_processus).l_base_pile_processus;
569:
570: while(l_element_courant != NULL)
571: {
572: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
573: .processus_detache == d_vrai)
574: {
575: if ((*(*((struct_processus_fils *) (*s_objet).objet))
576: .thread).pid == (*(*((struct_processus_fils *)
577: (*(*l_element_courant).donnee).objet)).thread).pid)
578: {
579: if (kill((*(*((struct_processus_fils *)
580: (*s_objet).objet)).thread).pid, SIGCONT) != 0)
581: {
582: // Le processus est peut-être dans l'état zombie.
583: }
584:
585: break;
586: }
587: }
588: else
589: {
590: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
591: (*s_objet).objet)).thread).mutex)) != 0)
592: {
593: (*s_etat_processus).erreur_systeme = d_es_processus;
594: return;
595: }
596:
597: if ((*(*((struct_processus_fils *)
598: (*s_objet).objet)).thread).thread_actif == d_vrai)
599: {
600: if (((pthread_equal((*(*((struct_processus_fils *)
601: (*s_objet).objet)).thread).tid,
602: (*(*((struct_processus_fils *)
603: (*(*l_element_courant).donnee).objet)).thread)
604: .tid) != 0)) && ((*(*((struct_processus_fils *)
605: (*s_objet).objet)).thread).pid ==
606: (*(*((struct_processus_fils *)
607: (*(*l_element_courant).donnee).objet)).thread)
608: .pid))
609: {
610: if (pthread_kill((*(*((struct_processus_fils *)
611: (*s_objet).objet)).thread).tid, SIGCONT)
612: != 0)
613: {
614: // Le thread est peut-être dans l'état zombie.
615: }
616:
617: if (pthread_mutex_unlock(
618: &((*(*((struct_processus_fils *)
619: (*s_objet).objet)).thread).mutex)) != 0)
620: {
621: (*s_etat_processus).erreur_systeme =
622: d_es_processus;
623: return;
624: }
625:
626: break;
627: }
628: }
629:
630: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
631: (*s_objet).objet)).thread).mutex)) != 0)
632: {
633: (*s_etat_processus).erreur_systeme = d_es_processus;
634: return;
635: }
636: }
637:
638: l_element_courant = (*l_element_courant).suivant;
639: }
640:
641: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
642: {
643: (*s_etat_processus).erreur_systeme = d_es_processus;
644: }
645: }
646: }
647: else
648: {
649: liberation(s_etat_processus, s_objet);
650:
651: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
652: return;
653: }
654:
655: liberation(s_etat_processus, s_objet);
656:
657: return;
658: }
659:
660:
661: /*
662: ================================================================================
663: Fonction 'cstop'
664: ================================================================================
665: Entrées :
666: --------------------------------------------------------------------------------
667: Sorties :
668: --------------------------------------------------------------------------------
669: Effets de bord : néant
670: ================================================================================
671: */
672:
673: void
674: instruction_cstop(struct_processus *s_etat_processus)
675: {
676: (*s_etat_processus).erreur_execution = d_ex;
677:
678: if ((*s_etat_processus).affichage_arguments == 'Y')
679: {
680: printf("\n CSTOP ");
681:
682: if ((*s_etat_processus).langue == 'F')
683: {
684: printf("(capture du signal stop)\n\n");
685: printf(" Aucun argument\n");
686: }
687: else
688: {
689: printf("(catch stop signal)\n\n");
690: printf(" No argument\n");
691: }
692:
693: return;
694: }
695: else if ((*s_etat_processus).test_instruction == 'Y')
696: {
697: (*s_etat_processus).nombre_arguments = -1;
698: return;
699: }
700:
701: if (test_cfsf(s_etat_processus, 31) == d_vrai)
702: {
703: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
704: {
705: return;
706: }
707: }
708:
709: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
710: {
711: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
712: }
713: else
714: {
715: (*s_etat_processus).erreur_execution = d_ex_stop;
716: }
717:
718: return;
719: }
720:
721:
722: /*
723: ================================================================================
724: Fonction 'clrfuse'
725: ================================================================================
726: Entrées :
727: --------------------------------------------------------------------------------
728: Sorties :
729: --------------------------------------------------------------------------------
730: Effets de bord : néant
731: ================================================================================
732: */
733:
734: void
735: instruction_clrfuse(struct_processus *s_etat_processus)
736: {
737: (*s_etat_processus).erreur_execution = d_ex;
738:
739: if ((*s_etat_processus).affichage_arguments == 'Y')
740: {
741: printf("\n CLRFUSE ");
742:
743: if ((*s_etat_processus).langue == 'F')
744: {
745: printf("(libère un fusible)\n\n");
746: printf(" Aucun argument\n");
747: }
748: else
749: {
750: printf("(release fuse signal)\n\n");
751: printf(" No argument\n");
752: }
753:
754: return;
755: }
756: else if ((*s_etat_processus).test_instruction == 'Y')
757: {
758: (*s_etat_processus).nombre_arguments = -1;
759: return;
760: }
761:
762: if (test_cfsf(s_etat_processus, 31) == d_vrai)
763: {
764: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
765: {
766: return;
767: }
768: }
769:
770: if ((*s_etat_processus).presence_fusible == d_faux)
771: {
772: (*s_etat_processus).erreur_execution = d_ex_fusible;
773: return;
774: }
775:
776: if (pthread_cancel((*s_etat_processus).thread_fusible) != 0)
777: {
778: if ((*s_etat_processus).var_volatile_requete_arret == 0)
779: {
780: (*s_etat_processus).erreur_systeme = d_es_processus;
781: return;
782: }
783: }
784:
785: (*s_etat_processus).thread_fusible = 0;
786: (*s_etat_processus).presence_fusible = d_faux;
787:
788: return;
789: }
790:
791:
792: /*
793: ================================================================================
794: Fonction 'crtab'
795: ================================================================================
796: Entrées :
797: --------------------------------------------------------------------------------
798: Sorties :
799: --------------------------------------------------------------------------------
800: Effets de bord : néant
801: ================================================================================
802: */
803:
804: void
805: instruction_crtab(struct_processus *s_etat_processus)
806: {
807: struct_liste_chainee *l_element_courant;
808:
809: struct_objet *s_objet_argument;
810: struct_objet *s_objet_resultat;
811:
812: struct_objet *
813: creation_table(struct_liste_chainee *dimensions)
814: {
815: struct_objet *s_table;
816:
817: unsigned long i;
818:
819: if ((s_table = allocation(s_etat_processus, TBL)) == NULL)
820: {
821: return(NULL);
822: }
823:
824: (*((struct_tableau *) (*s_table).objet)).nombre_elements =
825: (unsigned long) (*((integer8 *) (*(*dimensions).donnee).objet));
826:
827: dimensions = (*dimensions).suivant;
828:
829: if (((*((struct_tableau *) (*s_table).objet)).elements =
830: malloc((*((struct_tableau *) (*s_table).objet))
831: .nombre_elements * sizeof(struct_objet *))) == NULL)
832: {
833: return(NULL);
834: }
835:
836: if (dimensions == NULL)
837: {
838: for(i = 0; i < (*((struct_tableau *) (*s_table).objet))
839: .nombre_elements; i++)
840: {
841: if (((*((struct_tableau *) (*s_table).objet)).elements[i] =
842: allocation(s_etat_processus, LST)) == NULL)
843: {
844: return(NULL);
845: }
846: }
847: }
848: else
849: {
850: for(i = 0; i < (*((struct_tableau *) (*s_table).objet))
851: .nombre_elements; i++)
852: {
853: if (((*((struct_tableau *) (*s_table).objet)).elements[i] =
854: creation_table(dimensions)) == NULL)
855: {
856: return(NULL);
857: }
858: }
859: }
860:
861: return(s_table);
862: }
863:
864: (*s_etat_processus).erreur_execution = d_ex;
865:
866: if ((*s_etat_processus).affichage_arguments == 'Y')
867: {
868: printf("\n CRTAB ");
869:
870: if ((*s_etat_processus).langue == 'F')
871: {
872: printf("(création d'une table régulière)\n\n");
873: }
874: else
875: {
876: printf("(create a regular table)\n\n");
877: }
878:
879: printf(" 1: %s\n", d_LST);
880: printf("-> 1: %s\n", d_TAB);
881:
882: return;
883: }
884: else if ((*s_etat_processus).test_instruction == 'Y')
885: {
886: (*s_etat_processus).nombre_arguments = -1;
887: return;
888: }
889:
890: if (test_cfsf(s_etat_processus, 31) == d_vrai)
891: {
892: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
893: {
894: return;
895: }
896: }
897:
898: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
899: &s_objet_argument) == d_erreur)
900: {
901: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
902: return;
903: }
904:
905: if ((*s_objet_argument).type == LST)
906: {
907: l_element_courant = (*s_objet_argument).objet;
908:
909: if (l_element_courant == NULL)
910: {
911: liberation(s_etat_processus, s_objet_argument);
912:
913: (*s_etat_processus).erreur_execution =
914: d_ex_argument_invalide;
915: return;
916: }
917:
918: while(l_element_courant != NULL)
919: {
920: if ((*(*l_element_courant).donnee).type != INT)
921: {
922: liberation(s_etat_processus, s_objet_argument);
923:
924: (*s_etat_processus).erreur_execution =
925: d_ex_erreur_type_argument;
926: return;
927: }
928:
929: l_element_courant = (*l_element_courant).suivant;
930: }
931:
932: if ((s_objet_resultat =
933: creation_table((*s_objet_argument).objet)) == NULL)
934: {
935: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
936: return;
937: }
938: }
939: else
940: {
941: liberation(s_etat_processus, s_objet_argument);
942:
943: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
944: return;
945: }
946:
947: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
948: s_objet_resultat) == d_erreur)
949: {
950: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
951: return;
952: }
953:
954: liberation(s_etat_processus, s_objet_argument);
955:
956: return;
957: }
958:
959: // vim: ts=4