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