File:
[local] /
rpl /
src /
messages.c
Revision
1.34:
download - view:
text,
annotated -
select for diffs -
revision graph
Tue Jun 21 15:26:35 2011 UTC (12 years, 10 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: #define MESSAGES
24: #include "rpl-conv.h"
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 "
89: "commande %s";
90: argument = (*s_etat_processus).instruction_derniere_erreur;
91: }
92: else
93: {
94: chaine = "+++Error : Too few arguments for %s "
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 "
107: "commande %s";
108: argument = (*s_etat_processus).instruction_derniere_erreur;
109: }
110: else
111: {
112: chaine = "+++Error : Invalid argument for "
113: "%s command";
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 "
141: "commande %s";
142: argument = (*s_etat_processus).instruction_derniere_erreur;
143: }
144: else
145: {
146: chaine = "+++Error : Invalid argument type for "
147: "%s command";
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 "
177: "l'instruction %s";
178: argument = (*s_etat_processus).instruction_derniere_erreur;
179: }
180: else
181: {
182: chaine = "+++Erreur : Invalid dimensions for "
183: "%s instruction";
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: {
194: chaine = "+++Erreur : Expression %s invalide";
195: argument = (*s_etat_processus).instruction_derniere_erreur;
196: }
197: else
198: {
199: chaine = "+++Error : Invalid %s expression";
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"
720: " mathématique %s";
721: argument = (*s_etat_processus).instruction_derniere_erreur;
722: }
723: else
724: {
725: chaine = "+++Error : Internal error in mathematical"
726: " subroutine %s";
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:
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:
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:
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:
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:
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: {
1280: chaine = "+Erreur : Cannot create global variable";
1281: }
1282:
1283: break;
1284: }
1285:
1286: case -1 : // Fonction externe
1287: {
1288: if ((*s_etat_processus).langue == 'F')
1289: {
1290: chaine = "+++Erreur : Fonction dynamique %s (ligne %lld)";
1291: argument = (*s_etat_processus).instruction_derniere_erreur;
1292: erreur_fonction_externe = d_vrai;
1293: }
1294: else
1295: {
1296: chaine = "+++Error : %s dynamic function (line %lld)";
1297: argument = (*s_etat_processus).instruction_derniere_erreur;
1298: erreur_fonction_externe = d_vrai;
1299: }
1300:
1301: break;
1302: }
1303:
1304: default :
1305: {
1306: if ((*s_etat_processus).langue == 'F')
1307: {
1308: chaine = "+++Erreur : Erreur d'exécution";
1309: }
1310: else
1311: {
1312: chaine = "+++Error : Execution error";
1313: }
1314:
1315: break;
1316: }
1317: }
1318: }
1319: else if ((*s_etat_processus).erreur_systeme != d_es)
1320: {
1321: (*s_etat_processus).derniere_erreur_systeme =
1322: (*s_etat_processus).erreur_systeme;
1323:
1324: /*
1325: --------------------------------------------------------------------------------
1326: Erreurs dues au système et au séquenceur
1327: --------------------------------------------------------------------------------
1328: */
1329:
1330: switch((*s_etat_processus).erreur_systeme)
1331: {
1332: case d_es_allocation_memoire :
1333: {
1334: if ((*s_etat_processus).langue == 'F')
1335: {
1336: chaine = "+++Système : Erreur d'allocation mémoire";
1337: }
1338: else
1339: {
1340: chaine = "+++System : Memory allocation error";
1341: }
1342:
1343: break;
1344: }
1345:
1346: case d_es_variable_introuvable :
1347: {
1348: if ((*s_etat_processus).langue == 'F')
1349: {
1350: chaine = "+++Système : Variable non définie";
1351: }
1352: else
1353: {
1354: chaine = "+++System : Undefined variable";
1355: }
1356:
1357: break;
1358: }
1359:
1360: case d_es_pile_vide :
1361: {
1362: if ((*s_etat_processus).langue == 'F')
1363: {
1364: chaine = "+++Système : Pile système vide";
1365: }
1366: else
1367: {
1368: chaine = "+++System : Empty system stack";
1369: }
1370:
1371: break;
1372: }
1373:
1374: case d_es_pile_operationnelle_vide :
1375: {
1376: if ((*s_etat_processus).langue == 'F')
1377: {
1378: chaine = "+++Système : Pile vide";
1379: }
1380: else
1381: {
1382: chaine = "+++System : Empty stack";
1383: }
1384:
1385: break;
1386: }
1387:
1388: case d_es_end_incoherent :
1389: {
1390: if ((*s_etat_processus).langue == 'F')
1391: {
1392: chaine = "+++Système : Instruction END incohérente";
1393: }
1394: else
1395: {
1396: chaine = "+++Systeme : Incoherent END instruction";
1397: }
1398:
1399: break;
1400: }
1401:
1402: case d_es_peripherique_stdin :
1403: {
1404: if ((*s_etat_processus).langue == 'F')
1405: {
1406: chaine = "+++Système : Erreur de lecture sur stdin";
1407: }
1408: else
1409: {
1410: chaine = "+++System : Read error on stdin";
1411: }
1412:
1413: break;
1414: }
1415:
1416: case d_es_erreur_fichier :
1417: {
1418: if ((*s_etat_processus).langue == 'F')
1419: {
1420: chaine = "+++Système : Erreur d'entrée/sortie sur un"
1421: " fichier";
1422: }
1423: else
1424: {
1425: chaine = "+++System : File input/output error";
1426: }
1427:
1428: break;
1429: }
1430:
1431: case d_es_execution_bibliotheque :
1432: {
1433: if ((*s_etat_processus).langue == 'F')
1434: {
1435: chaine = "+++Système : Problème lors de l'exécution "
1436: "d'une fonction externe";
1437: }
1438: else
1439: {
1440: chaine = "+++System : Extern function execution error";
1441: }
1442:
1443: break;
1444: }
1445:
1446: case d_es_signal :
1447: {
1448: if ((*s_etat_processus).langue == 'F')
1449: {
1450: chaine = "+++Système : Problème de gestion de signaux "
1451: "POSIX";
1452: }
1453: else
1454: {
1455: chaine = "+++System : POSIX signal error";
1456: }
1457:
1458: break;
1459: }
1460:
1461: case d_es_processus :
1462: {
1463: if ((*s_etat_processus).langue == 'F')
1464: {
1465: chaine = "+++Système : Erreur dans la gestion des"
1466: " processus";
1467: }
1468: else
1469: {
1470: chaine = "+++System : Process management error";
1471: }
1472:
1473: break;
1474: }
1475:
1476: case d_es_nombre_max_descripteurs :
1477: {
1478: if ((*s_etat_processus).langue == 'F')
1479: {
1480: chaine = "+++Système : Nombre maximal de descripteurs"
1481: " de fichiers atteint";
1482: }
1483: else
1484: {
1485: chaine = "+++System : Too much file descriptors";
1486: }
1487:
1488: break;
1489: }
1490:
1491: case d_es_interruption_invalide :
1492: {
1493: if ((*s_etat_processus).langue == 'F')
1494: {
1495: chaine = "+++Système : Interruption invalide";
1496: }
1497: else
1498: {
1499: chaine = "+++System : Unavailable interrupt";
1500: }
1501:
1502: break;
1503: }
1504:
1505: case d_es_contexte :
1506: {
1507: if ((*s_etat_processus).langue == 'F')
1508: {
1509: chaine = "+++Système : Erreur dans la gestion des"
1510: " contextes";
1511: }
1512: else
1513: {
1514: chaine = "+++System : Context management error";
1515: }
1516:
1517: break;
1518: }
1519:
1520: case d_es_somme_controle :
1521: {
1522: if ((*s_etat_processus).langue == 'F')
1523: {
1524: chaine = "+++Système : Somme de contrôle invalide";
1525: }
1526: else
1527: {
1528: chaine = "+++System : Invalid hash sum";
1529: }
1530:
1531: break;
1532: }
1533:
1534: case d_es_semaphore :
1535: {
1536: if ((*s_etat_processus).langue == 'F')
1537: {
1538: chaine = "+++Système : Erreur d'accès à un sémaphore";
1539: }
1540: else
1541: {
1542: chaine = "+++System : Semaphore access error";
1543: }
1544:
1545: break;
1546: }
1547:
1548: case -1 : // Fonction externe
1549: {
1550: if ((*s_etat_processus).langue == 'F')
1551: {
1552: chaine = "+++Système : Fonction dynamique %s (ligne %lld)";
1553: argument = (*s_etat_processus).instruction_derniere_erreur;
1554: erreur_fonction_externe = d_vrai;
1555: }
1556: else
1557: {
1558: chaine = "+++System : %s dynamic function (line %lld)";
1559: argument = (*s_etat_processus).instruction_derniere_erreur;
1560: erreur_fonction_externe = d_vrai;
1561: }
1562:
1563: break;
1564: }
1565:
1566: default :
1567: {
1568: if ((*s_etat_processus).langue == 'F')
1569: {
1570: chaine = "+++Système : Erreur interne";
1571: }
1572: else
1573: {
1574: chaine = "+++System : Internal error";
1575: }
1576:
1577: break;
1578: }
1579: }
1580: }
1581: else if ((*s_etat_processus).exception != d_ep)
1582: {
1583: (*s_etat_processus).derniere_exception =
1584: (*s_etat_processus).exception;
1585:
1586: /*
1587: --------------------------------------------------------------------------------
1588: Exceptions mathématiques
1589: --------------------------------------------------------------------------------
1590: */
1591:
1592: switch((*s_etat_processus).exception)
1593: {
1594: case d_ep_division_par_zero :
1595: {
1596: if ((*s_etat_processus).langue == 'F')
1597: {
1598: chaine = "+++Exception : Division par zéro";
1599: }
1600: else
1601: {
1602: chaine = "+++Exception : Division by zero";
1603: }
1604:
1605: break;
1606: }
1607:
1608: case d_ep_matrice_non_inversible :
1609: {
1610: if ((*s_etat_processus).langue == 'F')
1611: {
1612: chaine = "+++Exception : Matrice non inversible";
1613: }
1614: else
1615: {
1616: chaine = "+++Exception : Non inversible matrix";
1617: }
1618:
1619: break;
1620: }
1621:
1622: case d_ep_resultat_indefini :
1623: {
1624: if ((*s_etat_processus).langue == 'F')
1625: {
1626: chaine = "+++Exception : Résultat indéfini";
1627: }
1628: else
1629: {
1630: chaine = "+++Exception : Undefined result";
1631: }
1632:
1633: break;
1634: }
1635:
1636: case d_ep_underflow :
1637: {
1638: if ((*s_etat_processus).langue == 'F')
1639: {
1640: chaine = "+++Exception : Dépassement de capacité"
1641: " (underflow)";
1642: }
1643: else
1644: {
1645: chaine = "+++Exception : Underflow exception";
1646: }
1647:
1648: break;
1649: }
1650:
1651: case d_ep_overflow :
1652: {
1653: if ((*s_etat_processus).langue == 'F')
1654: {
1655: chaine = "+++Exception : Dépassement de capacité"
1656: " (overflow)";
1657: }
1658: else
1659: {
1660: chaine = "+++Exception : Overflow exception";
1661: }
1662:
1663: break;
1664: }
1665:
1666: case d_ep_domaine_definition :
1667: {
1668: if ((*s_etat_processus).langue == 'F')
1669: {
1670: chaine = "+++Exception : Domaine de définition";
1671: }
1672: else
1673: {
1674: chaine = "+++Exception : Domain exception";
1675: }
1676:
1677: break;
1678: }
1679:
1680: case d_ep_perte_precision :
1681: {
1682: if ((*s_etat_processus).langue == 'F')
1683: {
1684: chaine = "+++Exception : Perte de précision";
1685: }
1686: else
1687: {
1688: chaine = "+++Exception : Loss of precision";
1689: }
1690:
1691: break;
1692: }
1693:
1694: case d_ep_decomposition_QR :
1695: {
1696: if ((*s_etat_processus).langue == 'F')
1697: {
1698: chaine = "+++Exception : Décomposition QR impossible";
1699: }
1700: else
1701: {
1702: chaine = "+++Exception : QR decomposition failed";
1703: }
1704:
1705: break;
1706: }
1707:
1708: case d_ep_matrice_non_definie_positive :
1709: {
1710: if ((*s_etat_processus).langue == 'F')
1711: {
1712: chaine = "+++Exception : Matrice non définie positive";
1713: }
1714: else
1715: {
1716: chaine = "+++Exception : Non positive defined matrix";
1717: }
1718:
1719: break;
1720: }
1721:
1722: case d_ep_decomposition_QZ :
1723: {
1724: if ((*s_etat_processus).langue == 'F')
1725: {
1726: chaine = "+++Exception : Décomposition QZ impossible";
1727: }
1728: else
1729: {
1730: chaine = "+++Exception : QZ decomposition failed";
1731: }
1732:
1733: break;
1734: }
1735:
1736: case d_ep_decomposition_SVD :
1737: {
1738: if ((*s_etat_processus).langue == 'F')
1739: {
1740: chaine = "+++Exception : Décomposition SVD impossible";
1741: }
1742: else
1743: {
1744: chaine = "+++Exception : SVD decomposition failed";
1745: }
1746:
1747: break;
1748: }
1749:
1750: default :
1751: {
1752: if ((*s_etat_processus).langue == 'F')
1753: {
1754: chaine = "+++Exception : Exception mathématique";
1755: }
1756: else
1757: {
1758: chaine = "+++Exception : Mathematical exception";
1759: }
1760:
1761: break;
1762: }
1763: }
1764: }
1765: else if ((*s_etat_processus).erreur_compilation != d_ec)
1766: {
1767:
1768: /*
1769: --------------------------------------------------------------------------------
1770: Erreurs de compilation
1771: --------------------------------------------------------------------------------
1772: */
1773:
1774: switch((*s_etat_processus).erreur_compilation)
1775: {
1776: case d_ec_niveau_definition_negatif :
1777: {
1778: if ((*s_etat_processus).langue == 'F')
1779: {
1780: chaine = "+++Fatal : Niveau de définition négatif";
1781: }
1782: else
1783: {
1784: chaine = "+++Fatal : Negative definition level";
1785: }
1786:
1787: break;
1788: }
1789:
1790: case d_ec_nom_definition_invalide :
1791: {
1792: if ((*s_etat_processus).langue == 'F')
1793: {
1794: chaine = "+++Fatal : Nom de définition invalide";
1795: }
1796: else
1797: {
1798: chaine = "+++Fatal : Invalid definition name";
1799: }
1800:
1801: break;
1802: }
1803:
1804: case d_ec_erreur_boucle_definie :
1805: {
1806: if ((*s_etat_processus).langue == 'F')
1807: {
1808: chaine = "+++Fatal : Définition illégale "
1809: "d'une boucle définie";
1810: }
1811: else
1812: {
1813: chaine = "+++Fatal : Illegal use of a defined loop";
1814: }
1815:
1816: break;
1817: }
1818:
1819: case d_ec_erreur_instruction_end :
1820: {
1821: if ((*s_etat_processus).langue == 'F')
1822: {
1823: chaine = "+++Fatal : Erreur dans une structure terminée "
1824: "par l'instruction END";
1825: }
1826: else
1827: {
1828: chaine = "+++Fatal : Error in an END-closed structure";
1829: }
1830:
1831: break;
1832: }
1833:
1834: case d_ec_erreur_instruction_until :
1835: {
1836: if ((*s_etat_processus).langue == 'F')
1837: {
1838: chaine = "+++Fatal : Erreur dans une boucle DO/UNTIL/END";
1839: }
1840: else
1841: {
1842: chaine = "+++Fatal : Error in a DO/UNTIL/END loop";
1843: }
1844:
1845: break;
1846: }
1847:
1848: case d_ec_source_incoherent :
1849: {
1850: if ((*s_etat_processus).langue == 'F')
1851: {
1852: chaine = "+++Fatal : Définitions incohérentes";
1853: }
1854: else
1855: {
1856: chaine = "+++Fatal : Incoherent definitions";
1857: }
1858:
1859: break;
1860: }
1861:
1862: case d_ec_erreur_instruction_while :
1863: {
1864: if ((*s_etat_processus).langue == 'F')
1865: {
1866: chaine = "+++Fatal : Erreur dans une boucle WHILE/REPEAT/"
1867: "END";
1868: }
1869: else
1870: {
1871: chaine = "+++Fatal : Error in a WHILE/REPEAT/END loop";
1872: }
1873:
1874: break;
1875: }
1876:
1877: case d_ec_erreur_instruction_select :
1878: {
1879: if ((*s_etat_processus).langue == 'F')
1880: {
1881: chaine = "+++Fatal : Erreur dans une structure SELECT"
1882: "/DEFAULT/END";
1883: }
1884: else
1885: {
1886: chaine = "+++Fatal : Error in a SELECT/DEFAULT/END "
1887: "structure";
1888: }
1889:
1890: break;
1891: }
1892:
1893: case d_ec_erreur_instruction_case :
1894: {
1895: if ((*s_etat_processus).langue == 'F')
1896: {
1897: chaine = "+++Fatal : Erreur dans une structure CASE"
1898: "/THEN/END";
1899: }
1900: else
1901: {
1902: chaine = "+++Fatal : Error in a CASE/THEN/END "
1903: "structure";
1904: }
1905:
1906: break;
1907: }
1908:
1909: case d_ec_erreur_instruction_then :
1910: {
1911: if ((*s_etat_processus).langue == 'F')
1912: {
1913: chaine = "+++Fatal : Erreur dans une structure IF, "
1914: "IFERR ou CASE/THEN/END";
1915: }
1916: else
1917: {
1918: chaine = "+++Fatal : Error in a IF, IFERR or "
1919: "CASE/THEN/END structure";
1920: }
1921:
1922: break;
1923: }
1924:
1925: case d_ec_erreur_instruction_else :
1926: {
1927: if ((*s_etat_processus).langue == 'F')
1928: {
1929: chaine = "+++Fatal : Erreur dans une structure ELSE";
1930: }
1931: else
1932: {
1933: chaine = "+++Fatal : Error in a ELSE structure";
1934: }
1935:
1936: break;
1937: }
1938:
1939: case d_ec_erreur_instruction_elseif :
1940: {
1941: if ((*s_etat_processus).langue == 'F')
1942: {
1943: chaine = "+++Fatal : Erreur dans une structure ELSEIF";
1944: }
1945: else
1946: {
1947: chaine = "+++Fatal : Error in a ELSEIF structure";
1948: }
1949:
1950: break;
1951: }
1952:
1953: default :
1954: {
1955: if ((*s_etat_processus).langue == 'F')
1956: {
1957: chaine = "+++Fatal : Erreur de compilation";
1958: }
1959: else
1960: {
1961: chaine = "+++Fatal : compilation error";
1962: }
1963:
1964: break;
1965: }
1966: }
1967: }
1968: else
1969: {
1970: if ((*s_etat_processus).langue == 'F')
1971: {
1972: chaine = "";
1973: }
1974: else
1975: {
1976: chaine = "";
1977: }
1978: }
1979:
1980: if (argument == NULL)
1981: {
1982: if ((message = malloc((strlen(chaine) + 1) * sizeof(unsigned char)))
1983: == NULL)
1984: {
1985: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1986: return NULL;
1987: }
1988:
1989: strcpy(message, chaine);
1990: }
1991: else
1992: {
1993: if (erreur_fonction_externe == d_faux)
1994: {
1995: if ((message = malloc((strlen(chaine) + strlen(argument) - 1) *
1996: sizeof(unsigned char))) == NULL)
1997: {
1998: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1999: return NULL;
2000: }
2001:
2002: sprintf(message, chaine, argument);
2003: }
2004: else
2005: {
2006: if ((message = malloc((strlen(chaine) + strlen(argument) + 64
2007: - 1) * sizeof(unsigned char))) == NULL)
2008: {
2009: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2010: return NULL;
2011: }
2012:
2013: sprintf(message, chaine, argument,
2014: (*s_etat_processus).derniere_erreur_fonction_externe);
2015: }
2016: }
2017:
2018: return(message);
2019: }
2020:
2021: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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