![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to messages.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to messages.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.70 ! bertrand 3: RPL/2 (R) version 4.1.19
1.68 bertrand 4: Copyright (C) 1989-2014 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.16 bertrand 23: #define MESSAGES
1.22 bertrand 24: #include "rpl-conv.h"
1.1 bertrand 25:
26:
27: /*
28: ================================================================================
29: Affichage des messages d'erreur
30: ================================================================================
31: Entrées : structure sur l'état du processus
32: --------------------------------------------------------------------------------
33: Sorties : néant
34: --------------------------------------------------------------------------------
35: Effets de bord : néant
36: ================================================================================
37: */
38:
39: unsigned char *
40: messages(struct_processus *s_etat_processus)
41: {
42: logical1 erreur_fonction_externe;
43:
44: unsigned char *message;
45: unsigned char *chaine;
46: unsigned char *argument;
47:
48: chaine = NULL;
49: argument = NULL;
50:
51: erreur_fonction_externe = d_faux;
52:
53: (*s_etat_processus).derniere_exception = d_ep;
54: (*s_etat_processus).derniere_erreur_execution = d_ex;
55: (*s_etat_processus).derniere_erreur_systeme = d_es;
56:
57: if ((*s_etat_processus).erreur_execution != d_ex)
58: {
59: (*s_etat_processus).derniere_erreur_execution =
60: (*s_etat_processus).erreur_execution;
61:
62: /*
63: --------------------------------------------------------------------------------
64: Erreurs dues aux définitions
65: --------------------------------------------------------------------------------
66: */
67:
68: switch((*s_etat_processus).erreur_execution)
69: {
70: case d_ex_pile_vide :
71: {
72: if ((*s_etat_processus).langue == 'F')
73: {
74: chaine = "+++Erreur : Pile opérationnelle vide";
75: }
76: else
77: {
78: chaine = "+++Error : Empty stack";
79: }
80:
81: break;
82: }
83:
84: case d_ex_manque_argument :
85: {
86: if ((*s_etat_processus).langue == 'F')
87: {
88: chaine ="+++Erreur : Arguments insuffisants pour la "
1.49 bertrand 89: "commande '%s'";
1.1 bertrand 90: argument = (*s_etat_processus).instruction_derniere_erreur;
91: }
92: else
93: {
1.49 bertrand 94: chaine = "+++Error : Too few arguments for '%s' "
1.1 bertrand 95: "command";
96: argument = (*s_etat_processus).instruction_derniere_erreur;
97: }
98:
99: break;
100: }
101:
102: case d_ex_argument_invalide :
103: {
104: if ((*s_etat_processus).langue == 'F')
105: {
106: chaine = "+++Erreur : Argument invalide pour la "
1.49 bertrand 107: "commande '%s'";
1.1 bertrand 108: argument = (*s_etat_processus).instruction_derniere_erreur;
109: }
110: else
111: {
112: chaine = "+++Error : Invalid argument for "
1.49 bertrand 113: "'%s' command";
1.1 bertrand 114: argument = (*s_etat_processus).instruction_derniere_erreur;
115: }
116:
117: break;
118: }
119:
120: case d_ex_nom_reserve :
121: {
122: if ((*s_etat_processus).langue == 'F')
123: {
124: chaine = "Erreur : Nom '%s' réservé";
125: argument = (*s_etat_processus).instruction_derniere_erreur;
126: }
127: else
128: {
129: chaine = "Error : '%s' reserved name";
130: argument = (*s_etat_processus).instruction_derniere_erreur;
131: }
132:
133: break;
134: }
135:
136: case d_ex_erreur_type_argument :
137: {
138: if ((*s_etat_processus).langue == 'F')
139: {
140: chaine = "+++Erreur : Type d'argument invalide pour la "
1.49 bertrand 141: "commande '%s'";
1.1 bertrand 142: argument = (*s_etat_processus).instruction_derniere_erreur;
143: }
144: else
145: {
146: chaine = "+++Error : Invalid argument type for "
1.49 bertrand 147: "'%s' command";
1.1 bertrand 148: argument = (*s_etat_processus).instruction_derniere_erreur;
149: }
150:
151: break;
152: }
153:
154: case d_ex_nombre_arguments :
155: {
156: if ((*s_etat_processus).langue == 'F')
157: {
158: chaine = "+++Erreur : Une même fonction apparaît avec "
159: "des nombres d'arguments différents (%s)";
160: argument = (*s_etat_processus).instruction_derniere_erreur;
161: }
162: else
163: {
164: chaine = "+++Error : The same function seems to have "
165: "different numbers of arguments (%s)";
166: argument = (*s_etat_processus).instruction_derniere_erreur;
167: }
168:
169: break;
170: }
171:
172: case d_ex_dimensions_invalides :
173: {
174: if ((*s_etat_processus).langue == 'F')
175: {
176: chaine = "+++Erreur : Dimensions invalides pour "
1.49 bertrand 177: "l'instruction '%s'";
1.1 bertrand 178: argument = (*s_etat_processus).instruction_derniere_erreur;
179: }
180: else
181: {
182: chaine = "+++Erreur : Invalid dimensions for "
1.49 bertrand 183: "'%s' instruction";
1.1 bertrand 184: argument = (*s_etat_processus).instruction_derniere_erreur;
185: }
186:
187: break;
188: }
189:
190: case d_ex_expression_invalide :
191: {
192: if ((*s_etat_processus).langue == 'F')
193: {
1.49 bertrand 194: chaine = "+++Erreur : Expression '%s' invalide";
1.1 bertrand 195: argument = (*s_etat_processus).instruction_derniere_erreur;
196: }
197: else
198: {
1.49 bertrand 199: chaine = "+++Error : Invalid '%s' expression";
1.1 bertrand 200: argument = (*s_etat_processus).instruction_derniere_erreur;
201: }
202:
203: break;
204: }
205:
206: case d_ex_erreur_traitement_condition :
207: {
208: if ((*s_etat_processus).langue == 'F')
209: {
210: chaine = "+++Erreur : Traitement impossible d'une clause "
211: "conditionnelle";
212: }
213: else
214: {
215: chaine = "+++Error : Illegal conditional structure";
216: }
217:
218: break;
219: }
220:
221: case d_ex_erreur_traitement_boucle :
222: {
223: if ((*s_etat_processus).langue == 'F')
224: {
225: chaine = "+++Erreur : Traitement impossible "
226: "d'une boucle";
227: }
228: else
229: {
230: chaine = "+++Error : Illegal loop structure";
231: }
232:
233: break;
234: }
235:
236: case d_ex_variable_non_definie :
237: {
238: if ((*s_etat_processus).langue == 'F')
239: {
240: chaine = "+++Erreur : Variable non définie";
241: }
242: else
243: {
244: chaine = "+++Error : Undefined variable";
245: }
246:
247: break;
248: }
249:
250: case d_ex_drapeau_inexistant :
251: {
252: if ((*s_etat_processus).langue == 'F')
253: {
254: chaine = "+++Erreur : Drapeau inexistant";
255: }
256: else
257: {
258: chaine = "+++Error : Non-existent flag";
259: }
260:
261: break;
262: }
263:
264: case d_ex_nom_invalide :
265: {
266: if ((*s_etat_processus).langue == 'F')
267: {
268: chaine = "+++Erreur : Nom de variable invalide (%s)";
269: argument = (*s_etat_processus).instruction_derniere_erreur;
270: }
271: else
272: {
273: chaine = "+++Error : Invalid variable name (%s)";
274: argument = (*s_etat_processus).instruction_derniere_erreur;
275: }
276:
277: break;
278: }
279:
280: case d_ex_element_inexistant :
281: {
282: if ((*s_etat_processus).langue == 'F')
283: {
284: chaine = "+++Erreur : Indice invalide";
285: }
286: else
287: {
288: chaine = "+++Error : Invalid index";
289: }
290:
291: break;
292: }
293:
294: case d_ex_absence_variable :
295: {
296: if ((*s_etat_processus).langue == 'F')
297: {
298: chaine = "+++Erreur : Absence de variable";
299: }
300: else
301: {
302: chaine = "+++Error : Variable omission";
303: }
304:
305: break;
306: }
307:
308: case d_ex_erreur_evaluation :
309: {
310: if ((*s_etat_processus).langue == 'F')
311: {
312: chaine = "+++Erreur : Erreur dans l'évaluation d'une "
313: "expression";
314: }
315: else
316: {
317: chaine = "+++Error : Error in expression evaluation";
318: }
319:
320: break;
321: }
322:
323: case d_ex_longueur_fft :
324: {
325: if ((*s_etat_processus).langue == 'F')
326: {
327: chaine = "+++Erreur : Longueur de FFT invalide";
328: }
329: else
330: {
331: chaine = "+++Error : Invalid FFT length";
332: }
333:
334: break;
335: }
336:
337: case d_ex_longueur_dft :
338: {
339: if ((*s_etat_processus).langue == 'F')
340: {
341: chaine = "+++Erreur : Longueur de DFT invalide";
342: }
343: else
344: {
345: chaine = "+++Error : Invalid DFT length";
346: }
347:
348: break;
349: }
350:
351: case d_ex_queue_impression :
352: {
353: if ((*s_etat_processus).langue == 'F')
354: {
355: chaine = "+++Erreur : Queue d'impression vide";
356: }
357: else
358: {
359: chaine = "+++Error : Empty printing spool queue";
360: }
361:
362: break;
363: }
364:
365: case d_ex_type_trace_invalide :
366: {
367: if ((*s_etat_processus).langue == 'F')
368: {
369: chaine = "+++Erreur : Type de tracé invalide";
370: }
371: else
372: {
373: chaine = "+++Error : Invalid graph type";
374: }
375:
376: break;
377: }
378:
379: case d_ex_erreur_fichier :
380: {
381: if ((*s_etat_processus).langue == 'F')
382: {
383: chaine = "+++Erreur : Erreur d'entrée/sortie sur un"
384: " fichier ou une socket";
385: }
386: else
387: {
388: chaine = "+++Error : file or socket input/output error";
389: }
390:
391: break;
392: }
393:
394: case d_ex_absence_equation :
395: {
396: if ((*s_etat_processus).langue == 'F')
397: {
398: chaine = "+++Erreur : Absence d'équation";
399: }
400: else
401: {
402: chaine = "+++Error : Equation omission";
403: }
404:
405: break;
406: }
407:
408: case d_ex_erreur_bibliotheque :
409: {
410: if ((*s_etat_processus).langue == 'F')
411: {
412: chaine = "+++Erreur : Erreur portant sur une "
413: "bibliothèque dynamique";
414: }
415: else
416: {
417: chaine = "+++Error : Dynamic library error";
418: }
419:
420: break;
421: }
422:
423: case d_ex_execution_bibliotheque :
424: {
425: if ((*s_etat_processus).langue == 'F')
426: {
427: chaine = "+++Erreur : Problème lors de l'exécution d'une "
428: "fonction externe";
429: }
430: else
431: {
432: chaine = "+++Error : External function execution "
433: "error";
434: }
435:
436: break;
437: }
438:
439: case d_ex_matrice_statistique_invalide :
440: {
441: if ((*s_etat_processus).langue == 'F')
442: {
443: chaine = "+++Erreur : Matrice statistique invalide";
444: }
445: else
446: {
447: chaine = "+++Error : Invalid statistical matrix";
448: }
449:
450: break;
451: }
452:
453: case d_ex_dimensions_matrice_statistique :
454: {
455: if ((*s_etat_processus).langue == 'F')
456: {
457: chaine = "+++Erreur : Dimensions différentes des "
458: "observations et de la matrice statistique";
459: }
460: else
461: {
462: chaine = "+++Error : Invalid dimensions between "
463: "observations and statistical matrix";
464: }
465:
466: break;
467: }
468:
469: case d_ex_absence_observations :
470: {
471: if ((*s_etat_processus).langue == 'F')
472: {
473: chaine = "+++Erreur : Absence de matrice statistique";
474: }
475: else
476: {
477: chaine = "+++Error : Statistical matrix omission";
478: }
479:
480: break;
481: }
482:
483: case d_ex_statistiques_echantillon :
484: {
485: if ((*s_etat_processus).langue == 'F')
486: {
487: chaine = "+++Erreur : Echantillon trop restreint pour un "
488: "calcul de statistique";
489: }
490: else
491: {
492: chaine = "+++Error : Too few statistical observations";
493: }
494:
495: break;
496: }
497:
498: case d_ex_observations_inexistantes :
499: {
500: if ((*s_etat_processus).langue == 'F')
501: {
502: chaine = "+++Erreur : Colonne d'observations "
503: "inexistante";
504: }
505: else
506: {
507: chaine = "+++Error : Non-existent observations column";
508: }
509:
510: break;
511: }
512:
513: case d_ex_syntaxe :
514: {
515: if ((*s_etat_processus).langue == 'F')
516: {
517: chaine = "+++Erreur : Erreur de syntaxe";
518: }
519: else
520: {
521: chaine = "+++Error : Syntax error";
522: }
523:
524: break;
525: }
526:
527: case d_ex_cycle_hors_boucle :
528: {
529: if ((*s_etat_processus).langue == 'F')
530: {
531: chaine = "+++Erreur : Instruction 'CYCLE' hors d'une"
532: " boucle définie";
533: }
534: else
535: {
536: chaine = "+++Error : 'CYCLE' instruction out of any "
537: "defined loop";
538: }
539:
540: break;
541: }
542:
543: case d_ex_conversion_unite :
544: {
545: if ((*s_etat_processus).langue == 'F')
546: {
547: chaine = "+++Erreur : Conversion d'unité impossible";
548: }
549: else
550: {
551: chaine = "+++Error : Unit translation impossible";
552: }
553:
554: break;
555: }
556:
557: case d_ex_erreur_parametre_fichier :
558: {
559: if ((*s_etat_processus).langue == 'F')
560: {
561: chaine = "+++Erreur : Paramètre de fichier ou de socket "
562: "invalide";
563: }
564: else
565: {
566: chaine = "+++Error : Invalid file or socket parameter";
567: }
568:
569: break;
570: }
571:
572: case d_ex_erreur_acces_fichier :
573: {
574: if ((*s_etat_processus).langue == 'F')
575: {
576: chaine = "+++Erreur : Erreur d'accès à un fichier ou à une"
577: " socket";
578: }
579: else
580: {
581: chaine = "+++Error : File or socket access error";
582: }
583:
584: break;
585: }
586:
587: case d_ex_erreur_requete_fichier :
588: {
589: if ((*s_etat_processus).langue == 'F')
590: {
591: chaine = "+++Erreur : Erreur de requête envers un "
592: "fichier";
593: }
594: else
595: {
596: chaine = "+++Error : File request error";
597: }
598:
599: break;
600: }
601:
602: case d_ex_erreur_format_fichier :
603: {
604: if ((*s_etat_processus).langue == 'F')
605: {
606: chaine = "+++Erreur : Erreur de format";
607: }
608: else
609: {
610: chaine = "+++Error : Format error";
611: }
612:
613: break;
614: }
615:
616: case d_ex_fichier_verrouille :
617: {
618: if ((*s_etat_processus).langue == 'F')
619: {
620: chaine = "+++Erreur : Fichier verrouillé";
621: }
622: else
623: {
624: chaine = "+++Error : Locked file";
625: }
626:
627: break;
628: }
629:
630: case d_ex_verrou_indefini :
631: {
632: if ((*s_etat_processus).langue == 'F')
633: {
634: chaine = "+++Erreur : Verrou indéfini";
635: }
636: else
637: {
638: chaine = "+++Error : Undefined lock";
639: }
640:
641: break;
642: }
643:
644: case d_ex_fin_de_fichier_atteinte :
645: {
646: if ((*s_etat_processus).langue == 'F')
647: {
648: chaine = "+++Erreur : Fin de fichier atteinte";
649: }
650: else
651: {
652: chaine = "+++Error : End of file reached";
653: }
654:
655: break;
656: }
657:
658: case d_ex_debut_de_fichier_atteint :
659: {
660: if ((*s_etat_processus).langue == 'F')
661: {
662: chaine = "+++Erreur : Début de fichier atteint";
663: }
664: else
665: {
666: chaine = "+++Error : Beginning of file reached";
667: }
668:
669: break;
670: }
671:
672: case d_ex_erreur_type_fichier :
673: {
674: if ((*s_etat_processus).langue == 'F')
675: {
676: chaine = "+++Erreur : Type de fichier invalide";
677: }
678: else
679: {
680: chaine = "+++Error : Invalid file type";
681: }
682:
683: break;
684: }
685:
686: case d_ex_fichier_vide :
687: {
688: if ((*s_etat_processus).langue == 'F')
689: {
690: chaine = "+++Erreur : Fichier vide";
691: }
692: else
693: {
694: chaine = "+++Error : Empty file";
695: }
696:
697: break;
698: }
699:
700: case d_ex_dimensions_differentes :
701: {
702: if ((*s_etat_processus).langue == 'F')
703: {
704: chaine = "+++Erreur : Dimensions différentes pour "
705: "deux graphiques à superposer";
706: }
707: else
708: {
709: chaine = "+++Error : Invalid graphical dimension";
710: }
711:
712: break;
713: }
714:
715: case d_ex_routines_mathematiques :
716: {
717: if ((*s_etat_processus).langue == 'F')
718: {
719: chaine = "+++Erreur : Erreur interne dans la routine"
1.49 bertrand 720: " mathématique '%s'";
1.1 bertrand 721: argument = (*s_etat_processus).instruction_derniere_erreur;
722: }
723: else
724: {
725: chaine = "+++Error : Internal error in mathematical"
1.49 bertrand 726: " subroutine '%s'";
1.1 bertrand 727: argument = (*s_etat_processus).instruction_derniere_erreur;
728: }
729:
730: break;
731: }
732:
733: case d_ex_exit_hors_boucle :
734: {
735: if ((*s_etat_processus).langue == 'F')
736: {
737: chaine = "+++Erreur : Instruction 'EXIT' hors d'une"
738: " boucle";
739: }
740: else
741: {
742: chaine = "+++Error : 'EXIT' instruction out of any "
743: "loop";
744: }
745:
746: break;
747: }
748:
749: case d_ex_processus :
750: {
751: if ((*s_etat_processus).langue == 'F')
752: {
753: chaine = "+++Erreur : Processus inexistant";
754: }
755: else
756: {
757: chaine = "+++Error : Non-existent process";
758: }
759:
760: break;
761: }
762:
763: case d_ex_image_processus :
764: {
765: if ((*s_etat_processus).langue == 'F')
766: {
767: chaine = "+++Erreur : Création impossible de l'image"
768: " du processus courant";
769: }
770: else
771: {
772: chaine = "+++Error : Cannot create dump of current process";
773: }
774:
775: break;
776: }
777:
778: case d_ex_erreur_sql :
779: {
780: if ((*s_etat_processus).langue == 'F')
781: {
782: chaine = "+++Erreur : Requête SQL invalide";
783: }
784: else
785: {
786: chaine = "+++Error : Invalid SQL query";
787: }
788:
789: break;
790: }
791:
792: case d_ex_variable_verrouillee :
793: {
794: if ((*s_etat_processus).langue == 'F')
795: {
796: chaine = "+++Erreur : Variable verrouillée";
797: }
798: else
799: {
800: chaine = "+++Error : Locked variable";
801: }
802:
803: break;
804: }
805:
806: case d_ex_variable_volatile :
807: {
808: if ((*s_etat_processus).langue == 'F')
809: {
810: chaine = "+++Erreur : Variable volatile";
811: }
812: else
813: {
814: chaine = "+++Error : Volatile variable";
815: }
816:
817: break;
818: }
819:
820: case d_ex_erreur_processus :
821: {
822: if ((*s_etat_processus).langue == 'F')
823: {
824: chaine = "+++Erreur : Commande inconnue";
825: }
826: else
827: {
828: chaine = "+++Error : Unknown command";
829: }
830:
831: break;
832: }
833:
834: case d_ex_erreur_impression :
835: {
836: if ((*s_etat_processus).langue == 'F')
837: {
838: chaine = "+++Erreur : Fichier d'impression erroné";
839: }
840: else
841: {
842: chaine = "+++Error : Erroneous print file";
843: }
844:
845: break;
846: }
847:
848: case d_ex_nombre_arguments_fonction :
849: {
850: if ((*s_etat_processus).langue == 'F')
851: {
852: chaine = "+++Erreur : Nombre d'arguments invalide";
853: }
854: else
855: {
856: chaine = "+++Error : Invalid number of arguments";
857: }
858:
859: break;
860: }
861:
862: case d_ex_fonction_indisponible :
863: {
864: if ((*s_etat_processus).langue == 'F')
865: {
866: chaine = "+++Erreur : Fonction indisponible";
867: }
868: else
869: {
870: chaine = "+++Error : Unavailable function";
871: }
872:
873: break;
874: }
875:
876: case d_ex_bibliotheque_chargee :
877: {
878: if ((*s_etat_processus).langue == 'F')
879: {
880: chaine = "+++Erreur : Bibliothèque ouverte";
881: }
882: else
883: {
884: chaine = "+++Error : Opened library";
885: }
886:
887: break;
888: }
889:
890: case d_ex_aucun_symbole :
891: {
892: if ((*s_etat_processus).langue == 'F')
893: {
894: chaine = "+++Erreur : Aucun symbole déclaré";
895: }
896: else
897: {
898: chaine = "+++Error : Too few symbols";
899: }
900:
901: break;
902: }
903:
904: case d_ex_definition_ambigue :
905: {
906: if ((*s_etat_processus).langue == 'F')
907: {
908: chaine = "+++Erreur : Définition externe ambiguë";
909: }
910: else
911: {
912: chaine = "+++Error : Ambiguous external definition";
913: }
914:
915: break;
916: }
917:
918: case d_ex_fichier_hors_contexte :
919: {
920: if ((*s_etat_processus).langue == 'F')
921: {
922: chaine = "+++Erreur : Descripteur hors contexte";
923: }
924: else
925: {
926: chaine = "+++Error : Context mismatch";
927: }
928:
929: break;
930: }
931:
932: case d_ex_socket_en_ecoute :
933: {
934: if ((*s_etat_processus).langue == 'F')
935: {
936: chaine = "+++Erreur : Connexion refusée sur une socket"
937: " en attente";
938: }
939: else
940: {
941: chaine = "+++Error : Connexion refused on a"
942: " waiting socket";
943: }
944:
945: break;
946: }
947:
948: case d_ex_interruption_invalide :
949: {
950: if ((*s_etat_processus).langue == 'F')
951: {
952: chaine = "+++Erreur : Interruption invalide";
953: }
954: else
955: {
956: chaine = "+++Error : Unavailable interrupt";
957: }
958:
959: break;
960: }
961:
962: case d_ex_erreur_transcodage :
963: {
964: if ((*s_etat_processus).langue == 'F')
965: {
966: chaine = "+++Erreur : Erreur de transcodage";
967: }
968: else
969: {
970: chaine = "+++Error : Transcodage error";
971: }
972:
973: break;
974: }
975:
976: case d_ex_contexte :
977: {
978: if ((*s_etat_processus).langue == 'F')
979: {
980: chaine = "+++Erreur : Aucun contexte sauvegardé";
981: }
982: else
983: {
984: chaine = "+++Error : No stacked context";
985: }
986:
987: break;
988: }
989:
990: case d_ex_absence_processus_pere :
991: {
992: if ((*s_etat_processus).langue == 'F')
993: {
994: chaine = "+++Erreur : Absence de processus père";
995: }
996: else
997: {
998: chaine = "+++Error : No parent process";
999: }
1000:
1001: break;
1002: }
1003:
1004: case d_ex_creation_variable :
1005: {
1006: if ((*s_etat_processus).langue == 'F')
1007: {
1008: chaine = "+++Erreur : Création de variable impossible";
1009: }
1010: else
1011: {
1012: chaine = "+++Error : Variable initialization failed";
1013: }
1014:
1015: break;
1016: }
1017:
1018: case d_ex_fusible :
1019: {
1020: if ((*s_etat_processus).langue == 'F')
1021: {
1022: chaine = "+++Erreur : Fusible préexistant";
1023: }
1024: else
1025: {
1026: chaine = "+++Error : Fuse error";
1027: }
1028:
1029: break;
1030: }
1031:
1032: case d_ex_iswi_hors_interruption :
1033: {
1034: if ((*s_etat_processus).langue == 'F')
1035: {
1036: chaine = "+++Erreur : Aucune interruption en cours";
1037: }
1038: else
1039: {
1040: chaine = "+++Error : No current interrupt";
1041: }
1042:
1043: break;
1044: }
1045:
1046: case d_ex_daemon :
1047: {
1048: if ((*s_etat_processus).langue == 'F')
1049: {
1050: chaine = "+++Erreur : Conversion en daemon impossible";
1051: }
1052: else
1053: {
1054: chaine = "+++Error : Unable to convert to daemon";
1055: }
1056:
1057: break;
1058: }
1059:
1060: case d_ex_mutex :
1061: {
1062: if ((*s_etat_processus).langue == 'F')
1063: {
1064: chaine = "+++Erreur : Mutex non initialisé";
1065: }
1066: else
1067: {
1068: chaine = "+++Error : Uninitialized mutex";
1069: }
1070:
1071: break;
1072: }
1073:
1074: case d_ex_semaphore :
1075: {
1076: if ((*s_etat_processus).langue == 'F')
1077: {
1078: chaine = "+++Erreur : Erreur d'accès à un sémaphore";
1079: }
1080: else
1081: {
1082: chaine = "+++Error : Semaphore access error";
1083: }
1084:
1085: break;
1086: }
1087:
1088: case d_ex_variable_statique_partagee :
1089: {
1090: if ((*s_etat_processus).langue == 'F')
1091: {
1092: chaine = "+++Erreur : Variable statique partagée";
1093: }
1094: else
1095: {
1096: chaine = "+++Error : Static shared variable";
1097: }
1098:
1099: break;
1100: }
1101:
1102: case d_ex_variable_partagee :
1103: {
1104: if ((*s_etat_processus).langue == 'F')
1105: {
1106: chaine = "+++Erreur : Variable partagée";
1107: }
1108: else
1109: {
1110: chaine = "+++Error : Shared variable";
1111: }
1112:
1113: break;
1114: }
1115:
1116: case d_ex_graphique_memorise :
1117: {
1118: if ((*s_etat_processus).langue == 'F')
1119: {
1120: chaine = "+++Erreur : Données mémorisées non affichées";
1121: }
1122: else
1123: {
1124: chaine = "+++Error : Non plotted buffered data";
1125: }
1126:
1127: break;
1128: }
1129:
1130: case d_ex_absence_graphique_courant :
1131: {
1132: if ((*s_etat_processus).langue == 'F')
1133: {
1134: chaine = "+++Erreur : Aucun graphique en cours";
1135: }
1136: else
1137: {
1138: chaine = "+++Error : No current graphic";
1139: }
1140:
1141: break;
1142: }
1143:
1144: case d_ex_stop :
1145: {
1146: if ((*s_etat_processus).langue == 'F')
1147: {
1148: chaine = "+++Erreur : Masque du signal STOP";
1149: }
1150: else
1151: {
1152: chaine = "+++Error : STOP signal mask";
1153: }
1154:
1155: break;
1156: }
1157:
1158: case d_ex_matrice_non_diagonale :
1159: {
1160: if ((*s_etat_processus).langue == 'F')
1161: {
1162: chaine = "+++Erreur : Matrice non diagonale";
1163: }
1164: else
1165: {
1166: chaine = "+++Error : Non diagonal matrix";
1167: }
1168:
1169: break;
1170: }
1171:
1172: case d_ex_locales :
1173: {
1174: if ((*s_etat_processus).langue == 'F')
1175: {
1176: chaine = "+++Erreur : Variable de localisation "
1177: "indisponible";
1178: }
1179: else
1180: {
1181: chaine = "+++Error : Unavailable locale";
1182: }
1183:
1184: break;
1185: }
1186:
1187: case d_ex_representation :
1188: {
1189: if ((*s_etat_processus).langue == 'F')
1190: {
1191: chaine = "+++Erreur : Erreur de représentation";
1192: }
1193: else
1194: {
1195: chaine = "+++Error : Mapping error";
1196: }
1197:
1198: break;
1199: }
1200:
1201: case d_ex_erreur_profilage :
1202: {
1203: if ((*s_etat_processus).langue == 'F')
1204: {
1205: chaine = "+++Erreur : Pile de profilage vide";
1206: }
1207: else
1208: {
1209: chaine = "+++Error : Empty profiles stack";
1210: }
1211:
1212: break;
1213: }
1214:
1.6 bertrand 1215: case d_ex_enregistrement_inexistant :
1216: {
1217: if ((*s_etat_processus).langue == 'F')
1218: {
1219: chaine = "+++Erreur : Enregistrement inexistant";
1220: }
1221: else
1222: {
1223: chaine = "+++Error : Record not found";
1224: }
1225:
1226: break;
1227: }
1228:
1.7 bertrand 1229: case d_ex_clef_inexistante :
1230: {
1231: if ((*s_etat_processus).langue == 'F')
1232: {
1233: chaine = "+++Erreur : Clef inexistante";
1234: }
1235: else
1236: {
1237: chaine = "+++Error : Key not found";
1238: }
1239:
1240: break;
1241: }
1242:
1.12 bertrand 1243: case d_ex_nom_implicite :
1244: {
1245: if ((*s_etat_processus).langue == 'F')
1246: {
1247: chaine = "+++Erreur : Nom implicite indéfini";
1248: }
1249: else
1250: {
1251: chaine = "+++Error : Undefined implicit name";
1252: }
1253:
1254: break;
1255: }
1256:
1.18 bertrand 1257: case d_ex_version_bibliotheque :
1258: {
1259: if ((*s_etat_processus).langue == 'F')
1260: {
1261: chaine = "+++Erreur : Version de bibliothèque incompatible";
1262: }
1263: else
1264: {
1265: chaine = "+++Error : Library version mismatch";
1266: }
1267:
1268: break;
1269: }
1270:
1.30 bertrand 1271: case d_ex_creation_variable_globale :
1272: {
1273: if ((*s_etat_processus).langue == 'F')
1274: {
1275: chaine = "+++Erreur : Création de variable globale "
1276: "impossible";
1277: }
1278: else
1279: {
1.37 bertrand 1280: chaine = "+++Error : Cannot create global variable";
1281: }
1282:
1283: break;
1284: }
1285:
1286: case d_ex_erreur_interne_rplcas :
1287: {
1288: if ((*s_etat_processus).langue == 'F')
1289: {
1290: chaine = "+++Erreur : Erreur interne RPL/CAS";
1291: }
1292: else
1293: {
1294: chaine = "+++Error : Internal RPL/CAS error";
1.30 bertrand 1295: }
1296:
1297: break;
1298: }
1299:
1.43 bertrand 1300: case d_ex_fichier_corrompu :
1301: {
1302: if ((*s_etat_processus).langue == 'F')
1303: {
1304: chaine = "+++Erreur : Fichier corrompu";
1305: }
1306: else
1307: {
1308: chaine = "+++Error : Corrupted file";
1309: }
1310:
1311: break;
1312: }
1313:
1.45 bertrand 1314: case d_ex_mutex_acquis_autre_thread :
1315: {
1316: if ((*s_etat_processus).langue == 'F')
1317: {
1318: chaine = "+++Erreur : Mutex acquis par un autre thread";
1319: }
1320: else
1321: {
1322: chaine = "+++Error : Mutex owned by another thread";
1323: }
1324:
1325: break;
1326: }
1327:
1.46 bertrand 1328: case d_ex_expression_reguliere :
1329: {
1330: if ((*s_etat_processus).langue == 'F')
1331: {
1332: chaine = "+++Erreur : Expression régulière";
1333: }
1334: else
1335: {
1336: chaine = "+++Error : Regular expression";
1337: }
1338:
1339: break;
1340: }
1341:
1.51 bertrand 1342: case d_ex_instruction_indisponible :
1343: {
1344: if ((*s_etat_processus).langue == 'F')
1345: {
1346: chaine = "+++Erreur : Instruction intrinsèque non "
1347: "disponible";
1348: }
1349: else
1350: {
1351: chaine = "+++Error : Unavailable intrinsic instruction";
1352: }
1353:
1354: break;
1355: }
1356:
1.58 bertrand 1357: case d_ex_chiffrement :
1358: {
1359: if ((*s_etat_processus).langue == 'F')
1360: {
1361: chaine = "+++Erreur : Erreur dans les routines "
1362: "de chiffrement";
1363: }
1364: else
1365: {
1366: chaine = "+++Error : Cipher error";
1367: }
1368:
1369: break;
1370: }
1371:
1372: case d_ex_chiffrement_indisponible :
1373: {
1374: if ((*s_etat_processus).langue == 'F')
1375: {
1376: chaine = "+++Erreur : Algorithme de chiffrement "
1377: "indisponible";
1378: }
1379: else
1380: {
1381: chaine = "+++Error : Unavailable cipher algorithm";
1382: }
1383:
1384: break;
1385: }
1386:
1.59 bertrand 1387: case d_ex_longueur_clef_chiffrement :
1388: {
1389: if ((*s_etat_processus).langue == 'F')
1390: {
1391: chaine = "+++Erreur : Longueur invalide de la clef "
1.60 bertrand 1392: "de chiffrement";
1.59 bertrand 1393: }
1394: else
1395: {
1396: chaine = "+++Error : Invalide key length";
1397: }
1398:
1.63 bertrand 1399: case d_ex_taille_message :
1400: {
1401: if ((*s_etat_processus).langue == 'F')
1402: {
1403: chaine = "+++Erreur : Message trop long";
1404: }
1405: else
1406: {
1407: chaine = "+++Error : Message size";
1408: }
1409:
1410: break;
1411: }
1412:
1.59 bertrand 1413: break;
1414: }
1415:
1.1 bertrand 1416: case -1 : // Fonction externe
1417: {
1418: if ((*s_etat_processus).langue == 'F')
1419: {
1.49 bertrand 1420: chaine = "+++Erreur : Fonction dynamique '%s' (ligne %lld)";
1.1 bertrand 1421: argument = (*s_etat_processus).instruction_derniere_erreur;
1422: erreur_fonction_externe = d_vrai;
1423: }
1424: else
1425: {
1.49 bertrand 1426: chaine = "+++Error : '%s' dynamic function (line %lld)";
1.1 bertrand 1427: argument = (*s_etat_processus).instruction_derniere_erreur;
1428: erreur_fonction_externe = d_vrai;
1429: }
1430:
1431: break;
1432: }
1433:
1434: default :
1435: {
1436: if ((*s_etat_processus).langue == 'F')
1437: {
1438: chaine = "+++Erreur : Erreur d'exécution";
1439: }
1440: else
1441: {
1442: chaine = "+++Error : Execution error";
1443: }
1444:
1445: break;
1446: }
1447: }
1448: }
1449: else if ((*s_etat_processus).erreur_systeme != d_es)
1450: {
1451: (*s_etat_processus).derniere_erreur_systeme =
1452: (*s_etat_processus).erreur_systeme;
1453:
1454: /*
1455: --------------------------------------------------------------------------------
1456: Erreurs dues au système et au séquenceur
1457: --------------------------------------------------------------------------------
1458: */
1459:
1460: switch((*s_etat_processus).erreur_systeme)
1461: {
1462: case d_es_allocation_memoire :
1463: {
1464: if ((*s_etat_processus).langue == 'F')
1465: {
1466: chaine = "+++Système : Erreur d'allocation mémoire";
1467: }
1468: else
1469: {
1470: chaine = "+++System : Memory allocation error";
1471: }
1472:
1473: break;
1474: }
1475:
1476: case d_es_variable_introuvable :
1477: {
1478: if ((*s_etat_processus).langue == 'F')
1479: {
1480: chaine = "+++Système : Variable non définie";
1481: }
1482: else
1483: {
1484: chaine = "+++System : Undefined variable";
1485: }
1486:
1487: break;
1488: }
1489:
1490: case d_es_pile_vide :
1491: {
1492: if ((*s_etat_processus).langue == 'F')
1493: {
1494: chaine = "+++Système : Pile système vide";
1495: }
1496: else
1497: {
1498: chaine = "+++System : Empty system stack";
1499: }
1500:
1501: break;
1502: }
1503:
1504: case d_es_pile_operationnelle_vide :
1505: {
1506: if ((*s_etat_processus).langue == 'F')
1507: {
1508: chaine = "+++Système : Pile vide";
1509: }
1510: else
1511: {
1512: chaine = "+++System : Empty stack";
1513: }
1514:
1515: break;
1516: }
1517:
1518: case d_es_end_incoherent :
1519: {
1520: if ((*s_etat_processus).langue == 'F')
1521: {
1522: chaine = "+++Système : Instruction END incohérente";
1523: }
1524: else
1525: {
1526: chaine = "+++Systeme : Incoherent END instruction";
1527: }
1528:
1529: break;
1530: }
1531:
1532: case d_es_peripherique_stdin :
1533: {
1534: if ((*s_etat_processus).langue == 'F')
1535: {
1536: chaine = "+++Système : Erreur de lecture sur stdin";
1537: }
1538: else
1539: {
1540: chaine = "+++System : Read error on stdin";
1541: }
1542:
1543: break;
1544: }
1545:
1546: case d_es_erreur_fichier :
1547: {
1548: if ((*s_etat_processus).langue == 'F')
1549: {
1550: chaine = "+++Système : Erreur d'entrée/sortie sur un"
1551: " fichier";
1552: }
1553: else
1554: {
1555: chaine = "+++System : File input/output error";
1556: }
1557:
1558: break;
1559: }
1560:
1561: case d_es_execution_bibliotheque :
1562: {
1563: if ((*s_etat_processus).langue == 'F')
1564: {
1565: chaine = "+++Système : Problème lors de l'exécution "
1566: "d'une fonction externe";
1567: }
1568: else
1569: {
1570: chaine = "+++System : Extern function execution error";
1571: }
1572:
1573: break;
1574: }
1575:
1576: case d_es_signal :
1577: {
1578: if ((*s_etat_processus).langue == 'F')
1579: {
1580: chaine = "+++Système : Problème de gestion de signaux "
1581: "POSIX";
1582: }
1583: else
1584: {
1585: chaine = "+++System : POSIX signal error";
1586: }
1587:
1588: break;
1589: }
1590:
1591: case d_es_processus :
1592: {
1593: if ((*s_etat_processus).langue == 'F')
1594: {
1595: chaine = "+++Système : Erreur dans la gestion des"
1596: " processus";
1597: }
1598: else
1599: {
1600: chaine = "+++System : Process management error";
1601: }
1602:
1603: break;
1604: }
1605:
1606: case d_es_nombre_max_descripteurs :
1607: {
1608: if ((*s_etat_processus).langue == 'F')
1609: {
1610: chaine = "+++Système : Nombre maximal de descripteurs"
1611: " de fichiers atteint";
1612: }
1613: else
1614: {
1615: chaine = "+++System : Too much file descriptors";
1616: }
1617:
1618: break;
1619: }
1620:
1621: case d_es_interruption_invalide :
1622: {
1623: if ((*s_etat_processus).langue == 'F')
1624: {
1625: chaine = "+++Système : Interruption invalide";
1626: }
1627: else
1628: {
1629: chaine = "+++System : Unavailable interrupt";
1630: }
1631:
1632: break;
1633: }
1634:
1635: case d_es_contexte :
1636: {
1637: if ((*s_etat_processus).langue == 'F')
1638: {
1639: chaine = "+++Système : Erreur dans la gestion des"
1640: " contextes";
1641: }
1642: else
1643: {
1644: chaine = "+++System : Context management error";
1645: }
1646:
1647: break;
1648: }
1649:
1.5 bertrand 1650: case d_es_somme_controle :
1651: {
1652: if ((*s_etat_processus).langue == 'F')
1653: {
1654: chaine = "+++Système : Somme de contrôle invalide";
1655: }
1656: else
1657: {
1658: chaine = "+++System : Invalid hash sum";
1659: }
1660:
1661: break;
1662: }
1663:
1.24 bertrand 1664: case d_es_semaphore :
1665: {
1666: if ((*s_etat_processus).langue == 'F')
1667: {
1668: chaine = "+++Système : Erreur d'accès à un sémaphore";
1669: }
1670: else
1671: {
1672: chaine = "+++System : Semaphore access error";
1673: }
1674:
1675: break;
1676: }
1677:
1.45 bertrand 1678: case d_es_mutex_acquis_autre_thread :
1679: {
1680: if ((*s_etat_processus).langue == 'F')
1681: {
1682: chaine = "+++Système : Mutex acquis par un autre thread";
1683: }
1684: else
1685: {
1686: chaine = "+++System : Mutex owned by another thread";
1687: }
1688:
1689: break;
1690: }
1691:
1.1 bertrand 1692: case -1 : // Fonction externe
1693: {
1694: if ((*s_etat_processus).langue == 'F')
1695: {
1.49 bertrand 1696: chaine = "+++Système : Fonction dynamique '%s' "
1697: "(ligne %lld)";
1.1 bertrand 1698: argument = (*s_etat_processus).instruction_derniere_erreur;
1699: erreur_fonction_externe = d_vrai;
1700: }
1701: else
1702: {
1.49 bertrand 1703: chaine = "+++System : '%s' dynamic function (line %lld)";
1.1 bertrand 1704: argument = (*s_etat_processus).instruction_derniere_erreur;
1705: erreur_fonction_externe = d_vrai;
1706: }
1707:
1708: break;
1709: }
1710:
1711: default :
1712: {
1713: if ((*s_etat_processus).langue == 'F')
1714: {
1715: chaine = "+++Système : Erreur interne";
1716: }
1717: else
1718: {
1719: chaine = "+++System : Internal error";
1720: }
1721:
1722: break;
1723: }
1724: }
1725: }
1726: else if ((*s_etat_processus).exception != d_ep)
1727: {
1728: (*s_etat_processus).derniere_exception =
1729: (*s_etat_processus).exception;
1730:
1731: /*
1732: --------------------------------------------------------------------------------
1733: Exceptions mathématiques
1734: --------------------------------------------------------------------------------
1735: */
1736:
1737: switch((*s_etat_processus).exception)
1738: {
1739: case d_ep_division_par_zero :
1740: {
1741: if ((*s_etat_processus).langue == 'F')
1742: {
1743: chaine = "+++Exception : Division par zéro";
1744: }
1745: else
1746: {
1747: chaine = "+++Exception : Division by zero";
1748: }
1749:
1750: break;
1751: }
1752:
1753: case d_ep_matrice_non_inversible :
1754: {
1755: if ((*s_etat_processus).langue == 'F')
1756: {
1757: chaine = "+++Exception : Matrice non inversible";
1758: }
1759: else
1760: {
1761: chaine = "+++Exception : Non inversible matrix";
1762: }
1763:
1764: break;
1765: }
1766:
1767: case d_ep_resultat_indefini :
1768: {
1769: if ((*s_etat_processus).langue == 'F')
1770: {
1771: chaine = "+++Exception : Résultat indéfini";
1772: }
1773: else
1774: {
1775: chaine = "+++Exception : Undefined result";
1776: }
1777:
1778: break;
1779: }
1780:
1781: case d_ep_underflow :
1782: {
1783: if ((*s_etat_processus).langue == 'F')
1784: {
1785: chaine = "+++Exception : Dépassement de capacité"
1786: " (underflow)";
1787: }
1788: else
1789: {
1790: chaine = "+++Exception : Underflow exception";
1791: }
1792:
1793: break;
1794: }
1795:
1796: case d_ep_overflow :
1797: {
1798: if ((*s_etat_processus).langue == 'F')
1799: {
1800: chaine = "+++Exception : Dépassement de capacité"
1801: " (overflow)";
1802: }
1803: else
1804: {
1805: chaine = "+++Exception : Overflow exception";
1806: }
1807:
1808: break;
1809: }
1810:
1811: case d_ep_domaine_definition :
1812: {
1813: if ((*s_etat_processus).langue == 'F')
1814: {
1815: chaine = "+++Exception : Domaine de définition";
1816: }
1817: else
1818: {
1819: chaine = "+++Exception : Domain exception";
1820: }
1821:
1822: break;
1823: }
1824:
1825: case d_ep_perte_precision :
1826: {
1827: if ((*s_etat_processus).langue == 'F')
1828: {
1829: chaine = "+++Exception : Perte de précision";
1830: }
1831: else
1832: {
1833: chaine = "+++Exception : Loss of precision";
1834: }
1835:
1836: break;
1837: }
1838:
1839: case d_ep_decomposition_QR :
1840: {
1841: if ((*s_etat_processus).langue == 'F')
1842: {
1843: chaine = "+++Exception : Décomposition QR impossible";
1844: }
1845: else
1846: {
1847: chaine = "+++Exception : QR decomposition failed";
1848: }
1849:
1850: break;
1851: }
1852:
1853: case d_ep_matrice_non_definie_positive :
1854: {
1855: if ((*s_etat_processus).langue == 'F')
1856: {
1857: chaine = "+++Exception : Matrice non définie positive";
1858: }
1859: else
1860: {
1861: chaine = "+++Exception : Non positive defined matrix";
1862: }
1863:
1864: break;
1865: }
1866:
1867: case d_ep_decomposition_QZ :
1868: {
1869: if ((*s_etat_processus).langue == 'F')
1870: {
1871: chaine = "+++Exception : Décomposition QZ impossible";
1872: }
1873: else
1874: {
1875: chaine = "+++Exception : QZ decomposition failed";
1876: }
1877:
1878: break;
1879: }
1880:
1881: case d_ep_decomposition_SVD :
1882: {
1883: if ((*s_etat_processus).langue == 'F')
1884: {
1885: chaine = "+++Exception : Décomposition SVD impossible";
1886: }
1887: else
1888: {
1889: chaine = "+++Exception : SVD decomposition failed";
1890: }
1891:
1892: break;
1893: }
1894:
1895: default :
1896: {
1897: if ((*s_etat_processus).langue == 'F')
1898: {
1899: chaine = "+++Exception : Exception mathématique";
1900: }
1901: else
1902: {
1903: chaine = "+++Exception : Mathematical exception";
1904: }
1905:
1906: break;
1907: }
1908: }
1909: }
1910: else if ((*s_etat_processus).erreur_compilation != d_ec)
1911: {
1912:
1913: /*
1914: --------------------------------------------------------------------------------
1915: Erreurs de compilation
1916: --------------------------------------------------------------------------------
1917: */
1918:
1919: switch((*s_etat_processus).erreur_compilation)
1920: {
1921: case d_ec_niveau_definition_negatif :
1922: {
1923: if ((*s_etat_processus).langue == 'F')
1924: {
1925: chaine = "+++Fatal : Niveau de définition négatif";
1926: }
1927: else
1928: {
1929: chaine = "+++Fatal : Negative definition level";
1930: }
1931:
1932: break;
1933: }
1934:
1935: case d_ec_nom_definition_invalide :
1936: {
1937: if ((*s_etat_processus).langue == 'F')
1938: {
1939: chaine = "+++Fatal : Nom de définition invalide";
1940: }
1941: else
1942: {
1943: chaine = "+++Fatal : Invalid definition name";
1944: }
1945:
1946: break;
1947: }
1948:
1949: case d_ec_erreur_boucle_definie :
1950: {
1951: if ((*s_etat_processus).langue == 'F')
1952: {
1953: chaine = "+++Fatal : Définition illégale "
1954: "d'une boucle définie";
1955: }
1956: else
1957: {
1958: chaine = "+++Fatal : Illegal use of a defined loop";
1959: }
1960:
1961: break;
1962: }
1963:
1964: case d_ec_erreur_instruction_end :
1965: {
1966: if ((*s_etat_processus).langue == 'F')
1967: {
1968: chaine = "+++Fatal : Erreur dans une structure terminée "
1969: "par l'instruction END";
1970: }
1971: else
1972: {
1973: chaine = "+++Fatal : Error in an END-closed structure";
1974: }
1975:
1976: break;
1977: }
1978:
1979: case d_ec_erreur_instruction_until :
1980: {
1981: if ((*s_etat_processus).langue == 'F')
1982: {
1983: chaine = "+++Fatal : Erreur dans une boucle DO/UNTIL/END";
1984: }
1985: else
1986: {
1987: chaine = "+++Fatal : Error in a DO/UNTIL/END loop";
1988: }
1989:
1990: break;
1991: }
1992:
1993: case d_ec_source_incoherent :
1994: {
1995: if ((*s_etat_processus).langue == 'F')
1996: {
1997: chaine = "+++Fatal : Définitions incohérentes";
1998: }
1999: else
2000: {
2001: chaine = "+++Fatal : Incoherent definitions";
2002: }
2003:
2004: break;
2005: }
2006:
2007: case d_ec_erreur_instruction_while :
2008: {
2009: if ((*s_etat_processus).langue == 'F')
2010: {
2011: chaine = "+++Fatal : Erreur dans une boucle WHILE/REPEAT/"
2012: "END";
2013: }
2014: else
2015: {
2016: chaine = "+++Fatal : Error in a WHILE/REPEAT/END loop";
2017: }
2018:
2019: break;
2020: }
2021:
2022: case d_ec_erreur_instruction_select :
2023: {
2024: if ((*s_etat_processus).langue == 'F')
2025: {
2026: chaine = "+++Fatal : Erreur dans une structure SELECT"
2027: "/DEFAULT/END";
2028: }
2029: else
2030: {
2031: chaine = "+++Fatal : Error in a SELECT/DEFAULT/END "
2032: "structure";
2033: }
2034:
2035: break;
2036: }
2037:
2038: case d_ec_erreur_instruction_case :
2039: {
2040: if ((*s_etat_processus).langue == 'F')
2041: {
2042: chaine = "+++Fatal : Erreur dans une structure CASE"
2043: "/THEN/END";
2044: }
2045: else
2046: {
2047: chaine = "+++Fatal : Error in a CASE/THEN/END "
2048: "structure";
2049: }
2050:
2051: break;
2052: }
2053:
2054: case d_ec_erreur_instruction_then :
2055: {
2056: if ((*s_etat_processus).langue == 'F')
2057: {
2058: chaine = "+++Fatal : Erreur dans une structure IF, "
2059: "IFERR ou CASE/THEN/END";
2060: }
2061: else
2062: {
2063: chaine = "+++Fatal : Error in a IF, IFERR or "
2064: "CASE/THEN/END structure";
2065: }
2066:
2067: break;
2068: }
2069:
2070: case d_ec_erreur_instruction_else :
2071: {
2072: if ((*s_etat_processus).langue == 'F')
2073: {
2074: chaine = "+++Fatal : Erreur dans une structure ELSE";
2075: }
2076: else
2077: {
2078: chaine = "+++Fatal : Error in a ELSE structure";
2079: }
2080:
2081: break;
2082: }
2083:
2084: case d_ec_erreur_instruction_elseif :
2085: {
2086: if ((*s_etat_processus).langue == 'F')
2087: {
2088: chaine = "+++Fatal : Erreur dans une structure ELSEIF";
2089: }
2090: else
2091: {
2092: chaine = "+++Fatal : Error in a ELSEIF structure";
2093: }
2094:
2095: break;
2096: }
2097:
2098: default :
2099: {
2100: if ((*s_etat_processus).langue == 'F')
2101: {
2102: chaine = "+++Fatal : Erreur de compilation";
2103: }
2104: else
2105: {
2106: chaine = "+++Fatal : compilation error";
2107: }
2108:
2109: break;
2110: }
2111: }
2112: }
2113: else
2114: {
2115: if ((*s_etat_processus).langue == 'F')
2116: {
2117: chaine = "";
2118: }
2119: else
2120: {
2121: chaine = "";
2122: }
2123: }
2124:
2125: if (argument == NULL)
2126: {
2127: if ((message = malloc((strlen(chaine) + 1) * sizeof(unsigned char)))
2128: == NULL)
2129: {
2130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2131: return NULL;
2132: }
2133:
2134: strcpy(message, chaine);
2135: }
2136: else
2137: {
2138: if (erreur_fonction_externe == d_faux)
2139: {
2140: if ((message = malloc((strlen(chaine) + strlen(argument) - 1) *
2141: sizeof(unsigned char))) == NULL)
2142: {
2143: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2144: return NULL;
2145: }
2146:
2147: sprintf(message, chaine, argument);
2148: }
2149: else
2150: {
2151: if ((message = malloc((strlen(chaine) + strlen(argument) + 64
2152: - 1) * sizeof(unsigned char))) == NULL)
2153: {
2154: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2155: return NULL;
2156: }
2157:
2158: sprintf(message, chaine, argument,
2159: (*s_etat_processus).derniere_erreur_fonction_externe);
2160: }
2161: }
2162:
2163: return(message);
2164: }
2165:
2166: // vim: ts=4