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