1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.10
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 -1 : // Fonction externe
1215: {
1216: if ((*s_etat_processus).langue == 'F')
1217: {
1218: chaine = "+++Erreur : Fonction dynamique %s (ligne %lld)";
1219: argument = (*s_etat_processus).instruction_derniere_erreur;
1220: erreur_fonction_externe = d_vrai;
1221: }
1222: else
1223: {
1224: chaine = "+++Error : %s dynamic function (line %lld)";
1225: argument = (*s_etat_processus).instruction_derniere_erreur;
1226: erreur_fonction_externe = d_vrai;
1227: }
1228:
1229: break;
1230: }
1231:
1232: default :
1233: {
1234: if ((*s_etat_processus).langue == 'F')
1235: {
1236: chaine = "+++Erreur : Erreur d'exécution";
1237: }
1238: else
1239: {
1240: chaine = "+++Error : Execution error";
1241: }
1242:
1243: break;
1244: }
1245: }
1246: }
1247: else if ((*s_etat_processus).erreur_systeme != d_es)
1248: {
1249: (*s_etat_processus).derniere_erreur_systeme =
1250: (*s_etat_processus).erreur_systeme;
1251:
1252: /*
1253: --------------------------------------------------------------------------------
1254: Erreurs dues au système et au séquenceur
1255: --------------------------------------------------------------------------------
1256: */
1257:
1258: switch((*s_etat_processus).erreur_systeme)
1259: {
1260: case d_es_allocation_memoire :
1261: {
1262: if ((*s_etat_processus).langue == 'F')
1263: {
1264: chaine = "+++Système : Erreur d'allocation mémoire";
1265: }
1266: else
1267: {
1268: chaine = "+++System : Memory allocation error";
1269: }
1270:
1271: break;
1272: }
1273:
1274: case d_es_variable_introuvable :
1275: {
1276: if ((*s_etat_processus).langue == 'F')
1277: {
1278: chaine = "+++Système : Variable non définie";
1279: }
1280: else
1281: {
1282: chaine = "+++System : Undefined variable";
1283: }
1284:
1285: break;
1286: }
1287:
1288: case d_es_pile_vide :
1289: {
1290: if ((*s_etat_processus).langue == 'F')
1291: {
1292: chaine = "+++Système : Pile système vide";
1293: }
1294: else
1295: {
1296: chaine = "+++System : Empty system stack";
1297: }
1298:
1299: break;
1300: }
1301:
1302: case d_es_pile_operationnelle_vide :
1303: {
1304: if ((*s_etat_processus).langue == 'F')
1305: {
1306: chaine = "+++Système : Pile vide";
1307: }
1308: else
1309: {
1310: chaine = "+++System : Empty stack";
1311: }
1312:
1313: break;
1314: }
1315:
1316: case d_es_end_incoherent :
1317: {
1318: if ((*s_etat_processus).langue == 'F')
1319: {
1320: chaine = "+++Système : Instruction END incohérente";
1321: }
1322: else
1323: {
1324: chaine = "+++Systeme : Incoherent END instruction";
1325: }
1326:
1327: break;
1328: }
1329:
1330: case d_es_peripherique_stdin :
1331: {
1332: if ((*s_etat_processus).langue == 'F')
1333: {
1334: chaine = "+++Système : Erreur de lecture sur stdin";
1335: }
1336: else
1337: {
1338: chaine = "+++System : Read error on stdin";
1339: }
1340:
1341: break;
1342: }
1343:
1344: case d_es_erreur_fichier :
1345: {
1346: if ((*s_etat_processus).langue == 'F')
1347: {
1348: chaine = "+++Système : Erreur d'entrée/sortie sur un"
1349: " fichier";
1350: }
1351: else
1352: {
1353: chaine = "+++System : File input/output error";
1354: }
1355:
1356: break;
1357: }
1358:
1359: case d_es_execution_bibliotheque :
1360: {
1361: if ((*s_etat_processus).langue == 'F')
1362: {
1363: chaine = "+++Système : Problème lors de l'exécution "
1364: "d'une fonction externe";
1365: }
1366: else
1367: {
1368: chaine = "+++System : Extern function execution error";
1369: }
1370:
1371: break;
1372: }
1373:
1374: case d_es_signal :
1375: {
1376: if ((*s_etat_processus).langue == 'F')
1377: {
1378: chaine = "+++Système : Problème de gestion de signaux "
1379: "POSIX";
1380: }
1381: else
1382: {
1383: chaine = "+++System : POSIX signal error";
1384: }
1385:
1386: break;
1387: }
1388:
1389: case d_es_processus :
1390: {
1391: if ((*s_etat_processus).langue == 'F')
1392: {
1393: chaine = "+++Système : Erreur dans la gestion des"
1394: " processus";
1395: }
1396: else
1397: {
1398: chaine = "+++System : Process management error";
1399: }
1400:
1401: break;
1402: }
1403:
1404: case d_es_nombre_max_descripteurs :
1405: {
1406: if ((*s_etat_processus).langue == 'F')
1407: {
1408: chaine = "+++Système : Nombre maximal de descripteurs"
1409: " de fichiers atteint";
1410: }
1411: else
1412: {
1413: chaine = "+++System : Too much file descriptors";
1414: }
1415:
1416: break;
1417: }
1418:
1419: case d_es_interruption_invalide :
1420: {
1421: if ((*s_etat_processus).langue == 'F')
1422: {
1423: chaine = "+++Système : Interruption invalide";
1424: }
1425: else
1426: {
1427: chaine = "+++System : Unavailable interrupt";
1428: }
1429:
1430: break;
1431: }
1432:
1433: case d_es_contexte :
1434: {
1435: if ((*s_etat_processus).langue == 'F')
1436: {
1437: chaine = "+++Système : Erreur dans la gestion des"
1438: " contextes";
1439: }
1440: else
1441: {
1442: chaine = "+++System : Context management error";
1443: }
1444:
1445: break;
1446: }
1447:
1448: case -1 : // Fonction externe
1449: {
1450: if ((*s_etat_processus).langue == 'F')
1451: {
1452: chaine = "+++Système : Fonction dynamique %s (ligne %lld)";
1453: argument = (*s_etat_processus).instruction_derniere_erreur;
1454: erreur_fonction_externe = d_vrai;
1455: }
1456: else
1457: {
1458: chaine = "+++System : %s dynamic function (line %lld)";
1459: argument = (*s_etat_processus).instruction_derniere_erreur;
1460: erreur_fonction_externe = d_vrai;
1461: }
1462:
1463: break;
1464: }
1465:
1466: default :
1467: {
1468: if ((*s_etat_processus).langue == 'F')
1469: {
1470: chaine = "+++Système : Erreur interne";
1471: }
1472: else
1473: {
1474: chaine = "+++System : Internal error";
1475: }
1476:
1477: break;
1478: }
1479: }
1480: }
1481: else if ((*s_etat_processus).exception != d_ep)
1482: {
1483: (*s_etat_processus).derniere_exception =
1484: (*s_etat_processus).exception;
1485:
1486: /*
1487: --------------------------------------------------------------------------------
1488: Exceptions mathématiques
1489: --------------------------------------------------------------------------------
1490: */
1491:
1492: switch((*s_etat_processus).exception)
1493: {
1494: case d_ep_division_par_zero :
1495: {
1496: if ((*s_etat_processus).langue == 'F')
1497: {
1498: chaine = "+++Exception : Division par zéro";
1499: }
1500: else
1501: {
1502: chaine = "+++Exception : Division by zero";
1503: }
1504:
1505: break;
1506: }
1507:
1508: case d_ep_matrice_non_inversible :
1509: {
1510: if ((*s_etat_processus).langue == 'F')
1511: {
1512: chaine = "+++Exception : Matrice non inversible";
1513: }
1514: else
1515: {
1516: chaine = "+++Exception : Non inversible matrix";
1517: }
1518:
1519: break;
1520: }
1521:
1522: case d_ep_resultat_indefini :
1523: {
1524: if ((*s_etat_processus).langue == 'F')
1525: {
1526: chaine = "+++Exception : Résultat indéfini";
1527: }
1528: else
1529: {
1530: chaine = "+++Exception : Undefined result";
1531: }
1532:
1533: break;
1534: }
1535:
1536: case d_ep_underflow :
1537: {
1538: if ((*s_etat_processus).langue == 'F')
1539: {
1540: chaine = "+++Exception : Dépassement de capacité"
1541: " (underflow)";
1542: }
1543: else
1544: {
1545: chaine = "+++Exception : Underflow exception";
1546: }
1547:
1548: break;
1549: }
1550:
1551: case d_ep_overflow :
1552: {
1553: if ((*s_etat_processus).langue == 'F')
1554: {
1555: chaine = "+++Exception : Dépassement de capacité"
1556: " (overflow)";
1557: }
1558: else
1559: {
1560: chaine = "+++Exception : Overflow exception";
1561: }
1562:
1563: break;
1564: }
1565:
1566: case d_ep_domaine_definition :
1567: {
1568: if ((*s_etat_processus).langue == 'F')
1569: {
1570: chaine = "+++Exception : Domaine de définition";
1571: }
1572: else
1573: {
1574: chaine = "+++Exception : Domain exception";
1575: }
1576:
1577: break;
1578: }
1579:
1580: case d_ep_perte_precision :
1581: {
1582: if ((*s_etat_processus).langue == 'F')
1583: {
1584: chaine = "+++Exception : Perte de précision";
1585: }
1586: else
1587: {
1588: chaine = "+++Exception : Loss of precision";
1589: }
1590:
1591: break;
1592: }
1593:
1594: case d_ep_decomposition_QR :
1595: {
1596: if ((*s_etat_processus).langue == 'F')
1597: {
1598: chaine = "+++Exception : Décomposition QR impossible";
1599: }
1600: else
1601: {
1602: chaine = "+++Exception : QR decomposition failed";
1603: }
1604:
1605: break;
1606: }
1607:
1608: case d_ep_matrice_non_definie_positive :
1609: {
1610: if ((*s_etat_processus).langue == 'F')
1611: {
1612: chaine = "+++Exception : Matrice non définie positive";
1613: }
1614: else
1615: {
1616: chaine = "+++Exception : Non positive defined matrix";
1617: }
1618:
1619: break;
1620: }
1621:
1622: case d_ep_decomposition_QZ :
1623: {
1624: if ((*s_etat_processus).langue == 'F')
1625: {
1626: chaine = "+++Exception : Décomposition QZ impossible";
1627: }
1628: else
1629: {
1630: chaine = "+++Exception : QZ decomposition failed";
1631: }
1632:
1633: break;
1634: }
1635:
1636: case d_ep_decomposition_SVD :
1637: {
1638: if ((*s_etat_processus).langue == 'F')
1639: {
1640: chaine = "+++Exception : Décomposition SVD impossible";
1641: }
1642: else
1643: {
1644: chaine = "+++Exception : SVD decomposition failed";
1645: }
1646:
1647: break;
1648: }
1649:
1650: default :
1651: {
1652: if ((*s_etat_processus).langue == 'F')
1653: {
1654: chaine = "+++Exception : Exception mathématique";
1655: }
1656: else
1657: {
1658: chaine = "+++Exception : Mathematical exception";
1659: }
1660:
1661: break;
1662: }
1663: }
1664: }
1665: else if ((*s_etat_processus).erreur_compilation != d_ec)
1666: {
1667:
1668: /*
1669: --------------------------------------------------------------------------------
1670: Erreurs de compilation
1671: --------------------------------------------------------------------------------
1672: */
1673:
1674: switch((*s_etat_processus).erreur_compilation)
1675: {
1676: case d_ec_niveau_definition_negatif :
1677: {
1678: if ((*s_etat_processus).langue == 'F')
1679: {
1680: chaine = "+++Fatal : Niveau de définition négatif";
1681: }
1682: else
1683: {
1684: chaine = "+++Fatal : Negative definition level";
1685: }
1686:
1687: break;
1688: }
1689:
1690: case d_ec_nom_definition_invalide :
1691: {
1692: if ((*s_etat_processus).langue == 'F')
1693: {
1694: chaine = "+++Fatal : Nom de définition invalide";
1695: }
1696: else
1697: {
1698: chaine = "+++Fatal : Invalid definition name";
1699: }
1700:
1701: break;
1702: }
1703:
1704: case d_ec_erreur_boucle_definie :
1705: {
1706: if ((*s_etat_processus).langue == 'F')
1707: {
1708: chaine = "+++Fatal : Définition illégale "
1709: "d'une boucle définie";
1710: }
1711: else
1712: {
1713: chaine = "+++Fatal : Illegal use of a defined loop";
1714: }
1715:
1716: break;
1717: }
1718:
1719: case d_ec_erreur_instruction_end :
1720: {
1721: if ((*s_etat_processus).langue == 'F')
1722: {
1723: chaine = "+++Fatal : Erreur dans une structure terminée "
1724: "par l'instruction END";
1725: }
1726: else
1727: {
1728: chaine = "+++Fatal : Error in an END-closed structure";
1729: }
1730:
1731: break;
1732: }
1733:
1734: case d_ec_erreur_instruction_until :
1735: {
1736: if ((*s_etat_processus).langue == 'F')
1737: {
1738: chaine = "+++Fatal : Erreur dans une boucle DO/UNTIL/END";
1739: }
1740: else
1741: {
1742: chaine = "+++Fatal : Error in a DO/UNTIL/END loop";
1743: }
1744:
1745: break;
1746: }
1747:
1748: case d_ec_source_incoherent :
1749: {
1750: if ((*s_etat_processus).langue == 'F')
1751: {
1752: chaine = "+++Fatal : Définitions incohérentes";
1753: }
1754: else
1755: {
1756: chaine = "+++Fatal : Incoherent definitions";
1757: }
1758:
1759: break;
1760: }
1761:
1762: case d_ec_erreur_instruction_while :
1763: {
1764: if ((*s_etat_processus).langue == 'F')
1765: {
1766: chaine = "+++Fatal : Erreur dans une boucle WHILE/REPEAT/"
1767: "END";
1768: }
1769: else
1770: {
1771: chaine = "+++Fatal : Error in a WHILE/REPEAT/END loop";
1772: }
1773:
1774: break;
1775: }
1776:
1777: case d_ec_erreur_instruction_select :
1778: {
1779: if ((*s_etat_processus).langue == 'F')
1780: {
1781: chaine = "+++Fatal : Erreur dans une structure SELECT"
1782: "/DEFAULT/END";
1783: }
1784: else
1785: {
1786: chaine = "+++Fatal : Error in a SELECT/DEFAULT/END "
1787: "structure";
1788: }
1789:
1790: break;
1791: }
1792:
1793: case d_ec_erreur_instruction_case :
1794: {
1795: if ((*s_etat_processus).langue == 'F')
1796: {
1797: chaine = "+++Fatal : Erreur dans une structure CASE"
1798: "/THEN/END";
1799: }
1800: else
1801: {
1802: chaine = "+++Fatal : Error in a CASE/THEN/END "
1803: "structure";
1804: }
1805:
1806: break;
1807: }
1808:
1809: case d_ec_erreur_instruction_then :
1810: {
1811: if ((*s_etat_processus).langue == 'F')
1812: {
1813: chaine = "+++Fatal : Erreur dans une structure IF, "
1814: "IFERR ou CASE/THEN/END";
1815: }
1816: else
1817: {
1818: chaine = "+++Fatal : Error in a IF, IFERR or "
1819: "CASE/THEN/END structure";
1820: }
1821:
1822: break;
1823: }
1824:
1825: case d_ec_erreur_instruction_else :
1826: {
1827: if ((*s_etat_processus).langue == 'F')
1828: {
1829: chaine = "+++Fatal : Erreur dans une structure ELSE";
1830: }
1831: else
1832: {
1833: chaine = "+++Fatal : Error in a ELSE structure";
1834: }
1835:
1836: break;
1837: }
1838:
1839: case d_ec_erreur_instruction_elseif :
1840: {
1841: if ((*s_etat_processus).langue == 'F')
1842: {
1843: chaine = "+++Fatal : Erreur dans une structure ELSEIF";
1844: }
1845: else
1846: {
1847: chaine = "+++Fatal : Error in a ELSEIF structure";
1848: }
1849:
1850: break;
1851: }
1852:
1853: default :
1854: {
1855: if ((*s_etat_processus).langue == 'F')
1856: {
1857: chaine = "+++Fatal : Erreur de compilation";
1858: }
1859: else
1860: {
1861: chaine = "+++Fatal : compilation error";
1862: }
1863:
1864: break;
1865: }
1866: }
1867: }
1868: else
1869: {
1870: if ((*s_etat_processus).langue == 'F')
1871: {
1872: chaine = "";
1873: }
1874: else
1875: {
1876: chaine = "";
1877: }
1878: }
1879:
1880: if (argument == NULL)
1881: {
1882: if ((message = malloc((strlen(chaine) + 1) * sizeof(unsigned char)))
1883: == NULL)
1884: {
1885: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1886: return NULL;
1887: }
1888:
1889: strcpy(message, chaine);
1890: }
1891: else
1892: {
1893: if (erreur_fonction_externe == d_faux)
1894: {
1895: if ((message = malloc((strlen(chaine) + strlen(argument) - 1) *
1896: sizeof(unsigned char))) == NULL)
1897: {
1898: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1899: return NULL;
1900: }
1901:
1902: sprintf(message, chaine, argument);
1903: }
1904: else
1905: {
1906: if ((message = malloc((strlen(chaine) + strlen(argument) + 64
1907: - 1) * sizeof(unsigned char))) == NULL)
1908: {
1909: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1910: return NULL;
1911: }
1912:
1913: sprintf(message, chaine, argument,
1914: (*s_etat_processus).derniere_erreur_fonction_externe);
1915: }
1916: }
1917:
1918: return(message);
1919: }
1920:
1921: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>