home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Misc / CLISP-1.LHA / CLISP960530-sr.lha / src / error.d < prev    next >
Encoding:
Text File  |  1996-07-21  |  112.2 KB  |  2,764 lines

  1. # Error-Handling für CLISP
  2. # Bruno Haible 23.4.1995
  3. # Marcus Daniels 8.4.1994
  4.  
  5. #include "lispbibl.c"
  6.  
  7.  
  8. # SYS::*RECURSIVE-ERROR-COUNT* = Rekursionstiefe der Ausgabe von Errormeldungen
  9.  
  10. # UP: Beginnt die Ausgabe einer Errormeldung.
  11. # begin_error()
  12. # < STACK_0: Stream (i.a. *ERROR-OUTPUT*)
  13. # < STACK_1: Wert von *error-handler*
  14. # < STACK_2: Argumentliste für *error-handler*
  15. # < STACK_3: Condition-Typ (i.a. SIMPLE-ERROR) oder NIL
  16. # erniedrigt STACK um 7
  17.   local void begin_error (void);
  18.   local void begin_error()
  19.     { end_system_call(); # keine Betriebssystem-Operation läuft mehr
  20.       #ifdef PENDING_INTERRUPTS
  21.       interrupt_pending = FALSE; # Ctrl-C-Wartezeit ist gleich beendet
  22.       begin_system_call();
  23.       #ifdef HAVE_UALARM
  24.       ualarm(0,0); # SIGALRM-Timer abbrechen
  25.       #else
  26.       #ifdef EMUNIX_OLD_8h # EMX-Bug umgehen
  27.       alarm(1000);
  28.       #endif
  29.       alarm(0); # SIGALRM-Timer abbrechen
  30.       #endif
  31.       end_system_call();
  32.       #endif
  33.       # Error-Count erhöhen, bei >3 Ausgabe-Abbruch:
  34.       dynamic_bind(S(recursive_error_count),fixnum_inc(Symbol_value(S(recursive_error_count)),1));
  35.       if (!sym_posfixnump(S(recursive_error_count))) # sollte ein Fixnum >=0 sein
  36.         { set_Symbol_value(S(recursive_error_count),Fixnum_0); } # sonst Notkorrektur
  37.       if (posfixnum_to_L(Symbol_value(S(recursive_error_count))) > 3)
  38.         { # Mehrfach verschachtelte Fehlermeldung.
  39.           set_Symbol_value(S(recursive_error_count),Fixnum_0); # Error-Count löschen
  40.           # *PRINT-PRETTY* an NIL binden (um Speicher zu sparen):
  41.           dynamic_bind(S(print_pretty),NIL);
  42.           //: DEUTSCH "Unausgebbare Fehlermeldung"
  43.           //: ENGLISH "Unprintable error message"
  44.           //: FRANCAIS "Message inimprimable"
  45.           fehler(serious_condition,GETTEXT("Unprintable error message"));
  46.         }
  47.      {var reg1 object error_handler = Symbol_value(S(error_handler)); # *ERROR-HANDLER*
  48.       if (!nullp(error_handler))
  49.         # *ERROR-HANDER* /= NIL
  50.         { pushSTACK(NIL); pushSTACK(NIL); pushSTACK(error_handler);
  51.           pushSTACK(make_string_output_stream()); # String-Output-Stream
  52.         }
  53.         else
  54.         if (sym_nullp(S(use_clcs))) # SYS::*USE-CLCS*
  55.           # *ERROR-HANDER* = NIL, SYS::*USE-CLCS* = NIL
  56.           { pushSTACK(NIL); pushSTACK(NIL); pushSTACK(NIL);
  57.             pushSTACK(var_stream(S(error_output),strmflags_wr_ch_B)); # Stream *ERROR-OUTPUT*
  58.             terpri(&STACK_0); # neue Zeile
  59.             write_sstring(&STACK_0,O(error_string1)); # "*** - " ausgeben
  60.           }
  61.           else
  62.           # *ERROR-HANDER* = NIL, SYS::*USE-CLCS* /= NIL
  63.           { pushSTACK(S(simple_error)); pushSTACK(NIL); pushSTACK(unbound);
  64.             pushSTACK(make_string_output_stream()); # String-Output-Stream
  65.           }
  66.     }}
  67.  
  68. # UP: Gibt ein Error-Objekt aus.
  69.   local void write_errorobject (object obj);
  70.   local void write_errorobject(obj)
  71.     var reg1 object obj;
  72.     { if (nullp(STACK_1))
  73.         { dynamic_bind(S(prin_stream),unbound); # SYS::*PRIN-STREAM* an #<UNBOUND> binden
  74.           dynamic_bind(S(print_escape),T); # *PRINT-ESCAPE* an T binden
  75.           prin1(&STACK_(0+DYNBIND_SIZE+DYNBIND_SIZE),obj); # direkt ausgeben
  76.           dynamic_unbind();
  77.           dynamic_unbind();
  78.         }
  79.         else
  80.         { # obj auf die Argumentliste schieben:
  81.           pushSTACK(obj);
  82.           obj = allocate_cons();
  83.           Car(obj) = popSTACK();
  84.           Cdr(obj) = STACK_2; STACK_2 = obj;
  85.           # und "~S" in den Format-String schreiben:
  86.           write_schar(&STACK_0,'~'); write_schar(&STACK_0,'S');
  87.     }   }
  88.  
  89. # UP: Gibt ein Error-Character aus.
  90.   local void write_errorchar (object obj);
  91.   local void write_errorchar(obj)
  92.     var reg1 object obj;
  93.     { if (nullp(STACK_1))
  94.         { write_char(&STACK_0,obj); } # direkt ausgeben
  95.         else
  96.         { # obj auf die Argumentliste schieben:
  97.           pushSTACK(obj);
  98.           obj = allocate_cons();
  99.           Car(obj) = popSTACK();
  100.           Cdr(obj) = STACK_2; STACK_2 = obj;
  101.           # und "~A" in den Format-String schreiben:
  102.           write_schar(&STACK_0,'~'); write_schar(&STACK_0,'A');
  103.     }   }
  104.  
  105. # UP: Gibt einen Errorstring aus. Bei jeder Tilde '~' wird ein Objekt aus dem
  106. # Stack ausgegeben, bei jedem '$' wird ein Character aus dem Stack ausgegeben.
  107. # write_errorstring(errorstring)
  108. # > STACK_0: Stream usw.
  109. # > errorstring: Errorstring (ein unverschieblicher ASCIZ-String)
  110. # > STACK_7, STACK_8, ...: Argumente (für jedes '~' bzw. '$' eines),
  111. #   in umgekehrter Reihenfolge wie bei FUNCALL !
  112. # < ergebnis: STACK-Wert oberhalb des Stream und der Argumente
  113.   local object* write_errorstring (const char* errorstring);
  114.   local object* write_errorstring(errorstring)
  115.     var reg1 const char* errorstring;
  116.     { var reg2 object* argptr = args_end_pointer STACKop (4+DYNBIND_SIZE); # Pointer übern Stream und Frame
  117.       loop
  118.         { var reg3 uintB ch = *errorstring++; # nächstes Zeichen
  119.           if (ch==0) break; # String zu Ende?
  120.           if (ch=='~') # Tilde?
  121.             # ja -> ein Objekt vom Stack ausgeben:
  122.             { write_errorobject(BEFORE(argptr)); }
  123.           elif (ch=='$') # '$' ?
  124.             # ja -> ein Character vom Stack ausgeben:
  125.             { write_errorchar(BEFORE(argptr)); }
  126.           else
  127.             # nein -> Zeichen normal ausgeben:
  128.             { write_char(&STACK_0,code_char(ch)); }
  129.         }
  130.       return argptr;
  131.     }
  132.  
  133. # Beendet die Ausgabe einer Fehlermeldung und startet neuen Driver.
  134. # end_error();
  135.   nonreturning_function(local, end_error, (object* stackptr));
  136.   local void end_error(stackptr)
  137.     var reg2 object* stackptr;
  138.     { if (nullp(STACK_1))
  139.         # *ERROR-HANDER* = NIL, SYS::*USE-CLCS* = NIL
  140.         { skipSTACK(4); # Fehlermeldung wurde schon ausgegeben
  141.           dynamic_unbind(); # Bindungsframe für sys::*recursive-error-count* auflösen,
  142.                             # da keine Fehlermeldungs-Ausgabe mehr aktiv
  143.           set_args_end_pointer(stackptr);
  144.           break_driver(NIL); # Break-Driver aufrufen (kehrt nicht zurück)
  145.         }
  146.         else
  147.         { STACK_0 = get_output_stream_string(&STACK_0);
  148.          {var reg4 object arguments = nreverse(STACK_2);
  149.           # Stackaufbau: type, args, handler, errorstring.
  150.           if (!eq(STACK_1,unbound))
  151.             # *ERROR-HANDER* /= NIL
  152.             { # Stackaufbau: nil, args, handler, errorstring.
  153.               # (apply *error-handler* nil errorstring args) ausführen:
  154.               check_SP(); check_STACK();
  155.               {var reg1 object error_handler = STACK_1; STACK_1 = NIL;
  156.                apply(error_handler,2,arguments);
  157.                skipSTACK(2);
  158.               }
  159.               dynamic_unbind(); # Bindungsframe für sys::*recursive-error-count* auflösen,
  160.                                 # da keine Fehlermeldungs-Ausgabe mehr aktiv
  161.               set_args_end_pointer(stackptr);
  162.               break_driver(NIL); # Break-Driver aufrufen (kehrt nicht zurück)
  163.             }
  164.             else
  165.             # *ERROR-HANDER* = NIL, SYS::*USE-CLCS* /= NIL
  166.             { # Stackaufbau: type, args, --, errorstring.
  167.               var reg1 object type = STACK_3;
  168.               var reg5 object errorstring = STACK_0;
  169.               skipSTACK(4);
  170.               dynamic_unbind(); # Bindungsframe für sys::*recursive-error-count* auflösen
  171.               # (APPLY #'coerce-to-condition errorstring args 'error type keyword-arguments)
  172.               # ausführen:
  173.               pushSTACK(errorstring); pushSTACK(arguments); pushSTACK(S(error)); pushSTACK(type);
  174.              {var reg3 uintC argcount = 4;
  175.               # arithmetic-error, division-by-zero, floating-point-overflow, floating-point-underflow
  176.               #   --> ergänze :operation :operands ??
  177.               # cell-error, uncound-variable, undefined-function
  178.               #   --> ergänze :name
  179.               if (eq(type,S(simple_cell_error))
  180.                   || eq(type,S(simple_unbound_variable))
  181.                   || eq(type,S(simple_undefined_function))
  182.                  )
  183.                 { pushSTACK(S(Kname)); pushSTACK(BEFORE(stackptr)); # :name ...
  184.                   argcount += 2;
  185.                 }
  186.               # type-error --> ergänze :datum, :expected-type
  187.               if (eq(type,S(simple_type_error)))
  188.                 { pushSTACK(S(Kexpected_type)); pushSTACK(BEFORE(stackptr)); # :expected-type ...
  189.                   pushSTACK(S(Kdatum)); pushSTACK(BEFORE(stackptr)); # :datum ...
  190.                   argcount += 4;
  191.                 }
  192.               # package-error --> ergänze :package
  193.               if (eq(type,S(simple_package_error)))
  194.                 { pushSTACK(S(Kpackage)); pushSTACK(BEFORE(stackptr)); # :package ...
  195.                   argcount += 2;
  196.                 }
  197.               # print-not-readable --> ergänze :object
  198.               if (eq(type,S(simple_print_not_readable)))
  199.                 { pushSTACK(S(Kobject)); pushSTACK(BEFORE(stackptr)); # :object
  200.                   argcount += 2;
  201.                 }
  202.               # stream-error, end-of-file --> ergänze :stream
  203.               if (eq(type,S(simple_stream_error))
  204.                   || eq(type,S(simple_end_of_file))
  205.                  )
  206.                 { pushSTACK(S(Kstream)); pushSTACK(BEFORE(stackptr)); # :stream ...
  207.                   argcount += 2;
  208.                 }
  209.               # file-error --> ergänze :pathname
  210.               if (eq(type,S(simple_file_error)))
  211.                 { pushSTACK(S(Kpathname)); pushSTACK(BEFORE(stackptr)); # :pathname ...
  212.                   argcount += 2;
  213.                 }
  214.               funcall(S(coerce_to_condition),argcount); # (SYS::COERCE-TO-CONDITION ...)
  215.               # set_args_end_pointer(stackptr); # wozu? macht das Debuggen nur schwieriger!
  216.               pushSTACK(value1); # condition retten
  217.               pushSTACK(value1); funcall(L(clcs_signal),1); # (SIGNAL condition)
  218.               dynamic_bind(S(prin_stream),unbound); # SYS::*PRIN-STREAM* an #<UNBOUND> binden
  219.               pushSTACK(STACK_(0+DYNBIND_SIZE)); # condition
  220.               funcall(L(invoke_debugger),1); # (INVOKE-DEBUGGER condition)
  221.             }}
  222.         }}
  223.       NOTREACHED
  224.     }
  225.  
  226. # Fehlermeldung mit Errorstring. Kehrt nicht zurück.
  227. # fehler(errortype,errorstring);
  228. # > errortype: Condition-Typ
  229. # > errorstring: Konstanter ASCIZ-String.
  230. #   Bei jeder Tilde wird ein LISP-Objekt vom STACK genommen und statt der
  231. #   Tilde ausgegeben.
  232. # > auf dem STACK: Initialisierungswerte für die Condition, je nach errortype
  233.   nonreturning_function(global, fehler, (conditiontype errortype, const char * errorstring));
  234.   global void fehler(errortype,errorstring)
  235.     var reg2 conditiontype errortype;
  236.     var reg1 const char * errorstring;
  237.     { begin_error(); # Fehlermeldung anfangen
  238.       if (!nullp(STACK_3)) # *ERROR-HANDLER* = NIL, SYS::*USE-CLCS* /= NIL ?
  239.         { # Error-Typ-Symbol zu errortype auswählen:
  240.           var reg3 object sym = S(simple_condition); # erster Error-Typ
  241.           sym = objectplus(sym,
  242.                            (soint)(sizeof(*TheSymbol(sym))<<(oint_addr_shift-addr_shift))
  243.                            * (uintL)errortype
  244.                           );
  245.           STACK_3 = sym;
  246.         }
  247.       end_error(write_errorstring(errorstring)); # Fehlermeldung ausgeben, beenden
  248.     }
  249.  
  250.   nonreturning_function(global, fehler3, (conditiontype errortype, const char *arg1,const char *arg2,const char *arg3));
  251.   global void fehler3 (errortype, arg1,arg2,arg3)
  252.     var conditiontype errortype;
  253.     var reg7 const char *arg1;
  254.     var reg6 const char *arg2;
  255.     var reg5 const char *arg3;
  256.     {
  257.       var reg4 uintL count1 = asciz_length(arg1);
  258.       var reg3 uintL count2 = asciz_length(arg2);
  259.       var reg2 uintL count3 = asciz_length(arg3);
  260.       var DYNAMIC_ARRAY(auto,cbuf,char,count1+count2+count3+1); 
  261.       var reg1 char *buf;
  262.       buf = cbuf;
  263.       dotimesL(count1,count1, { *buf++ = *arg1++; });
  264.       dotimesL(count2,count2, { *buf++ = *arg2++; });
  265.       dotimesL(count3,count3, { *buf++ = *arg3++; });
  266.       *buf = '\0';
  267.       fehler(errortype,cbuf);
  268.     }
  269.  
  270.   nonreturning_function(global, fehler4, (conditiontype errortype, const char *arg1,const char *arg2,const char *arg3, const char *arg4));
  271.   global void fehler4 (errortype, arg1,arg2,arg3,arg4)
  272.     var conditiontype errortype;
  273.     var reg9 const char *arg1;
  274.     var reg8 const char *arg2;
  275.     var reg7 const char *arg3;
  276.     var reg6 const char *arg4;
  277.     {
  278.       var reg5 uintL count1 = asciz_length(arg1);
  279.       var reg4 uintL count2 = asciz_length(arg2);
  280.       var reg3 uintL count3 = asciz_length(arg3);
  281.       var reg2 uintL count4 = asciz_length(arg4);
  282.       var DYNAMIC_ARRAY(auto,cbuf,char,count1+count2+count3+count4+1); 
  283.       var reg1 char *buf;
  284.       buf = cbuf;
  285.       dotimesL(count1,count1, { *buf++ = *arg1++;});
  286.       dotimesL(count2,count2, { *buf++ = *arg2++; });
  287.       dotimesL(count3,count3, { *buf++ = *arg3++; });
  288.       dotimesL(count4,count4, { *buf++ = *arg4++; });
  289.       *buf = '\0';
  290.       fehler(errortype,cbuf);
  291.     }
  292.  
  293.   nonreturning_function(global, fehler5, (conditiontype errortype, const char *arg1,const char *arg2,const char *arg3, const char *arg4, const char *arg5));
  294.   global void fehler5 (errortype, arg1,arg2,arg3,arg4, arg5)
  295.     var conditiontype errortype;
  296.     var reg10 const char *arg1;
  297.     var reg9 const char *arg2;
  298.     var reg8 const char *arg3;
  299.     var reg7 const char *arg4;
  300.     var const char *arg5;
  301.     {
  302.       var reg6 uintL count1 = asciz_length(arg1);
  303.       var reg5 uintL count2 = asciz_length(arg2);
  304.       var reg4 uintL count3 = asciz_length(arg3);
  305.       var reg3 uintL count4 = asciz_length(arg4);
  306.       var reg2 uintL count5 = asciz_length(arg5);
  307.       var DYNAMIC_ARRAY(auto,cbuf,char,count1+count2+count3+count4+count5+1); 
  308.       var reg1 char *buf;
  309.       buf = cbuf;
  310.       dotimesL(count1,count1, { *buf++ = *arg1++;});
  311.       dotimesL(count2,count2, { *buf++ = *arg2++; });
  312.       dotimesL(count3,count3, { *buf++ = *arg3++; });
  313.       dotimesL(count4,count4, { *buf++ = *arg4++; });
  314.       dotimesL(count5,count5, { *buf++ = *arg5++; });
  315.       *buf = '\0';
  316.       fehler(errortype,cbuf);
  317.     }
  318.  
  319. #ifdef AMIGAOS
  320.   # Behandlung von AMIGAOS-Fehlern
  321.   # OS_error_();
  322.   # > IoErr(): Fehlercode
  323.     nonreturning_function(global, OS_error_, (void));
  324.  
  325.   # Tabelle der Fehlermeldungen und ihrer Namen:
  326.     local const char* error100_msg_table[23][2];
  327.     local const char* error200_msg_table[44][2];
  328.     local const char* error300_msg_table[6][2];
  329.  
  330.   # Initialisierung der Tabelle:
  331.     global int init_errormsg_table (void);
  332.     global int init_errormsg_table()
  333.       {
  334.         # A remanescence of pre-gettext times
  335.         #ifdef LANGUAGE_STATIC
  336.           #define lang3(english,deutsch,francais)  ENGLISH ? english : DEUTSCH ? deutsch : FRANCAIS ? francais : ""
  337.           #define lang1(string)  string
  338.           #define langcount  1
  339.           #define language  0
  340.         #else
  341.           #define lang3(english,deutsch,francais)  english, deutsch, francais
  342.           #define lang1(string)  string, string, string
  343.           #define langcount  3
  344.         #endif
  345.         error100_msg_table[0][0]=""; error100_msg_table[0][1]="";
  346.         error100_msg_table[1][0]=""; error100_msg_table[1][1]="";
  347.         error100_msg_table[2][0]=""; error100_msg_table[2][1]="";
  348.  
  349.         error100_msg_table[3][0]="ERROR_NO_FREE_STORE";
  350.         //: DEUTSCH "nicht genügend Speicher vorhanden"
  351.         //: ENGLISH "not enough memory available"
  352.         //: FRANCAIS "Pas assez de mémoire"
  353.         error100_msg_table[3][1]=GETTEXT("not enough memory available");
  354.  
  355.         error100_msg_table[4][0]=""; error100_msg_table[4][1]="";
  356.  
  357.         error100_msg_table[5][0]="ERROR_TASK_TABLE_FULL";
  358.         //: DEUTSCH "keine weiteren CLI Prozesse mehr"
  359.         //: ENGLISH "process table full"
  360.         //: FRANCAIS "La table des processus est pleine"
  361.         error100_msg_table[5][1]=GETTEXT("process table full");
  362.  
  363.         error100_msg_table[6][0]=""; error100_msg_table[6][1]="";
  364.         error100_msg_table[7][0]=""; error100_msg_table[7][1]="";
  365.         error100_msg_table[8][0]=""; error100_msg_table[8][1]="";
  366.         error100_msg_table[9][0]=""; error100_msg_table[9][1]="";
  367.         error100_msg_table[10][0]=""; error100_msg_table[10][1]="";
  368.         error100_msg_table[11][0]=""; error100_msg_table[11][1]="";
  369.         error100_msg_table[12][0]=""; error100_msg_table[12][1]="";
  370.         error100_msg_table[13][0]=""; error100_msg_table[13][1]="";
  371.  
  372.         error100_msg_table[14][0]="ERROR_BAD_TEMPLATE";
  373.         //: DEUTSCH "ungültiges Muster"
  374.         //: ENGLISH "bad template"
  375.         //: FRANCAIS "mauvais schéma"
  376.         error100_msg_table[14][1]=GETTEXT("bad template");
  377.  
  378.         error100_msg_table[15][0]="ERROR_BAD_NUMBER";
  379.         //: DEUTSCH "ungültige Zahl"
  380.         //: ENGLISH "bad number"
  381.         //: FRANCAIS "mauvais nombre"
  382.         error100_msg_table[15][1]=GETTEXT("bad number");
  383.  
  384.         error100_msg_table[16][0]="ERROR_REQUIRED_ARG_MISSING";
  385.         //: DEUTSCH "benötigtes Schlüsselwort nicht vorhanden"
  386.         //: ENGLISH "required argument missing"
  387.         //: FRANCAIS "mot clé manque"
  388.         error100_msg_table[16][1]=GETTEXT("required argument missing");
  389.  
  390.         error100_msg_table[17][0]="ERROR_KEY_NEEDS_ARG";
  391.         //: DEUTSCH "kein Wert nach Schlüsselwort vorhanden"
  392.         //: ENGLISH "value after keyword missing"
  393.         //: FRANCAIS "mot clé sans valeur"
  394.         error100_msg_table[17][1]=GETTEXT("value after keyword missing");
  395.  
  396.         error100_msg_table[18][0]="ERROR_TOO_MANY_ARGS";
  397.         //: DEUTSCH "falsche Anzahl Argumente"
  398.         //: ENGLISH "wrong number of arguments"
  399.         //: FRANCAIS "mauvais nombre d'arguments"
  400.         error100_msg_table[18][1]=GETTEXT("wrong number of arguments");
  401.  
  402.         error100_msg_table[19][0]="ERROR_UNMATCHED_QUOTES";
  403.         //: DEUTSCH "ausstehende Anführungszeichen"
  404.         //: ENGLISH "unmatched quotes"
  405.         //: FRANCAIS "guillemets non terminés"
  406.         error100_msg_table[19][1]=GETTEXT("unmatched quotes");
  407.  
  408.         error100_msg_table[20][0]="ERROR_LINE_TOO_LONG";
  409.         //: DEUTSCH "ungültige Zeile oder Zeile zu lang"
  410.         //: ENGLISH "argument line invalid or too long"
  411.         //: FRANCAIS "ligne est mauvaise ou trop longue"
  412.         error100_msg_table[20][1]="argument line invalid or too long";
  413.  
  414.         error100_msg_table[21][0]="ERROR_FILE_NOT_OBJECT";
  415.         //: DEUTSCH "Datei ist nicht ausführbar"
  416.         //: ENGLISH "file is not executable"
  417.         //: FRANCAIS "fichier non exécutable"
  418.         error100_msg_table[21][1]=GETTEXT("file is not executable");
  419.  
  420.         error100_msg_table[22][0]="ERROR_INVALID_RESIDENT_LIBRARY";
  421.         //: DEUTSCH "ungültige residente Library"
  422.         //: ENGLISH "invalid resident library"
  423.         //: FRANCAIS "Librarie résidente non valide"
  424.         error100_msg_table[22][1]=GETTEXT("invalid resident library");
  425.  
  426.         error200_msg_table[0][0]=""; error200_msg_table[0][1]="";
  427.         
  428.         error200_msg_table[1][0]="ERROR_NO_DEFAULT_DIR";
  429.         error200_msg_table[1][1]="";
  430.  
  431.         error200_msg_table[2][0]="ERROR_OBJECT_IN_USE";
  432.         //: DEUTSCH "Objekt wird schon benutzt"
  433.         //: ENGLISH "object is in use"
  434.         //: FRANCAIS "l'objet est utilisé"
  435.         error200_msg_table[2][1]=GETTEXT("object is in use");
  436.         
  437.         error200_msg_table[3][0]="ERROR_OBJECT_EXISTS";
  438.         //: DEUTSCH "Objekt existiert bereits"
  439.         //: ENGLISH "object already exists"
  440.         //: FRANCAIS "l'objet existe déjà"
  441.         error200_msg_table[3][1]=GETTEXT("object already exists");
  442.  
  443.         error200_msg_table[4][0]="ERROR_DIR_NOT_FOUND";
  444.         //: DEUTSCH "Verzeichnis nicht gefunden"
  445.         //: ENGLISH "directory not found"
  446.         //: FRANCAIS "répertoire non trouvé"
  447.         error200_msg_table[4][1]=GETTEXT("directory not found");
  448.  
  449.         error200_msg_table[5][0]="ERROR_OBJECT_NOT_FOUND";
  450.         //: DEUTSCH "Objekt nicht gefunden"
  451.         //: ENGLISH "object not found"
  452.         //: FRANCAIS "objet non trouvé"
  453.         error200_msg_table[5][1]=GETTEXT("object not found");
  454.  
  455.         error200_msg_table[6][0]="ERROR_BAD_STREAM_NAME";
  456.         //: DEUTSCH "ungültige Fensterbeschreibung"
  457.         //: ENGLISH "invalid window description"
  458.         //: FRANCAIS "mauvais descripteur de fenêtre"
  459.         error200_msg_table[6][1]=GETTEXT("invalid window description");
  460.  
  461.         error200_msg_table[7][0]="ERROR_OBJECT_TOO_LARGE";
  462.         //: DEUTSCH "Objekt zu groß"
  463.         //: ENGLISH "object too large"
  464.         //: FRANCAIS "objet trop grand"
  465.         error200_msg_table[7][1]=GETTEXT("object too large");
  466.  
  467.         error200_msg_table[8][0]=""; error200_msg_table[8][1]="";
  468.  
  469.         error200_msg_table[9][0]="ERROR_ACTION_NOT_KNOWN";
  470.         //: DEUTSCH "unbekannter Pakettyp" # ??
  471.         //: ENGLISH "packet request type unknown"
  472.         //: FRANCAIS "Type de paquet inconnu"
  473.         error200_msg_table[9][1]=GETTEXT("packet request type unknown");
  474.  
  475.         error200_msg_table[10][0]="ERROR_INVALID_COMPONENT_NAME";
  476.         //: DEUTSCH "ungültiger Objektname"
  477.         //: ENGLISH "object name invalid"
  478.         //: FRANCAIS "nom d'objet incorrect"
  479.         error200_msg_table[10][1]=GETTEXT("object name invalid");
  480.         
  481.         error200_msg_table[11][0]="ERROR_INVALID_LOCK";
  482.         //: DEUTSCH "ungültiger Objektlock"
  483.         //: ENGLISH "invalid object lock"
  484.         //: FRANCAIS "«lock» invalide d'un objet"
  485.         error200_msg_table[11][1]=GETTEXT("invalid object lock");
  486.  
  487.         error200_msg_table[12][0]="ERROR_OBJECT_WRONG_TYPE";
  488.         //: DEUTSCH "Objekt ist nicht von benötigten Typ"
  489.         //: ENGLISH "object is not of required type"
  490.         //: FRANCAIS "objet de mauvais type"
  491.         error200_msg_table[12][1]=GETTEXT("object is not of required type");
  492.  
  493.         error200_msg_table[13][0]="ERROR_DISK_NOT_VALIDATED";
  494.         //: DEUTSCH "Datenträger ist nicht validiert"
  495.         //: ENGLISH "disk not validated"
  496.         //: FRANCAIS "volume non validé"
  497.         error200_msg_table[13][1]=GETTEXT("disk not validated");
  498.  
  499.         error200_msg_table[14][0]="ERROR_DISK_WRITE_PROTECTED";
  500.         //: DEUTSCH "Datenträger ist schreibgeschützt"
  501.         //: ENGLISH "disk is write-protected"
  502.         //: FRANCAIS "disquette protégée contre l'écriture"
  503.         error200_msg_table[14][1]=GETTEXT("disk is write-protected");
  504.  
  505.         error200_msg_table[15][0]="ERROR_RENAME_ACROSS_DEVICES";
  506.         //: DEUTSCH "rename über Laufwerke versucht"
  507.         //: ENGLISH "rename across devices attempted"
  508.         //: FRANCAIS "«rename» à travers des unités distinctes"
  509.         error200_msg_table[15][1]=GETTEXT("rename across devices attempted");
  510.  
  511.         error200_msg_table[16][0]="ERROR_DIRECTORY_NOT_EMPTY";
  512.         //: DEUTSCH "Verzeichnis ist nicht leer"
  513.         //: ENGLISH "directory not empty"
  514.         //: FRANCAIS "répertoire non vide"
  515.         error200_msg_table[16][1]=GETTEXT("directory not empty");
  516.  
  517.         error200_msg_table[17][0]="ERROR_TOO_MANY_LEVELS";
  518.         //: DEUTSCH "zu viele Verweise"
  519.         //: ENGLISH "too many levels"
  520.         //: FRANCAIS "trop de niveaux"
  521.         error200_msg_table[17][1]=GETTEXT("too many levels");
  522.  
  523.         error200_msg_table[18][0]="ERROR_DEVICE_NOT_MOUNTED";
  524.         //: DEUTSCH "Datenträger ist in keinem Laufwerk"
  525.         //: ENGLISH "device (or volume) is not mounted"
  526.         //: FRANCAIS "l'unité n'est dans aucun lecteur"
  527.         error200_msg_table[18][1]=GETTEXT("device (or volume) is not mounted");
  528.  
  529.         error200_msg_table[19][0]="ERROR_SEEK_ERROR";
  530.         //: DEUTSCH "seek schlug fehl"
  531.         //: ENGLISH "seek failure"
  532.         //: FRANCAIS "erreur pendant un déplacement (seek)"
  533.         error200_msg_table[19][1]=GETTEXT("seek failure");
  534.  
  535.         error200_msg_table[20][0]="ERROR_COMMENT_TOO_BIG";
  536.         //: DEUTSCH "Kommentar ist zu lang"
  537.         //: ENGLISH "comment is too long"
  538.         //: FRANCAIS "Commentaire trop long"
  539.         error200_msg_table[20][1]=GETTEXT("comment is too long");
  540.  
  541.         error200_msg_table[21][0]="ERROR_DISK_FULL";
  542.         //: DEUTSCH "Datenträger ist voll"
  543.         //: ENGLISH "disk is full"
  544.         //: FRANCAIS "support plein"
  545.         error200_msg_table[21][1]=GETTEXT("disk is full");
  546.  
  547.         error200_msg_table[22][0]="ERROR_DELETE_PROTECTED";
  548.         //: DEUTSCH "Datei ist gegen Löschen geschützt"
  549.         //: ENGLISH "object is protected from deletion"
  550.         //: FRANCAIS "objet est protégé contre l'effacement"
  551.         error200_msg_table[22][1]=GETTEXT("object is protected from deletion");
  552.  
  553.         error200_msg_table[23][0]="ERROR_WRITE_PROTECTED";
  554.         //: DEUTSCH "Datei ist schreibgeschützt"
  555.         //: ENGLISH "file is write protected"
  556.         //: FRANCAIS "fichier protégé contre l'écriture"
  557.         error200_msg_table[23][1]=GETTEXT("file is write protected");
  558.  
  559.         error200_msg_table[24][0]="ERROR_READ_PROTECTED";
  560.         //: DEUTSCH "Datei ist lesegeschützt"
  561.         //: ENGLISH "file is read protected"
  562.         //: FRANCAIS "fichier protégé contre la lecture"
  563.         error200_msg_table[24][1]=GETTEXT("file is read protected");
  564.  
  565.         error200_msg_table[25][0]="ERROR_NOT_A_DOS_DISK";
  566.         //: DEUTSCH "kein gültiger DOS-Datenträger"
  567.         //: ENGLISH "not a valid DOS disk"
  568.         //: FRANCAIS "disque non DOS"
  569.         error200_msg_table[25][1]=GETTEXT("not a valid DOS disk");
  570.  
  571.         error200_msg_table[26][0]="ERROR_NO_DISK";
  572.         //: DEUTSCH "kein Datenträger im Laufwerk"
  573.         //: ENGLISH "no disk in drive"
  574.         //: FRANCAIS "pas de disquette dans le lecteur"
  575.         error200_msg_table[26][1]=GETTEXT("no disk in drive");
  576.  
  577.         error200_msg_table[27][0]=""; error200_msg_table[27][1]="";
  578.         error200_msg_table[28][0]=""; error200_msg_table[28][1]="";
  579.         error200_msg_table[29][0]=""; error200_msg_table[29][1]="";
  580.         error200_msg_table[30][0]=""; error200_msg_table[30][1]="";
  581.         error200_msg_table[31][0]=""; error200_msg_table[31][1]="";
  582.  
  583.         error200_msg_table[32][0]="ERROR_NO_MORE_ENTRIES";
  584.         //: DEUTSCH "keine weiteren Verzeichniseinträge mehr"
  585.         //: ENGLISH "no more entries in directory"
  586.         //: FRANCAIS "pas plus d'entrées dans le répertoire"
  587.         error200_msg_table[32][1]=GETTEXT("no more entries in directory");
  588.  
  589.         error200_msg_table[33][0]="ERROR_IS_SOFT_LINK";
  590.         //: DEUTSCH "Objekt ist ein Softlink"
  591.         //: ENGLISH "object is soft link"
  592.         //: FRANCAIS "l'objet est un «soft link»"
  593.         error200_msg_table[33][1]=GETTEXT("object is soft link");
  594.  
  595.         error200_msg_table[34][0]="ERROR_OBJECT_LINKED";
  596.         //: DEUTSCH "Objekt ist gelinkt"
  597.         //: ENGLISH "object is linked"
  598.         //: FRANCAIS "l'objet est lié"
  599.         error200_msg_table[34][1]=GETTEXT("object is linked");
  600.  
  601.         error200_msg_table[35][0]="ERROR_BAD_HUNK";
  602.         //: DEUTSCH "Datei teilweise nicht ladbar"
  603.         //: ENGLISH "bad loadfile hunk"
  604.         //: FRANCAIS "fichier pas entièrement chargeable"
  605.         error200_msg_table[35][1]=GETTEXT("bad loadfile hunk");
  606.  
  607.         error200_msg_table[36][0]="ERROR_NOT_IMPLEMENTED";
  608.         //: DEUTSCH "unimplementierte Funktion"
  609.         //: ENGLISH "function not implemented"
  610.         //: FRANCAIS "fonction non implémentée"
  611.         error200_msg_table[36][1]=GETTEXT("function not implemented");
  612.  
  613.         error200_msg_table[37][0]=""; error200_msg_table[37][1]="";
  614.         error200_msg_table[38][0]=""; error200_msg_table[38][1]="";
  615.         error200_msg_table[39][0]=""; error200_msg_table[39][1]="";
  616.  
  617.         error200_msg_table[40][0]="ERROR_RECORD_NOT_LOCKED";
  618.         //: DEUTSCH ""
  619.         //: ENGLISH "record not locked"
  620.         //: FRANCAIS ""
  621.         error200_msg_table[40][1]=GETTEXT("record not locked");
  622.  
  623.         error200_msg_table[41][0]="ERROR_LOCK_COLLISION";
  624.         //: DEUTSCH ""
  625.         //: ENGLISH "record lock collision"
  626.         //: FRANCAIS ""
  627.         error200_msg_table[41][1]=GETTEXT("record lock collision");
  628.  
  629.         error200_msg_table[42][0]="ERROR_LOCK_TIMEOUT";
  630.         //: DEUTSCH ""
  631.         //: ENGLISH "record lock timeout"
  632.         //: FRANCAIS ""
  633.         error200_msg_table[42][1]=GETTEXT("record lock timeout");
  634.  
  635.         error200_msg_table[43][0]="ERROR_UNLOCK_ERROR";
  636.         //: DEUTSCH ""
  637.         //: ENGLISH "record unlock error"
  638.         //: FRANCAIS ""
  639.         error200_msg_table[43][1]=GETTEXT("record unlock error");
  640.  
  641.         error300_msg_table[0][0]=""; error300_msg_table[0][1]="";
  642.         error300_msg_table[1][0]=""; error300_msg_table[1][1]="";
  643.         error300_msg_table[2][0]=""; error300_msg_table[2][1]="";
  644.  
  645.         error300_msg_table[3][0]="ERROR_BUFFER_OVERFLOW";
  646.         //: DEUTSCH "Puffer-Überlauf"
  647.         //: ENGLISH "buffer overflow"
  648.         //: FRANCAIS "débordement de tampon"
  649.         error300_msg_table[3][1]=GETTEXT("buffer overflow");
  650.  
  651.         error300_msg_table[4][0]="ERROR_BREAK";
  652.         //: DEUTSCH "Unterbrechung"
  653.         //: ENGLISH "break"
  654.         //: FRANCAIS "interruption"
  655.         error300_msg_table[4][1]=GETTEXT("break");
  656.  
  657.         error300_msg_table[5][0]="ERROR_NOT_EXECUTABLE";
  658.         //: DEUTSCH "Datei ist nicht ausführbar"
  659.         //: ENGLISH "file not executable"
  660.         //: FRANCAIS "fichier non exécutable"
  661.         error300_msg_table[5][1]=GETTEXT("file not executable");
  662.         return 0;
  663.       }
  664.  
  665.     global void OS_error_ ()
  666.       { var reg1 sintW errcode = IoErr(); # Fehlernummer
  667.         end_system_call();
  668.         clr_break_sem_4(); # keine AMIGAOS-Operation mehr aktiv
  669.         begin_error(); # Fehlermeldung anfangen
  670.         # Meldungbeginn ausgeben:
  671.         //: DEUTSCH "AmigaOS-Fehler "
  672.         //: ENGLISH "Amiga OS error "
  673.         //: FRANCAIS "Erreur S.E. Amiga "
  674.         write_errorstring(GETTEXT("Amiga OS error "));
  675.         # Fehlernummer ausgeben:
  676.         write_errorobject(fixnum(errcode));
  677.         {
  678.           var reg3 const char* errorname = "";
  679.           var reg3 const char* errormsg = "";
  680.           var reg2 uintC index;
  681.  
  682.           if (errcode == 0)
  683.             { errorname = "";
  684.               //: DEUTSCH "OK, kein Fehler"
  685.               //: ENGLISH "Ok, No error"
  686.               //: FRANCAIS "Ok, pas d'erreur"
  687.               errormsg =GETTEXT("Ok, No error");
  688.             }
  689.           elif ((index = errcode-100) < 23)
  690.             { errorname = error100_msg_table[index][0];
  691.               errormsg = error100_msg_table[index][1];
  692.             }
  693.           elif ((index = errcode-200) < 44)
  694.             { errorname = error200_msg_table[index][0];
  695.               errormsg = error200_msg_table[index][1];
  696.             }
  697.           elif ((index = errcode-300) < 6)
  698.             { errorname = error300_msg_table[index][0];
  699.               errormsg = error300_msg_table[index][1];
  700.             }
  701.           if (!(errorname[0] == 0)) # bekannter Name?
  702.             { write_errorstring(" (");
  703.               write_errorstring(errorname);
  704.               write_errorstring(")");
  705.             }
  706.           if (!(errormsg[0] == 0)) # nichtleere Meldung?
  707.             { write_errorstring(": ");
  708.               write_errorstring(errormsg);
  709.             }
  710.         }
  711.         SetIoErr(0L); # Fehlercode löschen (fürs nächste Mal):
  712.         end_error(args_end_pointer STACKop (4+DYNBIND_SIZE)); # Fehlermeldung beenden
  713.       }
  714. #endif
  715.  
  716. #ifdef DJUNIX
  717.   # Behandlung von DJUNIX-(DOS-)Fehlern
  718.   # OS_error_();
  719.   # > int errno: Fehlercode
  720.     nonreturning_function(global, OS_error_, (void));
  721.     global void OS_error_ ()
  722.       { var reg1 uintC errcode = errno; # positive Fehlernummer
  723.         end_system_call();
  724.         clr_break_sem_4(); # keine DOS-Operation mehr aktiv
  725.         begin_error(); # Fehlermeldung anfangen
  726.         # Meldungbeginn ausgeben:
  727.         //: DEUTSCH "DJDOS-Fehler "
  728.         //: ENGLISH "DJDOS error "
  729.         //: FRANCAIS "Erreur DJDOS "
  730.         write_errorstring(GETTEXT("DJDOS error "));
  731.         # Fehlernummer ausgeben:
  732.         write_errorobject(fixnum(errcode));
  733.         # nach Möglichkeit noch ausführlicher:
  734.         #if (DJGPP == 2)
  735.         if (errcode < 39)
  736.         #else
  737.         if (errcode < 36)
  738.         #endif
  739.           {# Zu Fehlernummern <36/39 ist ein Text da.
  740.            #ifdef LANGUAGE_STATIC
  741.              #define lang3(english,deutsch,francais)  ENGLISH ? english : DEUTSCH ? deutsch : FRANCAIS ? francais : ""
  742.              #define lang1(string)  string
  743.              #define langcount  1
  744.              #define language  0
  745.            #else
  746.              #define lang3(english,deutsch,francais)  english, deutsch, francais
  747.              #define lang1(string)  string, string, string
  748.              #define langcount  3
  749.            #endif
  750.            local const char* errormsg_table[39][2];
  751.            var reg2 const char* errorname;
  752.            var reg3 const char* errormsg;
  753.  
  754.            errormsg_table[0][0]=""; errormsg_table[0][1]="";
  755.  
  756.            errormsg_table[ENOSYS][0]="ENOSYS";
  757.            //: DEUTSCH "Funktion ist nicht implementiert"
  758.            //: ENGLISH "Function not implemented"
  759.            //: FRANCAIS "fonction non implémentée"
  760.            errormsg_table[ENOSYS][1]=GETTEXT("Function not implemented");
  761.  
  762.            errormsg_table[ENOENT][0]="ENOENT";
  763.            //: DEUTSCH "File oder Directory existiert nicht"
  764.            //: ENGLISH "No such file or directory"
  765.            //: FRANCAIS "fichier ou répertoire non existant"
  766.            errormsg_table[ENOENT][1]=GETTEXT("No such file or directory");
  767.  
  768.            errormsg_table[ENOTDIR][0]="ENOTDIR";
  769.            //: DEUTSCH "Das ist kein Directory"
  770.            //: ENGLISH "Not a directory"
  771.            //: FRANCAIS "n'est pas un répertoire"
  772.            errormsg_table[ENOTDIR][1]=GETTEXT("Not a directory");
  773.  
  774.            errormsg_table[EMFILE][0]="EMFILE";
  775.            //: DEUTSCH "Zu viele offene Files"
  776.            //: ENGLISH "Too many open files"
  777.            //: FRANCAIS "Trop de fichiers ouverts"
  778.            errormsg_table[EMFILE][1]=GETTEXT("Too many open files");
  779.  
  780.            errormsg_table[EACCES][0]="EACCES";
  781.            //: DEUTSCH "Keine Berechtigung"
  782.            //: ENGLISH "Permission denied"
  783.            //: FRANCAIS "Accès dénié"
  784.            errormsg_table[EACCES][1]=GETTEXT("Permission denied");
  785.  
  786.            errormsg_table[EBADF][0]="EBADF";
  787.            //: DEUTSCH "File-Descriptor wurde nicht für diese Operation geöffnet"
  788.            //: ENGLISH "Bad file number"
  789.            //: FRANCAIS "descripteur de fichier non alloué"
  790.            errormsg_table[EBADF][1]=GETTEXT("Bad file number");
  791.  
  792.            errormsg_table[ENOMEM][0]="ENOMEM";
  793.            //: DEUTSCH "Hauptspeicher oder Swapspace reicht nicht"
  794.            //: ENGLISH "Not enough memory"
  795.            //: FRANCAIS "Pas assez de mémoire"
  796.            errormsg_table[ENOMEM][1]=GETTEXT("Not enough memory");
  797.  
  798.            errormsg_table[ENODEV][0]="ENODEV";
  799.            //: DEUTSCH "Gerät nicht da oder unpassend"
  800.            //: ENGLISH "No such device"
  801.            //: FRANCAIS "il n'y a pas de telle unité"
  802.            errormsg_table[ENODEV][1]=GETTEXT("No such device");
  803.  
  804.            #if DJGPP == 2
  805.            errormsg_table[ENOMORE][0]="ENMFILE";
  806.            #else
  807.            errormsg_table[ENOMORE][0]="ENOMORE";
  808.            #endif
  809.            //: DEUTSCH "Keine weiteren Dateien"
  810.            //: ENGLISH "No more files"
  811.            //: FRANCAIS "pas plus de fichier"
  812.            errormsg_table[ENOMORE][1]=GETTEXT("No more files");
  813.  
  814.            errormsg_table[EINVAL][0]="EINVAL";
  815.            //: DEUTSCH "Ungültiger Parameter"
  816.            //: ENGLISH "Invalid argument"
  817.            //: FRANCAIS "Paramètre illicite"
  818.            errormsg_table[EINVAL][1]=GETTEXT("Invalid argument");
  819.  
  820.            errormsg_table[E2BIG][0]="E2BIG";
  821.            //: DEUTSCH "Zu lange Argumentliste"
  822.            //: ENGLISH "Arg list too long"
  823.            //: FRANCAIS "liste d'arguments trop longue"
  824.            errormsg_table[E2BIG][1]=GETTEXT("Arg list too long");
  825.  
  826.            errormsg_table[ENOEXEC][0]="ENOEXEC";
  827.            //: DEUTSCH "Kein ausführbares Programm"
  828.            //: ENGLISH "Exec format error"
  829.            //: FRANCAIS "Programme non exécutable"
  830.            errormsg_table[ENOEXEC][1]=GETTEXT("Exec format error");
  831.  
  832.            errormsg_table[EXDEV][0]="EXDEV";
  833.            //: DEUTSCH "Links können nur aufs selbe Gerät gehen"
  834.            //: ENGLISH "Cross-device link"
  835.            //: FRANCAIS "liens uniquement sur la même unité"
  836.            errormsg_table[EXDEV][1]=GETTEXT("Cross-device link");
  837.  
  838.            errormsg_table[EDOM][0]="EDOM";
  839.            //: DEUTSCH "Argument zu mathematischer Funktion außerhalb des Definitionsbereichs"
  840.            //: ENGLISH "Argument out of domain"
  841.            //: FRANCAIS "argument hors du domaine de définition d'une fonction mathématique"
  842.            errormsg_table[EDOM][1]=GETTEXT("Argument out of domain");
  843.  
  844.            errormsg_table[ERANGE][0]="ERANGE";
  845.            //: DEUTSCH "Ergebnis mathematischer Funktion zu groß"
  846.            //: ENGLISH "Result too large"
  847.            //: FRANCAIS "débordement de valeur"
  848.            errormsg_table[ERANGE][1]=GETTEXT("Result too large");
  849.  
  850.            errormsg_table[EEXIST][0]="EEXIST";
  851.            //: DEUTSCH "File existiert schon"
  852.            //: ENGLISH "File exists"
  853.            //: FRANCAIS "Le fichier existe déjà"
  854.            errormsg_table[EEXIST][1]=GETTEXT("File exists");
  855.  
  856.            #if DJGPP == 2
  857.  
  858.            errormsg_table[EAGAIN][0]="EAGAIN";
  859.            //: DEUTSCH ""
  860.            //: ENGLISH "Resource temporarily unavailable"
  861.            //: FRANCAIS ""
  862.            errormsg_table[EAGAIN][1]=GETTEXT("Try again");
  863.  
  864.            errormsg_table[EBUSY][0]="EBUSY";
  865.            //: DEUTSCH ""
  866.            //: ENGLISH "Resource busy"
  867.            //: FRANCAIS ""
  868.            errormsg_table[EBUSY][1]=GETTEXT("Resource busy");
  869.  
  870.            errormsg_table[ECHILD][0]="ECHILD";
  871.            //: DEUTSCH "Worauf warten?"
  872.            //: ENGLISH "No child processes"
  873.            //: FRANCAIS "Pas de processus fils"
  874.            errormsg_table[ECHILD][1]=GETTEXT("No more child processes");
  875.  
  876.            errormsg_table[EDEADLK][0]="EDEADLK";
  877.            //: DEUTSCH "Das würde zu einem Deadlock führen"
  878.            //: ENGLISH "Resource deadlock would occur"
  879.            //: FRANCAIS "Blocage mutuel de la ressource "
  880.            errormsg_table[EDEADLK][1]=GETTEXT("Resource deadlock avoided");
  881.  
  882.            errormsg_table[EFAULT][0]="EFAULT";
  883.            //: DEUTSCH "Ungültige Adresse"
  884.            //: ENGLISH "Bad address"
  885.            //: FRANCAIS "Mauvaise adresse"
  886.            errormsg_table[EFAULT][1]=GETTEXT("Bad address");
  887.  
  888.            errormsg_table[EFBIG][0]="EFBIG";
  889.            //: DEUTSCH "Zu großes File"
  890.            //: ENGLISH "File too large"
  891.            //: FRANCAIS "Fichier trop grand"
  892.            errormsg_table[EFBIG][1]=GETTEXT("File too large");
  893.  
  894.            errormsg_table[EINTR][0]="EINTR";
  895.            //: DEUTSCH "Unterbrechung während Betriebssystem-Aufruf"
  896.            //: ENGLISH "Interrupted system call"
  897.            //: FRANCAIS "Appel système interrompu"
  898.            errormsg_table[EINTR][1]=GETTEXT("Interrupted system call");
  899.  
  900.            errormsg_table[EIO][0]="EIO";
  901.            //: DEUTSCH "Fehler bei Schreib-/Lesezugriff"
  902.            //: ENGLISH "I/O error"
  903.            //: FRANCAIS "Erreur E/S"
  904.            errormsg_table[EIO][1]=GETTEXT("Input or output");
  905.  
  906.            errormsg_table[EISDIR][0]="EISDIR";
  907.            //: DEUTSCH "Das ist ein Directory"
  908.            //: ENGLISH "Is a directory"
  909.            //: FRANCAIS "Est un répertoire"
  910.            errormsg_table[EISDIR][1]=GETTEXT("Is a directory");
  911.  
  912.            errormsg_table[EMLINK][0]="EMLINK";
  913.            //: DEUTSCH "Zu viele Links auf ein File"
  914.            //: ENGLISH "Too many links"
  915.            //: FRANCAIS "Trop de liens"
  916.            errormsg_table[EMLINK][1]=GETTEXT("Too many links");
  917.  
  918.            errormsg_table[ENAMETOOLONG][0]="ENAMETOOLONG";
  919.            //: DEUTSCH "Zu langer Filename"
  920.            //: ENGLISH "File name too long"
  921.            //: FRANCAIS "Nom du fichier trop long"
  922.            errormsg_table[ENAMETOOLONG][1]=GETTEXT("File name too long");
  923.  
  924.            errormsg_table[ENOLCK][0]="ENOLCK";
  925.            //: DEUTSCH "Zu viele Zugriffsvorbehalte auf einmal"
  926.            //: ENGLISH "No record locks available"
  927.            //: FRANCAIS "Pas de verrou disponible"
  928.            errormsg_table[ENOLCK][1]=GETTEXT("No locks available");
  929.  
  930.            errormsg_table[ENOSPC][0]="ENOSPC";
  931.            //: DEUTSCH "Platte oder Diskette voll"
  932.            //: ENGLISH "No space left on device"
  933.            //: FRANCAIS "Plus d'espace libre sur le périphérique"
  934.            errormsg_table[ENOSPC][1]=GETTEXT("No space left on drive");
  935.  
  936.            errormsg_table[ENOTEMPTY][0]="ENOTEMPTY";
  937.            //: DEUTSCH "Directory ist nicht leer"
  938.            //: ENGLISH "Directory not empty"
  939.            //: FRANCAIS "Répertoire non vide"
  940.            errormsg_table[ENOTEMPTY][1]=GETTEXT("Directory not empty");
  941.  
  942.            errormsg_table[ENOTTY][0]="ENOTTY";
  943.            //: DEUTSCH "Falscher Gerätetyp"
  944.            //: ENGLISH "Inappropriate ioctl for device"
  945.            //: FRANCAIS "Périphérique ne comprend pas ce ioctl"
  946.            errormsg_table[ENOTTY][1]=GETTEXT("Inappropriate I/O control operation");
  947.  
  948.            errormsg_table[ENXIO][0]="ENXIO";
  949.            //: DEUTSCH "Gerät existiert nicht oder Laufwerk leer"
  950.            //: ENGLISH "No such device or address"
  951.            //: FRANCAIS "Périphérique ou adresse inexistant"
  952.            errormsg_table[ENXIO][1]=GETTEXT("No such device or address");
  953.  
  954.            errormsg_table[EPERM][0]="EPERM";
  955.            //: DEUTSCH "Keine Berechtigung dazu"
  956.            //: ENGLISH "Operation not permitted"
  957.            //: FRANCAIS "Opération non autorisée"
  958.            errormsg_table[EPERM][1]=GETTEXT("Operation not permitted");
  959.  
  960.            errormsg_table[EPIPE][0]="EPIPE";
  961.            //: DEUTSCH "Output versackt"
  962.            //: ENGLISH "Broken pipe"
  963.            //: FRANCAIS "Rupture du tuyau"
  964.            errormsg_table[EPIPE][1]=GETTEXT("Broken pipe");
  965.  
  966.            errormsg_table[EROFS][0]="EROFS";
  967.            //: DEUTSCH "Dieses Filesystem erlaubt keinen Schreibzugriff"
  968.            //: ENGLISH "Read-only file system"
  969.            //: FRANCAIS "Système de fichiers en lecture seulement"
  970.            errormsg_table[EROFS][1]=GETTEXT("Read-only file system");
  971.  
  972.            errormsg_table[ESPIPE][0]="ESPIPE";
  973.            //: DEUTSCH "Nicht positionierbares File"
  974.            //: ENGLISH "Illegal seek"
  975.            //: FRANCAIS "seek illégal"
  976.            errormsg_table[ESPIPE][1]=GETTEXT("Invalid seek");
  977.  
  978.            errormsg_table[ESRCH][0]="ESRCH";
  979.            //: DEUTSCH "Dieser Prozeß existiert nicht (mehr)"
  980.            //: ENGLISH "No such process"
  981.            //: FRANCAIS "Processus inexistant"
  982.            errormsg_table[ESRCH][1]=GETTEXT("No such process");
  983.  
  984.            #else
  985.            errormsg_table[11][0]=""; errormsg_table[11][1]="";
  986.  
  987.            errormsg_table[EARENA][0]="EARENA";
  988.            //: DEUTSCH "Speicherverwaltung ist durcheinander"
  989.            //: ENGLISH "Memory control blocks destroyed"
  990.            //: FRANCAIS "gestionnaire de mémoire perdu"
  991.            errormsg_table[EARENA][1]=GETTEXT("Memory control blocks destroyed");
  992.  
  993.            errormsg_table[EACCODE][0]="EACCODE";
  994.            //: DEUTSCH "Ungültiger Zugriffsmodus"
  995.            //: ENGLISH "Invalid access code"
  996.            //: FRANCAIS "mode d'accès illégal"
  997.            errormsg_table[EACCODE][1]=GETTEXT("Invalid access code");
  998.  
  999.            errormsg_table[EBADENV][0]="EBADENV";
  1000.            //: DEUTSCH "Ungültiges Environment"
  1001.            //: ENGLISH "Invalid environment"
  1002.            //: FRANCAIS "environnement incorrect"
  1003.            errormsg_table[EBADENV][1]=GETTEXT("Invalid environment");
  1004.  
  1005.            errormsg_table[13][0]=""; errormsg_table[13][1]="";
  1006.            errormsg_table[14][0]=""; errormsg_table[14][1]="";
  1007.  
  1008.            errormsg_table[ECURDIR][0]="ECURDIR";
  1009.            //: DEUTSCH "Das aktuelle Verzeichnis kann nicht entfernt werden"
  1010.            //: ENGLISH "Attempt to remove the current directory"
  1011.            //: FRANCAIS "Le répertoire courant ne peut pas être effacé"
  1012.            errormsg_table[ECURDIR][1]=GETTEXT("Attempt to remove the current directory");
  1013.  
  1014.            errormsg_table[ENOTSAME][0]="ENOTSAME";
  1015.            //: DEUTSCH "Verschieben geht nicht über Laufwerksgrenzen hinweg"
  1016.            //: ENGLISH "Can't move to other than the same device"
  1017.            //: FRANCAIS "ne peux pas déplacer au-delà de l'unité"
  1018.            errormsg_table[ENOTSAME][1]=GETTEXT("Can't move to other than the same device");
  1019.  
  1020.            errormsg_table[ESEGV][0]="ESEGV";
  1021.            //: DEUTSCH "Ungültige Speicher-Adresse"
  1022.            //: ENGLISH "Invalid memory address"
  1023.            //: FRANCAIS "adresse mémoire illicite"
  1024.            errormsg_table[ESEGV][1]=GETTEXT("Invalid memory address");
  1025.  
  1026.            errormsg_table[23][0]=""; errormsg_table[23][1]="";
  1027.            errormsg_table[24][0]=""; errormsg_table[24][1]="";
  1028.            errormsg_table[25][0]=""; errormsg_table[25][1]="";
  1029.            errormsg_table[26][0]=""; errormsg_table[26][1]="";
  1030.            errormsg_table[27][0]=""; errormsg_table[27][1]="";
  1031.            errormsg_table[28][0]=""; errormsg_table[28][1]="";
  1032.            errormsg_table[29][0]=""; errormsg_table[29][1]="";
  1033.            errormsg_table[30][0]=""; errormsg_table[30][1]="";
  1034.            errormsg_table[31][0]=""; errormsg_table[31][1]="";
  1035.            errormsg_table[32][0]=""; errormsg_table[32][1]="";
  1036.            #endif
  1037.  
  1038.            errorname = errormsg_table[errcode][0];
  1039.            errormsg = errormsg_table[errcode][1];
  1040.  
  1041.            if (!(errorname[0] == 0)) # bekannter Name?
  1042.              { write_errorstring(" (");
  1043.                write_errorstring(errorname);
  1044.                write_errorstring(")");
  1045.              }
  1046.            if (!(errormsg[0] == 0)) # nichtleere Meldung?
  1047.              { write_errorstring(": ");
  1048.                write_errorstring(errormsg);
  1049.              }
  1050.           }
  1051.         end_error(args_end_pointer STACKop (4+DYNBIND_SIZE)); # Fehlermeldung beenden
  1052.       }
  1053.  
  1054.   # Ausgabe eines Fehlers, direkt übers Betriebssystem
  1055.   # errno_out(errorcode);
  1056.   # > int errorcode: Fehlercode
  1057.     global void errno_out (int errorcode);
  1058.     global void errno_out(errorcode)
  1059.       var reg1 int errorcode;
  1060.       { asciz_out(" errno = "); dez_out(errorcode); asciz_out("." CRLFstring); }
  1061. #endif
  1062.  
  1063. #if defined(UNIX) || defined(EMUNIX) || defined(WATCOM) || defined(RISCOS) || defined(WIN32_DOS) || defined(WIN32_UNIX)
  1064.  
  1065.   # Behandlung von UNIX-Fehlern
  1066.   # OS_error_();
  1067.   # > int errno: Fehlercode
  1068.     nonreturning_function(global, OS_error_, (void));
  1069.  
  1070.   # Problem: viele verschiedene UNIX-Versionen, jede wieder mit anderen
  1071.   # Fehlermeldungen.
  1072.   # Abhilfe: Die Fehlernamen sind einigermaßen portabel. Die englische
  1073.   # Fehlermeldung übernehmen wir, die Übersetzungen machen wir selbst.
  1074.   # Französische Fehlermeldungen von Tristan <marc@david.saclay.cea.fr>.
  1075.  
  1076.   #if !(defined(UNIX) || defined(EMUNIX) || defined(WATCOM) || defined(WIN32_DOS) || defined(WIN32_UNIX))
  1077.     extern int sys_nerr; # Anzahl der Betriebssystem-Fehlermeldungen
  1078.     extern char* sys_errlist[]; # Betriebssystem-Fehlermeldungen
  1079.   #endif
  1080.  
  1081.   # Tabelle der Fehlermeldungen und ihrer Namen:
  1082.     typedef struct { const char* name; const char* msg; } os_error;
  1083.     local os_error* errormsg_table;
  1084.  
  1085.   # Initialisierung der Tabelle:
  1086.     global int init_errormsg_table (void);
  1087.     global int init_errormsg_table()
  1088.       { var reg1 uintC i;
  1089.         begin_system_call();
  1090.         errormsg_table = (os_error*) malloc(sys_nerr * sizeof(os_error));
  1091.         end_system_call();
  1092.         if (errormsg_table == NULL) # Speicher reicht nicht?
  1093.           { return -1; }
  1094.         # Tabelle vor-initialisieren:
  1095.         for (i=0; i<sys_nerr; i++)
  1096.           { errormsg_table[i].name = "";
  1097.             errormsg_table[i].msg = sys_errlist[i];
  1098.           }
  1099.         # Tabelle initialisieren:
  1100.         # Obacht: Auf sys_nerr ist kein Verlaß. (Bei IRIX 5.2 ist EDQUOT >= sys_nerr !)
  1101.         /* allgemein verbreitete UNIX-Errors: */
  1102.         #ifdef EPERM
  1103.         if (EPERM < sys_nerr) {
  1104.         errormsg_table[EPERM].name = "EPERM";
  1105.         #if !defined(UNIX_LINUX)
  1106.         //: DEUTSCH "Keine Berechtigung dazu"
  1107.         //: ENGLISH "Not owner"
  1108.         //: FRANCAIS "Opération non autorisée"
  1109.         errormsg_table[EPERM].msg = GETTEXT("Not owner");
  1110.         #else
  1111.         //: DEUTSCH "Keine Berechtigung dazu"
  1112.         //: ENGLISH "Operation not permitted"
  1113.         //: FRANCAIS "Opération non autorisée"
  1114.         errormsg_table[EPERM].msg = GETTEXT("Operation not permitted");
  1115.         #endif
  1116.         }
  1117.         #endif
  1118.         #ifdef ENOENT
  1119.         if (ENOENT < sys_nerr) {
  1120.         errormsg_table[ENOENT].name = "ENOENT";
  1121.         //: DEUTSCH "File oder Directory existiert nicht"
  1122.         //: ENGLISH "No such file or directory"
  1123.         //: FRANCAIS "Fichier ou répertoire inéxistant"
  1124.         errormsg_table[ENOENT].msg = GETTEXT("No such file or directory");
  1125.         }
  1126.         #endif
  1127.         #ifdef ESRCH
  1128.         if (ESRCH < sys_nerr) {
  1129.         errormsg_table[ESRCH].name = "ESRCH";
  1130.         //: DEUTSCH "Dieser Prozeß existiert nicht (mehr)"
  1131.         //: ENGLISH "No such process"
  1132.         //: FRANCAIS "Processus inexistant"
  1133.         errormsg_table[ESRCH].msg = GETTEXT("No such process");
  1134.         }
  1135.         #endif
  1136.         #ifdef EINTR
  1137.         if (EINTR < sys_nerr) {
  1138.         errormsg_table[EINTR].name = "EINTR";
  1139.         //: DEUTSCH "Unterbrechung während Betriebssystem-Aufruf"
  1140.         //: ENGLISH "Interrupted system call"
  1141.         //: FRANCAIS "Appel système interrompu"
  1142.         errormsg_table[EINTR].msg = GETTEXT("Interrupted system call");
  1143.         }
  1144.         #endif
  1145.         #ifdef EIO
  1146.         if (EIO < sys_nerr) {
  1147.         errormsg_table[EIO].name = "EIO";
  1148.         //: DEUTSCH "Fehler bei Schreib-/Lesezugriff"
  1149.         //: ENGLISH "I/O error"
  1150.         //: FRANCAIS "Erreur E/S"
  1151.         errormsg_table[EIO].msg = GETTEXT("I/O error");
  1152.         }
  1153.         #endif
  1154.         #ifdef ENXIO
  1155.         if (ENXIO < sys_nerr) {
  1156.         errormsg_table[ENXIO].name = "ENXIO";
  1157.         //: DEUTSCH "Gerät existiert nicht oder Laufwerk leer"
  1158.         //: ENGLISH "No such device or address"
  1159.         //: FRANCAIS "Périphérique ou adresse inexistant"
  1160.         errormsg_table[ENXIO].msg = GETTEXT("No such device or address");
  1161.         }
  1162.         #endif
  1163.         #ifdef E2BIG
  1164.         if (E2BIG < sys_nerr) {
  1165.         errormsg_table[E2BIG].name = "E2BIG";
  1166.         //: DEUTSCH "Zu lange Argumentliste"
  1167.         //: ENGLISH "Arg list too long"
  1168.         //: FRANCAIS "Liste d'arguments trop longue"
  1169.         errormsg_table[E2BIG].msg = GETTEXT("Arg list too long");
  1170.         }
  1171.         #endif
  1172.         #ifdef ENOEXEC
  1173.         if (ENOEXEC < sys_nerr) {
  1174.         errormsg_table[ENOEXEC].name = "ENOEXEC";
  1175.         //: DEUTSCH "Kein ausführbares Programm"
  1176.         //: ENGLISH "Exec format error"
  1177.         //: FRANCAIS "Erreur sur le format exécutable"
  1178.         errormsg_table[ENOEXEC].msg = GETTEXT("Exec format error");
  1179.         }
  1180.         #endif
  1181.         #ifdef EBADF
  1182.         if (EBADF < sys_nerr) {
  1183.         errormsg_table[EBADF].name = "EBADF";
  1184.         //: DEUTSCH "File-Descriptor wurde nicht für diese Operation geöffnet"
  1185.         //: ENGLISH "Bad file number"
  1186.         //: FRANCAIS "Mauvais numéro de fichier"
  1187.         errormsg_table[EBADF].msg = GETTEXT("Bad file number");
  1188.         }
  1189.         #endif
  1190.         #ifdef ECHILD
  1191.         if (ECHILD < sys_nerr) {
  1192.         errormsg_table[ECHILD].name = "ECHILD";
  1193.         //: DEUTSCH "Worauf warten?"
  1194.         //: ENGLISH "No child processes"
  1195.         //: FRANCAIS "Pas de processus fils"
  1196.         errormsg_table[ECHILD].msg = GETTEXT("No child processes");
  1197.         }
  1198.         #endif
  1199.         #ifdef EAGAIN
  1200.         if (EAGAIN < sys_nerr) {
  1201.         errormsg_table[EAGAIN].name = "EAGAIN";
  1202.         //: DEUTSCH "Kann keinen weiteren Prozeß erzeugen"
  1203.         //: ENGLISH "No more processes"
  1204.         //: FRANCAIS "Essayez encore"
  1205.         errormsg_table[EAGAIN].msg = GETTEXT("No more processes");
  1206.         }
  1207.         #endif
  1208.         #ifdef ENOMEM
  1209.         if (ENOMEM < sys_nerr) {
  1210.         errormsg_table[ENOMEM].name = "ENOMEM";
  1211.         #if !defined(UNIX_SUNOS4)
  1212.         //: DEUTSCH "Hauptspeicher oder Swapspace reicht nicht"
  1213.         //: ENGLISH "Not enough memory"
  1214.         //: FRANCAIS "Plus de mémoire"
  1215.         errormsg_table[ENOMEM].msg = GETTEXT("Not enough memory");
  1216.         #else
  1217.         //: DEUTSCH "Speicher-Adreßbereich oder Swapspace reicht nicht"
  1218.         //: ENGLISH "Not enough memory"
  1219.         //: FRANCAIS "Plus de mémoire"
  1220.         errormsg_table[ENOMEM].msg = GETTEXT("Not enough memory");
  1221.         #endif
  1222.         }
  1223.         #endif
  1224.         #ifdef EACCES
  1225.         if (EACCES < sys_nerr) {
  1226.         errormsg_table[EACCES].name = "EACCES";
  1227.         //: DEUTSCH "Keine Berechtigung"
  1228.         //: ENGLISH "Permission denied"
  1229.         //: FRANCAIS "Permission refusée"
  1230.         errormsg_table[EACCES].msg = GETTEXT("Permission denied");
  1231.         }
  1232.         #endif
  1233.         #ifdef EFAULT
  1234.         if (EFAULT < sys_nerr) {
  1235.         errormsg_table[EFAULT].name = "EFAULT";
  1236.         //: DEUTSCH "Ungültige Adresse"
  1237.         //: ENGLISH "Bad address"
  1238.         //: FRANCAIS "Mauvaise adresse"
  1239.         errormsg_table[EFAULT].msg = GETTEXT("Bad address");
  1240.         }
  1241.         #endif
  1242.         #ifdef ENOTBLK
  1243.         if (ENOTBLK < sys_nerr) {
  1244.         errormsg_table[ENOTBLK].name = "ENOTBLK";
  1245.         //: DEUTSCH "Nur block-strukturierte Geräte erlaubt"
  1246.         //: ENGLISH "Block device required"
  1247.         //: FRANCAIS "Périphérique bloc requis"
  1248.         errormsg_table[ENOTBLK].msg = GETTEXT("Block device required");
  1249.         }
  1250.         #endif
  1251.         #ifdef EBUSY
  1252.         if (EBUSY < sys_nerr) {
  1253.         errormsg_table[EBUSY].name = "EBUSY";
  1254.         #if !defined(UNIX_SUNOS4)
  1255.         //: DEUTSCH "Gerät enthält Einheit und darf sie nicht auswerfen"
  1256.         //: ENGLISH "Mount device busy"
  1257.         //: FRANCAIS "Périphérique occupé"
  1258.         errormsg_table[EBUSY].msg = GETTEXT("Mount device busy");
  1259.         #else
  1260.         //: DEUTSCH "Filesystem darf nicht gekappt werden"
  1261.         //: ENGLISH "Device busy"
  1262.         //: FRANCAIS "Périphérique occupé"
  1263.         errormsg_table[EBUSY].msg = GETTEXT("Device busy");
  1264.         #endif
  1265.         }
  1266.         #endif
  1267.         #ifdef EEXIST
  1268.         if (EEXIST < sys_nerr) {
  1269.         errormsg_table[EEXIST].name = "EEXIST";
  1270.         //: DEUTSCH "File existiert schon"
  1271.         //: ENGLISH "File exists"
  1272.         //: FRANCAIS "Le fichier existe"
  1273.         errormsg_table[EEXIST].msg = GETTEXT("File exists");
  1274.         }
  1275.         #endif
  1276.         #ifdef EXDEV
  1277.         if (EXDEV < sys_nerr) {
  1278.         errormsg_table[EXDEV].name = "EXDEV";
  1279.         //: DEUTSCH "Links können nur aufs selbe Gerät gehen"
  1280.         //: ENGLISH "Cross-device link"
  1281.         //: FRANCAIS "Lien entre périphériques différents"
  1282.         errormsg_table[EXDEV].msg = GETTEXT("Cross-device link");
  1283.         }
  1284.         #endif
  1285.         #ifdef ENODEV
  1286.         if (ENODEV < sys_nerr) {
  1287.         errormsg_table[ENODEV].name = "ENODEV";
  1288.         //: DEUTSCH "Gerät nicht da oder unpassend"
  1289.         //: ENGLISH "No such device"
  1290.         //: FRANCAIS "Périphérique inexistant"
  1291.         errormsg_table[ENODEV].msg = GETTEXT("No such device");
  1292.         }
  1293.         #endif
  1294.         #ifdef ENOTDIR
  1295.         if (ENOTDIR < sys_nerr) {
  1296.         errormsg_table[ENOTDIR].name = "ENOTDIR";
  1297.         //: DEUTSCH "Das ist kein Directory"
  1298.         //: ENGLISH "Not a directory"
  1299.         //: FRANCAIS "N'est pas un répertoire"
  1300.         errormsg_table[ENOTDIR].msg = GETTEXT("Not a directory");
  1301.         }
  1302.         #endif
  1303.         #ifdef EISDIR
  1304.         if (EISDIR < sys_nerr) {
  1305.         errormsg_table[EISDIR].name = "EISDIR";
  1306.         //: DEUTSCH "Das ist ein Directory"
  1307.         //: ENGLISH "Is a directory"
  1308.         //: FRANCAIS "Est un répertoire"
  1309.         errormsg_table[EISDIR].msg = GETTEXT("Is a directory");
  1310.         }
  1311.         #endif
  1312.         #ifdef EINVAL
  1313.         if (EINVAL < sys_nerr) {
  1314.         errormsg_table[EINVAL].name = "EINVAL";
  1315.         //: DEUTSCH "Ungültiger Parameter"
  1316.         //: ENGLISH "Invalid argument"
  1317.         //: FRANCAIS "Argument invalide"
  1318.         errormsg_table[EINVAL].msg = GETTEXT("Invalid argument");
  1319.         }
  1320.         #endif
  1321.         #ifdef ENFILE
  1322.         if (ENFILE < sys_nerr) {
  1323.         errormsg_table[ENFILE].name = "ENFILE";
  1324.         //: DEUTSCH "Tabelle der offenen Files ist voll"
  1325.         //: ENGLISH "File table overflow"
  1326.         //: FRANCAIS "Dépassement de la table des fichiers"
  1327.         errormsg_table[ENFILE].msg = GETTEXT("File table overflow");
  1328.         }
  1329.         #endif
  1330.         #ifdef EMFILE
  1331.         if (EMFILE < sys_nerr) {
  1332.         errormsg_table[EMFILE].name = "EMFILE";
  1333.         //: DEUTSCH "Zu viele offene Files"
  1334.         //: ENGLISH "Too many open files"
  1335.         //: FRANCAIS "Trop de fichiers ouverts"
  1336.         errormsg_table[EMFILE].msg = GETTEXT("Too many open files");
  1337.         }
  1338.         #endif
  1339.         #ifdef ENOTTY
  1340.         if (ENOTTY < sys_nerr) {
  1341.         errormsg_table[ENOTTY].name = "ENOTTY";
  1342.         //: DEUTSCH "Falscher Gerätetyp"
  1343.         //: ENGLISH "Inappropriate ioctl for device"
  1344.         //: FRANCAIS "Périphérique ne comprend pas ce ioctl"
  1345.         errormsg_table[ENOTTY].msg = GETTEXT("Inappropriate ioctl for device");
  1346.         }
  1347.         #endif
  1348.         #ifdef ETXTBSY
  1349.         if (ETXTBSY < sys_nerr) {
  1350.         errormsg_table[ETXTBSY].name = "ETXTBSY";
  1351.         //: DEUTSCH "Programm wird gerade geändert oder ausgeführt"
  1352.         //: ENGLISH "Text file busy"
  1353.         //: FRANCAIS "Fichier code occupé"
  1354.         errormsg_table[ETXTBSY].msg = GETTEXT("Text file busy");
  1355.         }
  1356.         #endif
  1357.         #ifdef EFBIG
  1358.         if (EFBIG < sys_nerr) {
  1359.         errormsg_table[EFBIG].name = "EFBIG";
  1360.         //: DEUTSCH "Zu großes File"
  1361.         //: ENGLISH "File too large"
  1362.         //: FRANCAIS "Fichier trop grand"
  1363.         errormsg_table[EFBIG].msg = GETTEXT("File too large");
  1364.         }
  1365.         #endif
  1366.         #ifdef ENOSPC
  1367.         if (ENOSPC < sys_nerr) {
  1368.         errormsg_table[ENOSPC].name = "ENOSPC";
  1369.         //: DEUTSCH "Platte oder Diskette voll"
  1370.         //: ENGLISH "No space left on device"
  1371.         //: FRANCAIS "Plus d'espace libre sur le périphérique"
  1372.         errormsg_table[ENOSPC].msg = GETTEXT("No space left on device");
  1373.         }
  1374.         #endif
  1375.         #ifdef ESPIPE
  1376.         if (ESPIPE < sys_nerr) {
  1377.         errormsg_table[ESPIPE].name = "ESPIPE";
  1378.         //: DEUTSCH "Nicht positionierbares File"
  1379.         //: ENGLISH "Illegal seek"
  1380.         //: FRANCAIS "seek illégal"
  1381.         errormsg_table[ESPIPE].msg = GETTEXT("Illegal seek");
  1382.         }
  1383.         #endif
  1384.         #ifdef EROFS
  1385.         if (EROFS < sys_nerr) {
  1386.         errormsg_table[EROFS].name = "EROFS";
  1387.         //: DEUTSCH "Dieses Filesystem erlaubt keinen Schreibzugriff"
  1388.         //: ENGLISH "Read-only file system"
  1389.         //: FRANCAIS "Système de fichiers en lecture seulement"
  1390.         errormsg_table[EROFS].msg = GETTEXT("Read-only file system");
  1391.         }
  1392.         #endif
  1393.         #ifdef EMLINK
  1394.         if (EMLINK < sys_nerr) {
  1395.         errormsg_table[EMLINK].name = "EMLINK";
  1396.         //: DEUTSCH "Zu viele Links auf ein File"
  1397.         //: ENGLISH "Too many links"
  1398.         //: FRANCAIS "Trop de liens"
  1399.         errormsg_table[EMLINK].msg = GETTEXT("Too many links");
  1400.         }
  1401.         #endif
  1402.         #ifdef EPIPE
  1403.         if (EPIPE < sys_nerr) {
  1404.         errormsg_table[EPIPE].name = "EPIPE";
  1405.         //: DEUTSCH "Output versackt"
  1406.         //: ENGLISH "Broken pipe"
  1407.         //: FRANCAIS "Rupture du tuyau"
  1408.         errormsg_table[EPIPE].msg = GETTEXT("Broken pipe");
  1409.         }
  1410.         #endif
  1411.         /* Errors bei mathematischen Funktionen: */
  1412.         #ifdef EDOM
  1413.         if (EDOM < sys_nerr) {
  1414.         errormsg_table[EDOM].name = "EDOM";
  1415.         //: DEUTSCH "Argument zu mathematischer Funktion außerhalb des Definitionsbereichs"
  1416.         //: ENGLISH "Argument out of domain"
  1417.         //: FRANCAIS "Argument mathématique en dehors du domaine de définition de la fonction"
  1418.         errormsg_table[EDOM].msg = GETTEXT("Argument out of domain");
  1419.         }
  1420.         #endif
  1421.         #ifdef ERANGE
  1422.         if (ERANGE < sys_nerr) {
  1423.         errormsg_table[ERANGE].name = "ERANGE";
  1424.         //: DEUTSCH "Ergebnis mathematischer Funktion zu groß"
  1425.         //: ENGLISH "Result too large"
  1426.         //: FRANCAIS "Résultat mathématique non représentable"
  1427.         errormsg_table[ERANGE].msg = GETTEXT("Result too large");
  1428.         }
  1429.         #endif
  1430.         /* Errors bei Non-Blocking I/O und Interrupt I/O: */
  1431.         #ifdef EWOULDBLOCK
  1432.         if (EWOULDBLOCK < sys_nerr) {
  1433.         errormsg_table[EWOULDBLOCK].name = "EWOULDBLOCK";
  1434.         //: DEUTSCH "Darauf müßte gewartet werden"
  1435.         //: ENGLISH "Operation would block"
  1436.         //: FRANCAIS "L'opération devrait bloquer"
  1437.         errormsg_table[EWOULDBLOCK].msg = GETTEXT("Operation would block");
  1438.         }
  1439.         #endif
  1440.         #ifdef EINPROGRESS
  1441.         if (EINPROGRESS < sys_nerr) {
  1442.         errormsg_table[EINPROGRESS].name = "EINPROGRESS";
  1443.         //: DEUTSCH "Das kann lange dauern"
  1444.         //: ENGLISH "Operation now in progress"
  1445.         //: FRANCAIS "Operation maintenant en cours"
  1446.         errormsg_table[EINPROGRESS].msg = GETTEXT("Operation now in progress");
  1447.         }
  1448.         #endif
  1449.         #ifdef EALREADY
  1450.         if (EALREADY < sys_nerr) {
  1451.         errormsg_table[EALREADY].name = "EALREADY";
  1452.         //: DEUTSCH "Es läuft schon eine Operation"
  1453.         //: ENGLISH "Operation already in progress"
  1454.         //: FRANCAIS "Operation déjà en cours"
  1455.         errormsg_table[EALREADY].msg = GETTEXT("Operation already in progress");
  1456.         }
  1457.         #endif
  1458.         /* weitere allgemein übliche Errors: */
  1459.         #ifdef ELOOP
  1460.         if (ELOOP < sys_nerr) {
  1461.         errormsg_table[ELOOP].name = "ELOOP";
  1462.         //: DEUTSCH "Zu viele symbolische Links in einem Pathname"
  1463.         //: ENGLISH "Too many levels of symbolic links"
  1464.         //: FRANCAIS "Trop de liens symboliques rencontrés"
  1465.         errormsg_table[ELOOP].msg = GETTEXT("Too many levels of symbolic links");
  1466.         }
  1467.         #endif
  1468.         #ifdef ENAMETOOLONG
  1469.         if (ENAMETOOLONG < sys_nerr) {
  1470.         errormsg_table[ENAMETOOLONG].name = "ENAMETOOLONG";
  1471.         //: DEUTSCH "Zu langer Filename"
  1472.         //: ENGLISH "File name too long"
  1473.         //: FRANCAIS "Nom du fichier trop long"
  1474.         errormsg_table[ENAMETOOLONG].msg = GETTEXT("File name too long");
  1475.         }
  1476.         #endif
  1477.         #ifdef ENOTEMPTY
  1478.         if (ENOTEMPTY < sys_nerr) {
  1479.         errormsg_table[ENOTEMPTY].name = "ENOTEMPTY";
  1480.         //: DEUTSCH "Directory ist nicht leer"
  1481.         //: ENGLISH "Directory not empty"
  1482.         //: FRANCAIS "Répertoire non vide"
  1483.         errormsg_table[ENOTEMPTY].msg = GETTEXT("Directory not empty");
  1484.         }
  1485.         #endif
  1486.         /* Errors im Zusammenhang mit Network File System (NFS): */
  1487.         #ifdef ESTALE
  1488.         if (ESTALE < sys_nerr) {
  1489.         errormsg_table[ESTALE].name = "ESTALE";
  1490.         //: DEUTSCH "Offenes File auf entferntem Filesystem wurde gelöscht"
  1491.         //: ENGLISH "Stale NFS file handle"
  1492.         //: FRANCAIS "Fichier NFS perdu"
  1493.         errormsg_table[ESTALE].msg = GETTEXT("Stale NFS file handle");
  1494.         }
  1495.         #endif
  1496.         #ifdef EREMOTE
  1497.         if (EREMOTE < sys_nerr) {
  1498.         errormsg_table[EREMOTE].name = "EREMOTE";
  1499.         //: DEUTSCH "Mount läuft nicht auf entfernten Filesystemen"
  1500.         //: ENGLISH "Too many levels of remote in path"
  1501.         //: FRANCAIS "Mount éloigné ne marche pas"
  1502.         errormsg_table[EREMOTE].msg = GETTEXT("Too many levels of remote in path");
  1503.         }
  1504.         #endif
  1505.         /* Errors im Zusammenhang mit Sockets, IPC und Netzwerk: */
  1506.         #ifdef ENOTSOCK
  1507.         if (ENOTSOCK < sys_nerr) {
  1508.         errormsg_table[ENOTSOCK].name = "ENOTSOCK";
  1509.         //: DEUTSCH "Socket-Operation und kein Socket"
  1510.         //: ENGLISH "Socket operation on non-socket"
  1511.         //: FRANCAIS "Opération de type socket sur un fichier non-socket"
  1512.         errormsg_table[ENOTSOCK].msg = GETTEXT("Socket operation on non-socket");
  1513.         }
  1514.         #endif
  1515.         #ifdef EDESTADDRREQ
  1516.         if (EDESTADDRREQ < sys_nerr) {
  1517.         errormsg_table[EDESTADDRREQ].name = "EDESTADDRREQ";
  1518.         //: DEUTSCH "Operation braucht Zieladresse"
  1519.         //: ENGLISH "Destination address required"
  1520.         //: FRANCAIS "Adresse de destination obligatoire"
  1521.         errormsg_table[EDESTADDRREQ].msg = GETTEXT("Destination address required");
  1522.         }
  1523.         #endif
  1524.         #ifdef EMSGSIZE
  1525.         if (EMSGSIZE < sys_nerr) {
  1526.         errormsg_table[EMSGSIZE].name = "EMSGSIZE";
  1527.         //: DEUTSCH "Zu lange Nachricht"
  1528.         //: ENGLISH "Message too long"
  1529.         //: FRANCAIS "Message trop long"
  1530.         errormsg_table[EMSGSIZE].msg = GETTEXT("Message too long");
  1531.         }
  1532.         #endif
  1533.         #ifdef EPROTOTYPE
  1534.         if (EPROTOTYPE < sys_nerr) {
  1535.         errormsg_table[EPROTOTYPE].name = "EPROTOTYPE";
  1536.         //: DEUTSCH "Dieses Protokoll paßt nicht zu diesem Socket"
  1537.         //: ENGLISH "Protocol wrong type for socket"
  1538.         //: FRANCAIS "Mauvais type de protocole pour un socket"
  1539.         errormsg_table[EPROTOTYPE].msg = GETTEXT("Protocol wrong type for socket");
  1540.         }
  1541.         #endif
  1542.         #ifdef ENOPROTOOPT
  1543.         if (ENOPROTOOPT < sys_nerr) {
  1544.         errormsg_table[ENOPROTOOPT].name = "ENOPROTOOPT";
  1545.         #if defined(UNIX_SUNOS4)
  1546.         //: DEUTSCH "Fehlerhafte Option zu Protokoll auf Socket"
  1547.         //: ENGLISH "Option not supported by protocol"
  1548.         //: FRANCAIS "Protocole non disponible"
  1549.         errormsg_table[ENOPROTOOPT].msg = GETTEXT("Option not supported by protocol");
  1550.         #else
  1551.         #if defined(UNIX_BSD)
  1552.         //: DEUTSCH "Fehlerhafte Option zu Protokoll auf Socket"
  1553.         //: ENGLISH "Bad protocol option"
  1554.         //: FRANCAIS "Protocole non disponible"
  1555.         errormsg_table[ENOPROTOOPT].msg = GETTEXT("Bad protocol option");
  1556.         #else /* UNIX_HPUX, UNIX_LINUX */
  1557.         //: DEUTSCH "Fehlerhafte Option zu Protokoll auf Socket"
  1558.         //: ENGLISH "Protocol not available"
  1559.         //: FRANCAIS "Protocole non disponible"
  1560.         errormsg_table[ENOPROTOOPT].msg = GETTEXT("Protocol not available");
  1561.         #endif
  1562.         #endif
  1563.         }
  1564.         #endif
  1565.         #ifdef EPROTONOSUPPORT
  1566.         if (EPROTONOSUPPORT < sys_nerr) {
  1567.         errormsg_table[EPROTONOSUPPORT].name = "EPROTONOSUPPORT";
  1568.         //: DEUTSCH "Protokoll nicht implementiert"
  1569.         //: ENGLISH "Protocol not supported"
  1570.         //: FRANCAIS "Protocole non supporté"
  1571.         errormsg_table[EPROTONOSUPPORT].msg = GETTEXT("Protocol not supported");
  1572.         }
  1573.         #endif
  1574.         #ifdef ESOCKTNOSUPPORT
  1575.         if (ESOCKTNOSUPPORT < sys_nerr) {
  1576.         errormsg_table[ESOCKTNOSUPPORT].name = "ESOCKTNOSUPPORT";
  1577.         //: DEUTSCH "Socket-Typ nicht implementiert"
  1578.         //: ENGLISH "Socket type not supported"
  1579.         //: FRANCAIS "Type de socket non supporté"
  1580.         errormsg_table[ESOCKTNOSUPPORT].msg = GETTEXT("Socket type not supported");
  1581.         }
  1582.         #endif
  1583.         #ifdef EOPNOTSUPP
  1584.         if (EOPNOTSUPP < sys_nerr) {
  1585.         errormsg_table[EOPNOTSUPP].name = "EOPNOTSUPP";
  1586.         //: DEUTSCH "Operation auf diesem Socket nicht implementiert"
  1587.         //: ENGLISH "Operation not supported on socket"
  1588.         //: FRANCAIS "Opération non supportée sur socket"
  1589.         errormsg_table[EOPNOTSUPP].msg = GETTEXT("Operation not supported on socket");
  1590.         }
  1591.         #endif
  1592.         #ifdef EPFNOSUPPORT
  1593.         if (EPFNOSUPPORT < sys_nerr) {
  1594.         errormsg_table[EPFNOSUPPORT].name = "EPFNOSUPPORT";
  1595.         //: DEUTSCH "Protokoll-Familie nicht implementiert"
  1596.         //: ENGLISH "Protocol family not supported"
  1597.         //: FRANCAIS "Famille de protocoles non supportée"
  1598.         errormsg_table[EPFNOSUPPORT].msg = GETTEXT("Protocol family not supported");
  1599.         }
  1600.         #endif
  1601.         #ifdef EAFNOSUPPORT
  1602.         if (EAFNOSUPPORT < sys_nerr) {
  1603.         errormsg_table[EAFNOSUPPORT].name = "EAFNOSUPPORT";
  1604.         //: DEUTSCH "Adressen-Familie paßt nicht zu diesem Protokoll"
  1605.         //: ENGLISH "Address family not supported by protocol family"
  1606.         //: FRANCAIS "Famille d'adresses non supportée par le protocole"
  1607.         errormsg_table[EAFNOSUPPORT].msg = GETTEXT("Address family not supported by protocol family");
  1608.         }
  1609.         #endif
  1610.         #ifdef EADDRINUSE
  1611.         if (EADDRINUSE < sys_nerr) {
  1612.         errormsg_table[EADDRINUSE].name = "EADDRINUSE";
  1613.         //: DEUTSCH "Adresse schon belegt"
  1614.         //: ENGLISH "Address already in use"
  1615.         //: FRANCAIS "Adresse déjà utilisée"
  1616.         errormsg_table[EADDRINUSE].msg = GETTEXT("Address already in use");
  1617.         }
  1618.         #endif
  1619.         #ifdef EADDRNOTAVAIL
  1620.         if (EADDRNOTAVAIL < sys_nerr) {
  1621.         errormsg_table[EADDRNOTAVAIL].name = "EADDRNOTAVAIL";
  1622.         //: DEUTSCH "Adresse nicht (auf diesem Rechner) verfügbar"
  1623.         //: ENGLISH "Can't assign requested address"
  1624.         //: FRANCAIS "Ne peut pas assigner l'adresse demandée"
  1625.         errormsg_table[EADDRNOTAVAIL].msg = GETTEXT("Can't assign requested address");
  1626.         }
  1627.         #endif
  1628.         #ifdef ENETDOWN
  1629.         if (ENETDOWN < sys_nerr) {
  1630.         errormsg_table[ENETDOWN].name = "ENETDOWN";
  1631.         //: DEUTSCH "Netz streikt"
  1632.         //: ENGLISH "Network is down"
  1633.         //: FRANCAIS "Le réseau est éteint"
  1634.         errormsg_table[ENETDOWN].msg = GETTEXT("Network is down");
  1635.         }
  1636.         #endif
  1637.         #ifdef ENETUNREACH
  1638.         if (ENETUNREACH < sys_nerr) {
  1639.         errormsg_table[ENETUNREACH].name = "ENETUNREACH";
  1640.         //: DEUTSCH "Netz unbekannt und außer Sichtweite"
  1641.         //: ENGLISH "Network is unreachable"
  1642.         //: FRANCAIS "Le réseau ne peut être atteint"
  1643.         errormsg_table[ENETUNREACH].msg = GETTEXT("Network is unreachable");
  1644.         }
  1645.         #endif
  1646.         #ifdef ENETRESET
  1647.         if (ENETRESET < sys_nerr) {
  1648.         errormsg_table[ENETRESET].name = "ENETRESET";
  1649.         //: DEUTSCH "Rechner bootete, Verbindung gekappt"
  1650.         //: ENGLISH "Network dropped connection on reset"
  1651.         //: FRANCAIS "Le réseau a rompu la connection à cause d'une remise à zéro"
  1652.         errormsg_table[ENETRESET].msg = GETTEXT("Network dropped connection on reset");
  1653.         }
  1654.         #endif
  1655.         #ifdef ECONNABORTED
  1656.         if (ECONNABORTED < sys_nerr) {
  1657.         errormsg_table[ECONNABORTED].name = "ECONNABORTED";
  1658.         //: DEUTSCH "Mußte diese Verbindung kappen"
  1659.         //: ENGLISH "Software caused connection abort"
  1660.         //: FRANCAIS "Echec de connection à cause du logiciel"
  1661.         errormsg_table[ECONNABORTED].msg = GETTEXT("Software caused connection abort");
  1662.         }
  1663.         #endif
  1664.         #ifdef ECONNRESET
  1665.         if (ECONNRESET < sys_nerr) {
  1666.         errormsg_table[ECONNRESET].name = "ECONNRESET";
  1667.         //: DEUTSCH "Gegenseite kappte die Verbindung"
  1668.         //: ENGLISH "Connection reset by peer"
  1669.         //: FRANCAIS "Connection remise à zéro par le correspondant"
  1670.         errormsg_table[ECONNRESET].msg = GETTEXT("Connection reset by peer");
  1671.         }
  1672.         #endif
  1673.         #ifdef ENOBUFS
  1674.         if (ENOBUFS < sys_nerr) {
  1675.         errormsg_table[ENOBUFS].name = "ENOBUFS";
  1676.         //: DEUTSCH "Nicht genügend Platz für einen Buffer"
  1677.         //: ENGLISH "No buffer space available"
  1678.         //: FRANCAIS "Pas d'espace disponible pour un buffer"
  1679.         errormsg_table[ENOBUFS].msg = GETTEXT("No buffer space available");
  1680.         }
  1681.         #endif
  1682.         #ifdef EISCONN
  1683.         if (EISCONN < sys_nerr) {
  1684.         errormsg_table[EISCONN].name = "EISCONN";
  1685.         //: DEUTSCH "Socket ist bereits verbunden"
  1686.         //: ENGLISH "Socket is already connected"
  1687.         //: FRANCAIS "Le socket est déjà connecté"
  1688.         errormsg_table[EISCONN].msg = GETTEXT("Socket is already connected");
  1689.         }
  1690.         #endif
  1691.         #ifdef ENOTCONN
  1692.         if (ENOTCONN < sys_nerr) {
  1693.         errormsg_table[ENOTCONN].name = "ENOTCONN";
  1694.         //: DEUTSCH "Socket hat keine Verbindung"
  1695.         //: ENGLISH "Socket is not connected"
  1696.         //: FRANCAIS "Le socket n'est pas connecté"
  1697.         errormsg_table[ENOTCONN].msg = GETTEXT("Socket is not connected");
  1698.         }
  1699.         #endif
  1700.         #ifdef ESHUTDOWN
  1701.         if (ESHUTDOWN < sys_nerr) {
  1702.         errormsg_table[ESHUTDOWN].name = "ESHUTDOWN";
  1703.         //: DEUTSCH "Shutdown hat den Socket schon deaktiviert"
  1704.         //: ENGLISH "Can't send after socket shutdown"
  1705.         //: FRANCAIS "Impossibilité d'envoyer après un arrêt de socket"
  1706.         errormsg_table[ESHUTDOWN].msg = GETTEXT("Can't send after socket shutdown");
  1707.         }
  1708.         #endif
  1709.         #ifdef ETOOMANYREFS
  1710.         if (ETOOMANYREFS < sys_nerr) {
  1711.         errormsg_table[ETOOMANYREFS].name = "ETOOMANYREFS";
  1712.         //: DEUTSCH "Too many references: can't splice"
  1713.         //: ENGLISH "Too many references: can't splice"
  1714.         //: FRANCAIS "Too many references: can't splice"
  1715.         errormsg_table[ETOOMANYREFS].msg = GETTEXT("Too many references: can't splice");
  1716.         }
  1717.         #endif
  1718.         #ifdef ETIMEDOUT
  1719.         if (ETIMEDOUT < sys_nerr) {
  1720.         errormsg_table[ETIMEDOUT].name = "ETIMEDOUT";
  1721.         //: DEUTSCH "Verbindung nach Timeout gekappt"
  1722.         //: ENGLISH "Connection timed out"
  1723.         //: FRANCAIS "Durée écoulée pour la connection"
  1724.         errormsg_table[ETIMEDOUT].msg = GETTEXT("Connection timed out");
  1725.         }
  1726.         #endif
  1727.         #ifdef ECONNREFUSED
  1728.         if (ECONNREFUSED < sys_nerr) {
  1729.         errormsg_table[ECONNREFUSED].name = "ECONNREFUSED";
  1730.         //: DEUTSCH "Gegenseite verweigert die Verbindung"
  1731.         //: ENGLISH "Connection refused"
  1732.         //: FRANCAIS "Connection refusée"
  1733.         errormsg_table[ECONNREFUSED].msg = GETTEXT("Connection refused");
  1734.         }
  1735.         #endif
  1736.         #if 0
  1737.         errormsg_table[].name = "";
  1738.         //: DEUTSCH "Remote peer released connection"
  1739.         //: ENGLISH "Remote peer released connection"
  1740.         //: FRANCAIS "Remote peer released connection"
  1741.         errormsg_table[].msg = GETTEXT("Remote peer released connection");
  1742.         #endif
  1743.         #ifdef EHOSTDOWN
  1744.         if (EHOSTDOWN < sys_nerr) {
  1745.         errormsg_table[EHOSTDOWN].name = "EHOSTDOWN";
  1746.         //: DEUTSCH "Gegenseite ist wohl abgeschaltet"
  1747.         //: ENGLISH "Host is down"
  1748.         //: FRANCAIS "L'hôte est éteint"
  1749.         errormsg_table[EHOSTDOWN].msg = GETTEXT("Host is down");
  1750.         }
  1751.         #endif
  1752.         #ifdef EHOSTUNREACH
  1753.         if (EHOSTUNREACH < sys_nerr) {
  1754.         errormsg_table[EHOSTUNREACH].name = "EHOSTUNREACH";
  1755.         //: DEUTSCH "Gegenseite nicht in Sichtweite, nicht erreichbar"
  1756.         //: ENGLISH "Host is unreachable"
  1757.         //: FRANCAIS "Aucune route pour cet hôte"
  1758.         errormsg_table[EHOSTUNREACH].msg = GETTEXT("Host is unreachable");
  1759.         }
  1760.         #endif
  1761.         #if 0
  1762.         errormsg_table[].name = "";
  1763.         //: DEUTSCH "Networking error"
  1764.         //: ENGLISH "Networking error"
  1765.         //: FRANCAIS "Networking error"
  1766.         errormsg_table[].msg = GETTEXT("Networking error");
  1767.         #endif
  1768.         /* Quotas: */
  1769.         #ifdef EPROCLIM
  1770.         if (EPROCLIM < sys_nerr) {
  1771.         errormsg_table[EPROCLIM].name = "EPROCLIM";
  1772.         //: DEUTSCH "Zu viele Prozesse am Laufen"
  1773.         //: ENGLISH "Too many processes"
  1774.         //: FRANCAIS "Trop de processus"
  1775.         errormsg_table[EPROCLIM].msg = GETTEXT("Too many processes");
  1776.         }
  1777.         #endif
  1778.         #ifdef EUSERS
  1779.         if (EUSERS < sys_nerr) {
  1780.         errormsg_table[EUSERS].name = "EUSERS";
  1781.         //: DEUTSCH "Zu viele Benutzer aktiv"
  1782.         //: ENGLISH "Too many users"
  1783.         //: FRANCAIS "Trop d'utilisateurs"
  1784.         errormsg_table[EUSERS].msg = GETTEXT("Too many users");
  1785.         }
  1786.         #endif
  1787.         #ifdef EDQUOT
  1788.         if (EDQUOT < sys_nerr) {
  1789.         errormsg_table[EDQUOT].name = "EDQUOT";
  1790.         //: DEUTSCH "Plattenplatz rationiert, Ihr Anteil ist erschöpft"
  1791.         //: ENGLISH "Disk quota exceeded"
  1792.         //: FRANCAIS "Ration d'espace est épuisée"
  1793.         errormsg_table[EDQUOT].msg = GETTEXT("Disk quota exceeded");
  1794.         }
  1795.         #endif
  1796.         /* Errors im Zusammenhang mit STREAMS: */
  1797.         #ifdef ENOSTR
  1798.         if (ENOSTR < sys_nerr) {
  1799.         errormsg_table[ENOSTR].name = "ENOSTR";
  1800.         //: DEUTSCH "Das ist kein STREAM"
  1801.         //: ENGLISH "Not a stream device"
  1802.         //: FRANCAIS "Not a stream device"
  1803.         errormsg_table[ENOSTR].msg = GETTEXT("Not a stream device");
  1804.         }
  1805.         #endif
  1806.         #ifdef ETIME
  1807.         if (ETIME < sys_nerr) {
  1808.         errormsg_table[ETIME].name = "ETIME";
  1809.         //: DEUTSCH "STREAM braucht länger als erwartet"
  1810.         //: ENGLISH "Timer expired"
  1811.         //: FRANCAIS "Timer expired"
  1812.         errormsg_table[ETIME].msg = GETTEXT("Timer expired");
  1813.         }
  1814.         #endif
  1815.         #ifdef ENOSR
  1816.         if (ENOSR < sys_nerr) {
  1817.         errormsg_table[ENOSR].name = "ENOSR";
  1818.         //: DEUTSCH "Kein Platz für weiteren STREAM"
  1819.         //: ENGLISH "Out of stream resources"
  1820.         //: FRANCAIS "Out of stream resources"
  1821.         errormsg_table[ENOSR].msg = GETTEXT("Out of stream resources");
  1822.         }
  1823.         #endif
  1824.         #ifdef ENOMSG
  1825.         if (ENOMSG < sys_nerr) {
  1826.         errormsg_table[ENOMSG].name = "ENOMSG";
  1827.         //: DEUTSCH "Nachrichten dieses Typs gibt es hier nicht"
  1828.         //: ENGLISH "No message of desired type"
  1829.         //: FRANCAIS "No message of desired type"
  1830.         errormsg_table[ENOMSG].msg = GETTEXT("No message of desired type");
  1831.         }
  1832.         #endif
  1833.         #ifdef EBADMSG
  1834.         if (EBADMSG < sys_nerr) {
  1835.         errormsg_table[EBADMSG].name = "EBADMSG";
  1836.         //: DEUTSCH "Nachricht von unbekanntem Typ angekommen"
  1837.         //: ENGLISH "Not a data message"
  1838.         //: FRANCAIS "Not a data message"
  1839.         errormsg_table[EBADMSG].msg = GETTEXT("Not a data message");
  1840.         }
  1841.         #endif
  1842.         /* Errors bei SystemV IPC: */
  1843.         #ifdef EIDRM
  1844.         if (EIDRM < sys_nerr) {
  1845.         errormsg_table[EIDRM].name = "EIDRM";
  1846.         //: DEUTSCH "Name (einer Semaphore) wurde gelöscht"
  1847.         //: ENGLISH "Identifier removed"
  1848.         //: FRANCAIS "Identificateur supprimé"
  1849.         errormsg_table[EIDRM].msg = GETTEXT("Identifier removed");
  1850.         }
  1851.         #endif
  1852.         /* Errors bei SystemV Record-Locking: */
  1853.         #ifdef EDEADLK
  1854.         if (EDEADLK < sys_nerr) {
  1855.         errormsg_table[EDEADLK].name = "EDEADLK";
  1856.         //: DEUTSCH "Das würde zu einem Deadlock führen"
  1857.         //: ENGLISH "Resource deadlock would occur"
  1858.         //: FRANCAIS "Blocage mutuel de la ressource "
  1859.         errormsg_table[EDEADLK].msg = GETTEXT("Resource deadlock would occur");
  1860.         }
  1861.         #endif
  1862.         #ifdef ENOLCK
  1863.         if (ENOLCK < sys_nerr) {
  1864.         errormsg_table[ENOLCK].name = "ENOLCK";
  1865.         //: DEUTSCH "Zu viele Zugriffsvorbehalte auf einmal"
  1866.         //: ENGLISH "No record locks available"
  1867.         //: FRANCAIS "Pas de verrou disponible"
  1868.         errormsg_table[ENOLCK].msg = GETTEXT("No record locks available");
  1869.         }
  1870.         #endif
  1871.         /* Errors bei Remote File System (RFS): */
  1872.         #ifdef ENONET
  1873.         if (ENONET < sys_nerr) {
  1874.         errormsg_table[ENONET].name = "ENONET";
  1875.         //: DEUTSCH "Rechner nicht übers Netz erreichbar"
  1876.         //: ENGLISH "Machine is not on the network"
  1877.         //: FRANCAIS "La machine n'est pas sur le réseau"
  1878.         errormsg_table[ENONET].msg = GETTEXT("Machine is not on the network");
  1879.         }
  1880.         #endif
  1881.         #ifdef EREMOTE
  1882.         if (EREMOTE < sys_nerr) {
  1883.         errormsg_table[EREMOTE].name = "EREMOTE";
  1884.         //: DEUTSCH "Das kann nur der dortige Rechner"
  1885.         //: ENGLISH "Object is remote"
  1886.         //: FRANCAIS "Objet à distance"
  1887.         errormsg_table[EREMOTE].msg = GETTEXT("Object is remote");
  1888.         }
  1889.         #endif
  1890.         #ifdef ERREMOTE
  1891.         if (ERREMOTE < sys_nerr) {
  1892.         errormsg_table[ERREMOTE].name = "ERREMOTE";
  1893.         //: DEUTSCH "Das kann nur der dortige Rechner"
  1894.         //: ENGLISH "Object is remote"
  1895.         //: FRANCAIS "Objet à distance"
  1896.         errormsg_table[ERREMOTE].msg = GETTEXT("Object is remote");
  1897.         }
  1898.         #endif
  1899.         #ifdef ENOLINK
  1900.         if (ENOLINK < sys_nerr) {
  1901.         errormsg_table[ENOLINK].name = "ENOLINK";
  1902.         //: DEUTSCH "Verbindung ist zusammengebrochen"
  1903.         //: ENGLISH "Link has been severed"
  1904.         //: FRANCAIS "Le lien a été coupé"
  1905.         errormsg_table[ENOLINK].msg = GETTEXT("Link has been severed");
  1906.         }
  1907.         #endif
  1908.         #ifdef EADV
  1909.         if (EADV < sys_nerr) {
  1910.         errormsg_table[EADV].name = "EADV";
  1911.         //: DEUTSCH "Andere Rechner benutzen noch unsere Ressourcen"
  1912.         //: ENGLISH "Advertise error"
  1913.         //: FRANCAIS "Erreur d'annonce"
  1914.         errormsg_table[EADV].msg = GETTEXT("Advertise error");
  1915.         }
  1916.         #endif
  1917.         #ifdef ESRMNT
  1918.         if (ESRMNT < sys_nerr) {
  1919.         errormsg_table[ESRMNT].name = "ESRMNT";
  1920.         //: DEUTSCH "Andere Rechner benutzen noch unsere Ressourcen"
  1921.         //: ENGLISH "Srmount error"
  1922.         //: FRANCAIS "Erreur srmount"
  1923.         errormsg_table[ESRMNT].msg = GETTEXT("Srmount error");
  1924.         }
  1925.         #endif
  1926.         #ifdef ECOMM
  1927.         if (ECOMM < sys_nerr) {
  1928.         errormsg_table[ECOMM].name = "ECOMM";
  1929.         //: DEUTSCH "Beim Senden: Rechner nicht erreichbar"
  1930.         //: ENGLISH "Communication error on send"
  1931.         //: FRANCAIS "Erreur de communication lors d'un envoi"
  1932.         errormsg_table[ECOMM].msg = GETTEXT("Communication error on send");
  1933.         }
  1934.         #endif
  1935.         #ifdef EPROTO
  1936.         if (EPROTO < sys_nerr) {
  1937.         errormsg_table[EPROTO].name = "EPROTO";
  1938.         //: DEUTSCH "Protokoll klappt nicht"
  1939.         //: ENGLISH "Protocol error"
  1940.         //: FRANCAIS "Erreur de protocole"
  1941.         errormsg_table[EPROTO].msg = GETTEXT("Protocol error");
  1942.         }
  1943.         #endif
  1944.         #ifdef EMULTIHOP
  1945.         if (EMULTIHOP < sys_nerr) {
  1946.         errormsg_table[EMULTIHOP].name = "EMULTIHOP";
  1947.         //: DEUTSCH "Ressourcen nicht direkt erreichbar"
  1948.         //: ENGLISH "Multihop attempted"
  1949.         //: FRANCAIS "Tentative de sauts multiples"
  1950.         errormsg_table[EMULTIHOP].msg = GETTEXT("Multihop attempted");
  1951.         }
  1952.         #endif
  1953.         #ifdef EDOTDOT
  1954.         if (EDOTDOT < sys_nerr) {
  1955.         errormsg_table[EDOTDOT].name = "EDOTDOT";
  1956.         //: DEUTSCH "EDOTDOT"
  1957.         //: ENGLISH "EDOTDOT"
  1958.         //: FRANCAIS "EDOTDOT"
  1959.         errormsg_table[EDOTDOT].msg = GETTEXT("EDOTDOT");
  1960.         }
  1961.         #endif
  1962.         #ifdef EREMCHG
  1963.         if (EREMCHG < sys_nerr) {
  1964.         errormsg_table[EREMCHG].name = "EREMCHG";
  1965.         //: DEUTSCH "Rechner hat jetzt eine andere Adresse"
  1966.         //: ENGLISH "Remote address changed"
  1967.         //: FRANCAIS "Adresse à distance changée"
  1968.         errormsg_table[EREMCHG].msg = GETTEXT("Remote address changed");
  1969.         }
  1970.         #endif
  1971.         /* Errors von POSIX: */
  1972.         #ifdef ENOSYS
  1973.         if (ENOSYS < sys_nerr) {
  1974.         errormsg_table[ENOSYS].name = "ENOSYS";
  1975.         //: DEUTSCH "POSIX-Funktion hier nicht implementiert"
  1976.         //: ENGLISH "Function not implemented"
  1977.         //: FRANCAIS "Fonction non implémenté"
  1978.         errormsg_table[ENOSYS].msg = GETTEXT("Function not implemented");
  1979.         }
  1980.         #endif
  1981.         /* Sonstige: */
  1982.         #ifdef EMSDOS /* emx 0.8e - 0.8h */
  1983.         if (EMSDOS < sys_nerr) {
  1984.         errormsg_table[EMSDOS].name = "EMSDOS";
  1985.         //: DEUTSCH "Das geht unter MS-DOS nicht"
  1986.         //: ENGLISH "Not supported under MS-DOS"
  1987.         //: FRANCAIS "Pas supporté sous MS-DOS"
  1988.         errormsg_table[EMSDOS].msg = GETTEXT("Not supported under MS-DOS");
  1989.         }
  1990.         #endif
  1991.         return 0;
  1992.       }
  1993.  
  1994.     global void OS_error_ ()
  1995.       { var reg1 uintC errcode = errno; # positive Fehlernummer
  1996.         end_system_call();
  1997.         clr_break_sem_4(); # keine UNIX-Operation mehr aktiv
  1998.         begin_error(); # Fehlermeldung anfangen
  1999.        {# Meldungbeginn ausgeben:
  2000.         #ifdef UNIX
  2001.         //: DEUTSCH "UNIX-Fehler "
  2002.         //: ENGLISH "UNIX error "
  2003.         //: FRANCAIS "Erreur UNIX "
  2004.         write_errorstring(GETTEXT("Unix error "));
  2005.         #else
  2006.         //: DEUTSCH "UNIX-Bibliotheks-Fehler "
  2007.         //: ENGLISH "UNIX library error "
  2008.         //: FRANCAIS "Erreur dans la librairie UNIX "
  2009.         write_errorstring(GETTEXT("Unix library error "));
  2010.         #endif
  2011.         # Fehlernummer ausgeben:
  2012.         write_errorobject(fixnum(errcode));
  2013.         #if 0
  2014.         { # Fehlermeldung des Betriebssystems ausgeben:
  2015.           if (errcode < sys_nerr)
  2016.             { var reg2 const char* errormsg = sys_errlist[errcode];
  2017.               write_errorstring(": ");
  2018.               write_errorstring(errormsg);
  2019.         }   }
  2020.         #else # nach Möglichkeit noch ausführlicher:
  2021.         { # eigene Fehlermeldung ausgeben:
  2022.           if (errcode < sys_nerr)
  2023.             # Zu dieser Fehlernummer ist ein Text da.
  2024.             { var reg2 const char* errorname = errormsg_table[errcode].name;
  2025.               var reg2 const char* errormsg = errormsg_table[errcode].msg;
  2026.               if (!(errorname[0] == 0)) # bekannter Name?
  2027.                 { write_errorstring(" (");
  2028.                   write_errorstring(errorname);
  2029.                   write_errorstring(")");
  2030.                 }
  2031.               if (!(errormsg[0] == 0)) # nichtleere Meldung?
  2032.                 { write_errorstring(": ");
  2033.                   write_errorstring(errormsg);
  2034.                 }
  2035.         }   }
  2036.         #endif
  2037.        }
  2038.         errno = 0; # Fehlercode löschen (fürs nächste Mal)
  2039.         end_error(args_end_pointer STACKop (4+DYNBIND_SIZE)); # Fehlermeldung beenden
  2040.       }
  2041.  
  2042.   # Ausgabe eines Fehlers, direkt übers Betriebssystem
  2043.   # errno_out(errorcode);
  2044.   # > int errorcode: Fehlercode
  2045.     global void errno_out (int errorcode);
  2046.     global void errno_out(errorcode)
  2047.       var reg1 int errorcode;
  2048.       { asciz_out(" errno = ");
  2049.         if ((uintL)errorcode < sys_nerr)
  2050.           { var reg2 const char* errorname = errormsg_table[errorcode].name;
  2051.             var reg2 const char* errormsg = errormsg_table[errorcode].msg;
  2052.             if (!(errorname[0] == 0)) # bekannter Name?
  2053.               { asciz_out(errorname); }
  2054.               else
  2055.               { dez_out(errorcode); }
  2056.             if (!(errormsg[0] == 0)) # nichtleere Meldung?
  2057.               { asciz_out(": "); asciz_out(errormsg); }
  2058.           }
  2059.           else
  2060.           { dez_out(errorcode); }
  2061.         asciz_out("." CRLFstring);
  2062.       }
  2063.  
  2064. #endif # UNIX || EMUNIX || WATCOM || RISCOS
  2065.  
  2066.   nonreturning_function(global, OS_error_debug, (const char *,int));
  2067.   global void OS_error_debug (const char *filename,int lineno);
  2068.   global void OS_error_debug(filename,lineno)
  2069.     var const char *filename;
  2070.     var int lineno;
  2071.     {
  2072.       asciz_out(CRLFstring "filename: "); asciz_out(filename); 
  2073.       asciz_out(CRLFstring "line: "); dez_out(lineno);
  2074.       asciz_out(CRLFstring);
  2075.       OS_error_();
  2076.     }
  2077.  
  2078. LISPFUN(error,1,0,rest,nokey,0,NIL)
  2079. # (ERROR errorstring {expr})
  2080. # Kehrt nicht zurück.
  2081. # (defun error (errorstring &rest args)
  2082. #   (if (or *error-handler* (not *use-clcs*))
  2083. #     (progn
  2084. #       (if *error-handler*
  2085. #         (apply *error-handler* nil errorstring args)
  2086. #         (progn
  2087. #           (terpri *error-output*)
  2088. #           (write-string "*** - " *error-output*)
  2089. #           (apply #'format *error-output* errorstring args)
  2090. #       ) )
  2091. #       (funcall *break-driver* nil)
  2092. #     )
  2093. #     (let ((condition (coerce-to-condition errorstring args 'error 'simple-error)))
  2094. #       (signal condition)
  2095. #       (invoke-debugger condition)
  2096. #     )
  2097. # ) )
  2098.   { if (!sym_nullp(S(error_handler)) || sym_nullp(S(use_clcs)))
  2099.       { begin_error(); # Fehlermeldung anfangen
  2100.         rest_args_pointer skipSTACKop 1; # Pointer über die Argumente
  2101.         {var reg5 object fun;
  2102.          var reg4 object arg1;
  2103.          if (nullp(STACK_1))
  2104.            { fun = S(format); arg1 = STACK_0; } # (FORMAT *error-output* ...)
  2105.            else
  2106.            { fun = STACK_1; arg1 = NIL; } # (FUNCALL *error-handler* NIL ...)
  2107.          skipSTACK(3);
  2108.          # Errormeldung ausgeben:
  2109.          #   (FORMAT *ERROR-OUTPUT* errorstring {expr})
  2110.          # bzw. ({handler} nil errorstring {expr})
  2111.          pushSTACK(arg1);
  2112.          { var reg1 object* ptr = rest_args_pointer;
  2113.            var reg3 uintC count;
  2114.            dotimespC(count,1+argcount, { pushSTACK(NEXT(ptr)); } );
  2115.          }
  2116.          funcall(fun,2+argcount); # fun (= FORMAT bzw. handler) aufrufen
  2117.         }
  2118.         # Fehlermeldung beenden, vgl. end_error():
  2119.         dynamic_unbind(); # Keine Fehlermeldungs-Ausgabe mehr aktiv
  2120.         set_args_end_pointer(rest_args_pointer); # STACK aufräumen
  2121.         break_driver(NIL); # Break-Driver aufrufen (kehrt nicht zurück)
  2122.       }
  2123.       else
  2124.       { {var reg1 object arguments = listof(argcount); pushSTACK(arguments); }
  2125.         pushSTACK(S(error));
  2126.         pushSTACK(S(simple_error));
  2127.         funcall(S(coerce_to_condition),4); # (SYS::COERCE-TO-CONDITION ...)
  2128.         pushSTACK(value1); # condition retten
  2129.         pushSTACK(value1); funcall(L(clcs_signal),1); # (SIGNAL condition)
  2130.         dynamic_bind(S(prin_stream),unbound); # SYS::*PRIN-STREAM* an #<UNBOUND> binden
  2131.         pushSTACK(STACK_(0+DYNBIND_SIZE)); # condition
  2132.         funcall(L(invoke_debugger),1); # (INVOKE-DEBUGGER condition)
  2133.       }
  2134.     NOTREACHED
  2135.   }
  2136.  
  2137. LISPFUNN(defclcs,1)
  2138. # (SYSTEM::%DEFCLCS error-types)
  2139. # setzt die für ERROR-OF-TYPE benötigten Daten.
  2140.   { O(error_types) = popSTACK();
  2141.     value1 = NIL; mv_count=0;
  2142.   }
  2143.  
  2144. # Konvertiert einen Condition-Typ zur entsprechenden Simple-Condition.
  2145. # convert_simple_condition(type)
  2146.   local object convert_simple_condition (object type);
  2147.   local object convert_simple_condition(type)
  2148.     var reg2 object type;
  2149.     { # Vektor O(error_types) wie eine Aliste durchlaufen:
  2150.       var reg4 object v = O(error_types);
  2151.       var reg1 object* ptr = &TheSvector(v)->data[0];
  2152.       var reg3 uintL count;
  2153.       dotimesL(count,TheSvector(v)->length,
  2154.                { if (eq(type,Car(*ptr))) { return Cdr(*ptr); }
  2155.                  ptr++;
  2156.                });
  2157.       return type; # nicht gefunden -> Typ unverändert lassen
  2158.     }
  2159.  
  2160. LISPFUN(error_of_type,2,0,rest,nokey,0,NIL)
  2161. # (SYSTEM::ERROR-OF-TYPE type {keyword value}* errorstring {expr}*)
  2162. # Kehrt nicht zurück.
  2163. # (defun error-of-type (type &rest arguments)
  2164. #   ; Keyword-Argumente von den anderen Argumenten abspalten:
  2165. #   (let ((keyword-arguments '()))
  2166. #     (loop
  2167. #       (unless (and (consp arguments) (keywordp (car arguments))) (return))
  2168. #       (push (pop arguments) keyword-arguments)
  2169. #       (push (pop arguments) keyword-arguments)
  2170. #     )
  2171. #     (setq keyword-arguments (nreverse keyword-arguments))
  2172. #     (let ((errorstring (first arguments))
  2173. #           (args (rest arguments)))
  2174. #       ; Los geht's!
  2175. #       (if (or *error-handler* (not *use-clcs*))
  2176. #         (progn
  2177. #           (if *error-handler*
  2178. #             (apply *error-handler* nil errorstring args)
  2179. #             (progn
  2180. #               (terpri *error-output*)
  2181. #               (write-string "*** - " *error-output*)
  2182. #               (apply #'format *error-output* errorstring args)
  2183. #           ) )
  2184. #           (funcall *break-driver* nil)
  2185. #         )
  2186. #         (let ((condition
  2187. #                 (apply #'coerce-to-condition errorstring args
  2188. #                        'error (convert-simple-condition type) keyword-arguments
  2189. #              )) )
  2190. #           (signal condition)
  2191. #           (invoke-debugger condition)
  2192. #         )
  2193. # ) ) ) )
  2194.   { var reg6 uintC keyword_argcount = 0;
  2195.     rest_args_pointer skipSTACKop 1; # Pointer über die Argumente hinter type
  2196.     while (argcount>=2)
  2197.       { var reg3 object next_arg = Next(rest_args_pointer); # nächstes Argument
  2198.         if (!(symbolp(next_arg) && keywordp(next_arg))) break; # Keyword?
  2199.         rest_args_pointer skipSTACKop -2; argcount -= 2; keyword_argcount += 2;
  2200.       }
  2201.     # Nächstes Argument hoffentlich ein String.
  2202.     if (!sym_nullp(S(error_handler)) || sym_nullp(S(use_clcs)))
  2203.       { # Der Typ und die Keyword-Argumente werden ignoriert.
  2204.         begin_error(); # Fehlermeldung anfangen
  2205.         {var reg5 object fun;
  2206.          var reg4 object arg1;
  2207.          if (nullp(STACK_1))
  2208.            { fun = S(format); arg1 = STACK_0; } # (FORMAT *error-output* ...)
  2209.            else
  2210.            { fun = STACK_1; arg1 = NIL; } # (FUNCALL *error-handler* NIL ...)
  2211.          skipSTACK(3);
  2212.          # Errormeldung ausgeben:
  2213.          #   (FORMAT *ERROR-OUTPUT* errorstring {expr})
  2214.          # bzw. ({handler} nil errorstring {expr})
  2215.          pushSTACK(arg1);
  2216.          { var reg1 object* ptr = rest_args_pointer;
  2217.            var reg3 uintC count;
  2218.            dotimespC(count,1+argcount, { pushSTACK(NEXT(ptr)); } );
  2219.          }
  2220.          funcall(fun,2+argcount); # fun (= FORMAT bzw. handler) aufrufen
  2221.         }
  2222.         # Fehlermeldung beenden, vgl. end_error():
  2223.         dynamic_unbind(); # Keine Fehlermeldungs-Ausgabe mehr aktiv
  2224.         set_args_end_pointer(rest_args_pointer); # STACK aufräumen
  2225.         break_driver(NIL); # Break-Driver aufrufen (kehrt nicht zurück)
  2226.       }
  2227.       else
  2228.       { var reg5 object arguments = listof(argcount);
  2229.         # Stackaufbau: type, {keyword, value}*, errorstring.
  2230.         # Ein wenig im Stack umordnen:
  2231.         var reg4 object errorstring = STACK_0;
  2232.         pushSTACK(NIL); pushSTACK(NIL);
  2233.         { var reg1 object* ptr2 = args_end_pointer;
  2234.           var reg2 object* ptr1 = ptr2 STACKop 3;
  2235.           var reg3 uintC count;
  2236.           dotimesC(count,keyword_argcount, { BEFORE(ptr2) = BEFORE(ptr1); } );
  2237.           BEFORE(ptr2) = convert_simple_condition(BEFORE(ptr1));
  2238.           BEFORE(ptr2) = S(error);
  2239.           BEFORE(ptr2) = arguments;
  2240.           BEFORE(ptr2) = errorstring;
  2241.         }
  2242.         # Stackaufbau: errorstring, args, ERROR, type, {keyword, value}*.
  2243.         funcall(S(coerce_to_condition),4+keyword_argcount); # (SYS::COERCE-TO-CONDITION ...)
  2244.         pushSTACK(value1); # condition retten
  2245.         pushSTACK(value1); funcall(L(clcs_signal),1); # (SIGNAL condition)
  2246.         dynamic_bind(S(prin_stream),unbound); # SYS::*PRIN-STREAM* an #<UNBOUND> binden
  2247.         pushSTACK(STACK_(0+DYNBIND_SIZE)); # condition
  2248.         funcall(L(invoke_debugger),1); # (INVOKE-DEBUGGER condition)
  2249.       }
  2250.     NOTREACHED
  2251.   }
  2252.  
  2253. LISPFUNN(invoke_debugger,1)
  2254. # (INVOKE-DEBUGGER condition), CLtL2 S. 915
  2255. # Kehrt nicht zurück.
  2256. # (defun invoke-debugger (condition)
  2257. #   (when *debugger-hook*
  2258. #     (let ((debugger-hook *debugger-hook*)
  2259. #           (*debugger-hook* nil))
  2260. #       (funcall debugger-hook condition debugger-hook)
  2261. #   ) )
  2262. #   (funcall *break-driver* nil condition t)
  2263. # )
  2264.   { var reg1 object hook = Symbol_value(S(debugger_hook));
  2265.     if (!nullp(hook))
  2266.       { var reg2 object condition = STACK_0;
  2267.         dynamic_bind(S(debugger_hook),NIL); # *DEBUGGER-HOOK* an NIL binden
  2268.         pushSTACK(condition); pushSTACK(hook); funcall(hook,2); # Debugger-Hook aufrufen
  2269.         dynamic_unbind();
  2270.       }
  2271.     # *BREAK-DRIVER* kann hier als /= NIL angenommen werden.
  2272.     pushSTACK(NIL); pushSTACK(STACK_(0+1)); pushSTACK(T);
  2273.     funcall(Symbol_value(S(break_driver)),3); # Break-Driver aufrufen
  2274.     reset(); # kehrt wider Erwarten zurück -> zur nächsten Schleife zurück
  2275.     NOTREACHED
  2276.   }
  2277.  
  2278. # UP: Führt eine Break-Schleife wegen Tastaturunterbrechung aus.
  2279. # > STACK_0 : aufrufende Funktion
  2280. # verändert STACK, kann GC auslösen
  2281.   global void tast_break (void);
  2282.   global void tast_break()
  2283.     {
  2284.       #ifdef PENDING_INTERRUPTS
  2285.       interrupt_pending = FALSE; # Ctrl-C-Wartezeit ist gleich beendet
  2286.       begin_system_call();
  2287.       #ifdef HAVE_UALARM
  2288.       ualarm(0,0); # SIGALRM-Timer abbrechen
  2289.       #else
  2290.       #ifdef EMUNIX_OLD_8h # EMX-Bug umgehen
  2291.       alarm(1000);
  2292.       #endif
  2293.       alarm(0); # SIGALRM-Timer abbrechen
  2294.       #endif
  2295.       end_system_call();
  2296.       #endif
  2297.       # Simuliere begin_error(), 7 Elemente auf den STACK:
  2298.       pushSTACK(NIL); pushSTACK(NIL); pushSTACK(NIL);
  2299.       pushSTACK(NIL); pushSTACK(NIL); pushSTACK(NIL);
  2300.       pushSTACK(var_stream(S(debug_io),strmflags_wr_ch_B)); # Stream *DEBUG-IO*
  2301.       terpri(&STACK_0); # neue Zeile
  2302.       write_sstring(&STACK_0,O(error_string1)); # "*** - " ausgeben
  2303.       # String ausgeben, Aufrufernamen verbrauchen, STACK aufräumen:
  2304.       //: DEUTSCH "~: Tastatur-Interrupt"
  2305.       //: ENGLISH "~: User break"
  2306.       //: FRANCAIS "~ : Interruption clavier"
  2307.       set_args_end_pointer(write_errorstring(GETTEXT("~: User break")));
  2308.       break_driver(T); # Break-Driver aufrufen
  2309.     }
  2310.  
  2311. LISPFUN(clcs_signal,1,0,rest,nokey,0,NIL)
  2312. # (SIGNAL datum {arg}*), CLtL2 S. 888
  2313. # (defun signal (datum &rest arguments)
  2314. #   (let ((condition
  2315. #           (coerce-to-condition datum arguments 'signal
  2316. #                                'simple-condition ; CLtL2 p. 918 specifies this
  2317. #        )) )
  2318. #     (when (typep condition *break-on-signals*)
  2319. #       ; Enter the debugger prior to signalling the condition
  2320. #       (restart-case (invoke-debugger condition)
  2321. #         (continue ())
  2322. #     ) )
  2323. #     (invoke-handlers condition)
  2324. #     nil
  2325. # ) )
  2326.   { {var reg1 object arguments = listof(argcount); pushSTACK(arguments); }
  2327.     pushSTACK(S(clcs_signal));
  2328.     pushSTACK(S(simple_condition));
  2329.     funcall(S(coerce_to_condition),4); # (SYS::COERCE-TO-CONDITION ...)
  2330.     pushSTACK(value1); # condition retten
  2331.     pushSTACK(value1); pushSTACK(Symbol_value(S(break_on_signals)));
  2332.     funcall(S(safe_typep),2); # (SYS::SAFE-TYPEP condition *BREAK-ON-SIGNALS*)
  2333.     if (!nullp(value1))
  2334.       # Break-Driver aufrufen: (funcall *break-driver* t condition t)
  2335.       { # *BREAK-DRIVER* kann hier als /= NIL angenommen werden.
  2336.         pushSTACK(T); pushSTACK(STACK_(0+1)); pushSTACK(T);
  2337.         funcall(Symbol_value(S(break_driver)),3);
  2338.       }
  2339.    {var reg1 object condition = popSTACK(); # condition zurück
  2340.     invoke_handlers(condition); # Handler aufrufen
  2341.     value1 = NIL; mv_count=1; # Wert NIL
  2342.   }}
  2343.  
  2344. # Fehlermeldung, wenn ein Objekt keine Liste ist.
  2345. # fehler_list(obj);
  2346. # > arg: Nicht-Liste
  2347. # > subr_self: Aufrufer (ein SUBR)
  2348.   nonreturning_function(global, fehler_list, (object obj));
  2349.   global void fehler_list(obj)
  2350.     var reg1 object obj;
  2351.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2352.       pushSTACK(S(list)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2353.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2354.       //: DEUTSCH "~: ~ ist keine Liste."
  2355.       //: ENGLISH "~: ~ is not a list"
  2356.       //: FRANCAIS "~ : ~ n'est pas une liste."
  2357.       fehler(type_error, GETTEXT("~: ~ is not a list"));
  2358.     }
  2359.  
  2360. # Fehlermeldung, wenn ein Objekt kein Symbol ist.
  2361. # fehler_kein_symbol(caller,obj);
  2362. # > caller: Aufrufer (ein Symbol)
  2363. # > obj: Nicht-Symbol
  2364.   nonreturning_function(global, fehler_kein_symbol, (object caller, object obj));
  2365.   global void fehler_kein_symbol(caller,obj)
  2366.     var reg2 object caller;
  2367.     var reg1 object obj;
  2368.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2369.       pushSTACK(S(symbol)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2370.       pushSTACK(obj);
  2371.       pushSTACK(caller);
  2372.       //: DEUTSCH "~: ~ ist kein Symbol."
  2373.       //: ENGLISH "~: ~ is not a symbol"
  2374.       //: FRANCAIS "~ : ~ n'est pas un symbole."
  2375.       fehler(type_error, GETTEXT("~: ~ is not a symbol"));
  2376.     }
  2377.  
  2378. # Fehlermeldung, wenn ein Objekt kein Symbol ist.
  2379. # fehler_symbol(obj);
  2380. # > subr_self: Aufrufer (ein SUBR oder FSUBR)
  2381. # > obj: Nicht-Symbol
  2382.   nonreturning_function(global, fehler_symbol, (object obj));
  2383.   global void fehler_symbol(obj)
  2384.     var reg2 object obj;
  2385.     { var reg1 object aufrufer = subr_self;
  2386.       aufrufer = (subrp(aufrufer) ? TheSubr(aufrufer)->name : TheFsubr(aufrufer)->name);
  2387.       fehler_kein_symbol(aufrufer,obj);
  2388.     }
  2389.  
  2390. # Fehlermeldung, wenn ein Objekt kein Simple-Vector ist.
  2391. # fehler_kein_svector(caller,obj);
  2392. # > caller: Aufrufer (ein Symbol)
  2393. # > obj: Nicht-Svector
  2394.   nonreturning_function(global, fehler_kein_svector, (object caller, object obj));
  2395.   global void fehler_kein_svector(caller,obj)
  2396.     var reg2 object caller;
  2397.     var reg1 object obj;
  2398.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2399.       pushSTACK(S(simple_vector)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2400.       pushSTACK(obj);
  2401.       pushSTACK(caller);
  2402.       //: DEUTSCH "~: ~ ist kein Simple-Vector."
  2403.       //: ENGLISH "~: ~ is not a simple-vector"
  2404.       //: FRANCAIS "~: ~ n'est pas de type SIMPLE-VECTOR."
  2405.       fehler(type_error, GETTEXT("~: ~ is not a simple-vector"));
  2406.     }
  2407.  
  2408. # Fehlermeldung, wenn ein Objekt kein Vektor ist.
  2409. # fehler_vector(obj);
  2410. # > subr_self: Aufrufer (ein SUBR)
  2411. # > obj: Nicht-Vektor
  2412.   nonreturning_function(global, fehler_vector, (object obj));
  2413.   global void fehler_vector(obj)
  2414.     var reg1 object obj;
  2415.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2416.       pushSTACK(S(vector)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2417.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2418.       //: DEUTSCH "~: ~ ist kein Vektor."
  2419.       //: ENGLISH "~: ~ is not a vector"
  2420.       //: FRANCAIS "~: ~ n'est pas un vecteur."
  2421.       fehler(type_error, GETTEXT("~: ~ is not a vector"));
  2422.     }
  2423.  
  2424. # Fehlermeldung, falls ein Argument kein Character ist:
  2425. # fehler_char(obj);
  2426. # > obj: Das fehlerhafte Argument
  2427. # > subr_self: Aufrufer (ein SUBR)
  2428.   nonreturning_function(global, fehler_char, (object obj));
  2429.   global void fehler_char(obj)
  2430.     var reg1 object obj;
  2431.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2432.       pushSTACK(S(character)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2433.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2434.       //: DEUTSCH "~: Argument ~ ist kein Character."
  2435.       //: ENGLISH "~: argument ~ is not a character"
  2436.       //: FRANCAIS "~: L'argument ~ n'est pas un caractère."
  2437.       fehler(type_error, GETTEXT("~: argument ~ is not a character"));
  2438.     }
  2439.  
  2440. # Fehler, wenn Argument kein String-Char ist.
  2441. # fehler_string_char(obj);
  2442. # > obj: fehlerhaftes Argument
  2443. # > subr_self: Aufrufer (ein SUBR)
  2444.   nonreturning_function(global, fehler_string_char, (object obj));
  2445.   global void fehler_string_char(obj)
  2446.     var reg1 object obj;
  2447.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2448.       pushSTACK(S(string_char)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2449.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2450.       //: DEUTSCH "~: ~ ist kein String-Char."
  2451.       //: ENGLISH "~: ~ is not a string-char"
  2452.       //: FRANCAIS "~ : ~ n'est pas de type STRING-CHAR."
  2453.       fehler(type_error, GETTEXT("~: ~ is not a string-char"));
  2454.     }
  2455.  
  2456. # Fehlermeldung, falls ein Argument kein String ist:
  2457. # > obj: Das fehlerhafte Argument
  2458. # > subr_self: Aufrufer (ein SUBR)
  2459.   nonreturning_function(global, fehler_string, (object obj));
  2460.   global void fehler_string(obj)
  2461.     var reg1 object obj;
  2462.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2463.       pushSTACK(S(string)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2464.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2465.       //: DEUTSCH "~: Argument ~ ist kein String."
  2466.       //: ENGLISH "~: argument ~ is not a string"
  2467.       //: FRANCAIS "~: L'argument ~ n'est pas une chaîne."
  2468.       fehler(type_error, GETTEXT("~: argument ~ is not a string"));
  2469.     }
  2470.  
  2471. # Fehlermeldung, falls ein Argument kein Simple-String ist:
  2472. # > obj: Das fehlerhafte Argument
  2473. # > subr_self: Aufrufer (ein SUBR)
  2474.   nonreturning_function(global, fehler_sstring, (object obj));
  2475.   global void fehler_sstring(obj)
  2476.     var reg1 object obj;
  2477.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2478.       pushSTACK(S(simple_string)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2479.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2480.       //: DEUTSCH "~: Argument ~ ist kein Simple-String."
  2481.       //: ENGLISH "~: argument ~ is not a simple string"
  2482.       //: FRANCAIS "~: L'argument ~ n'est pas de type SIMPLE-STRING."
  2483.       fehler(type_error, GETTEXT("~: argument ~ is not a simple string"));
  2484.     }
  2485.  
  2486. # Fehlermeldung, wenn ein Argument kein Stream ist:
  2487. # fehler_stream(obj);
  2488. # > obj: Das fehlerhafte Argument
  2489. # > subr_self: Aufrufer (ein SUBR)
  2490.   nonreturning_function(global, fehler_stream, (object obj));
  2491.   global void fehler_stream(obj)
  2492.     var reg1 object obj;
  2493.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2494.       pushSTACK(S(stream)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2495.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2496.       //: DEUTSCH "~: Argument muß ein Stream sein, nicht ~"
  2497.       //: ENGLISH "~: argument ~ should be a stream"
  2498.       //: FRANCAIS "~ : L'argument doit être de type STREAM et non pas ~."
  2499.       fehler(type_error, GETTEXT("~: argument ~ should be a stream"));
  2500.     }
  2501.  
  2502. # Fehlermeldung, wenn ein Argument kein Stream vom geforderten Stream-Typ ist:
  2503. # fehler_streamtype(obj,type);
  2504. # > obj: Das fehlerhafte Argument
  2505. # > type: geforderten Stream-Typ
  2506. # > subr_self: Aufrufer (ein SUBR)
  2507.   nonreturning_function(global, fehler_streamtype, (object obj, object type));
  2508.   global void fehler_streamtype(obj,type)
  2509.     var reg1 object obj;
  2510.     var reg2 object type;
  2511.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2512.       pushSTACK(type); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2513.       pushSTACK(type); pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2514.       //: DEUTSCH "~: Argument ~ sollte ein Stream vom Typ ~ sein."
  2515.       //: ENGLISH "~: argument ~ should be a stream of type ~"
  2516.       //: FRANCAIS "~ : L'argument ~ devrait être de type ~."
  2517.       fehler(type_error, GETTEXT("~: argument ~ should be a stream of type ~"));
  2518.     }
  2519.  
  2520. #ifdef HAVE_FFI
  2521.  
  2522. # Fehler, wenn Argument kein Integer vom Typ `uint8' ist.
  2523. # fehler_uint8(obj);
  2524. # > obj: fehlerhaftes Argument
  2525. # > subr_self: Aufrufer (ein SUBR)
  2526.   nonreturning_function(global, fehler_uint8, (object obj));
  2527.   global void fehler_uint8(obj)
  2528.     var reg1 object obj;
  2529.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2530.       pushSTACK(O(type_uint8)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2531.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2532.       //: DEUTSCH "~: ~ ist keine 8-bit-Zahl."
  2533.       //: ENGLISH "~: ~ is not an 8-bit number"
  2534.       //: FRANCAIS "~ : ~ n'est pas un nombre à 8 bits."
  2535.       fehler(type_error, GETTEXT("~: ~ is not an 8-bit number"));
  2536.     }
  2537.  
  2538. # Fehler, wenn Argument kein Integer vom Typ `sint8' ist.
  2539. # fehler_sint8(obj);
  2540. # > obj: fehlerhaftes Argument
  2541. # > subr_self: Aufrufer (ein SUBR)
  2542.   nonreturning_function(global, fehler_sint8, (object obj));
  2543.   global void fehler_sint8(obj)
  2544.     var reg1 object obj;
  2545.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2546.       pushSTACK(O(type_sint8)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2547.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2548.       //: DEUTSCH "~: ~ ist keine 8-bit-Zahl."
  2549.       //: ENGLISH "~: ~ is not an 8-bit number"
  2550.       //: FRANCAIS "~ : ~ n'est pas un nombre à 8 bits."
  2551.       fehler(type_error, GETTEXT("~: ~ is not an 8-bit number"));
  2552.     }
  2553.  
  2554. # Fehler, wenn Argument kein Integer vom Typ `uint16' ist.
  2555. # fehler_uint16(obj);
  2556. # > obj: fehlerhaftes Argument
  2557. # > subr_self: Aufrufer (ein SUBR)
  2558.   nonreturning_function(global, fehler_uint16, (object obj));
  2559.   global void fehler_uint16(obj)
  2560.     var reg1 object obj;
  2561.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2562.       pushSTACK(O(type_uint16)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2563.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2564.       //: DEUTSCH "~: ~ ist keine 16-bit-Zahl."
  2565.       //: ENGLISH "~: ~ is not a 16-bit number"
  2566.       //: FRANCAIS "~ : ~ n'est pas un nombre à 16 bits."
  2567.       fehler(type_error, GETTEXT("~: ~ is not a 16-bit number"));
  2568.     }
  2569.  
  2570. # Fehler, wenn Argument kein Integer vom Typ `sint16' ist.
  2571. # fehler_sint16(obj);
  2572. # > obj: fehlerhaftes Argument
  2573. # > subr_self: Aufrufer (ein SUBR)
  2574.   nonreturning_function(global, fehler_sint16, (object obj));
  2575.   global void fehler_sint16(obj)
  2576.     var reg1 object obj;
  2577.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2578.       pushSTACK(O(type_sint16)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2579.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2580.       //: DEUTSCH "~: ~ ist keine 16-bit-Zahl."
  2581.       //: ENGLISH "~: ~ is not a 16-bit number"
  2582.       //: FRANCAIS "~ : ~ n'est pas un nombre à 16 bits."
  2583.       fehler(type_error, GETTEXT("~: ~ is not a 16-bit number"));
  2584.     }
  2585.  
  2586. # Fehler, wenn Argument kein Integer vom Typ `uint32' ist.
  2587. # fehler_uint32(obj);
  2588. # > obj: fehlerhaftes Argument
  2589. # > subr_self: Aufrufer (ein SUBR)
  2590.   nonreturning_function(global, fehler_uint32, (object obj));
  2591.   global void fehler_uint32(obj)
  2592.     var reg1 object obj;
  2593.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2594.       pushSTACK(O(type_uint32)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2595.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2596.       //: DEUTSCH "~: ~ ist keine 32-bit-Zahl."
  2597.       //: ENGLISH "~: ~ is not an 32-bit number"
  2598.       //: FRANCAIS "~ : ~ n'est pas un nombre à 32 bits."
  2599.       fehler(type_error, GETTEXT("~: ~ is not an 32-bit number"));
  2600.     }
  2601.  
  2602. # Fehler, wenn Argument kein Integer vom Typ `sint32' ist.
  2603. # fehler_sint32(obj);
  2604. # > obj: fehlerhaftes Argument
  2605. # > subr_self: Aufrufer (ein SUBR)
  2606.   nonreturning_function(global, fehler_sint32, (object obj));
  2607.   global void fehler_sint32(obj)
  2608.     var reg1 object obj;
  2609.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2610.       pushSTACK(O(type_sint32)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2611.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2612.       //: DEUTSCH "~: ~ ist keine 32-bit-Zahl."
  2613.       //: ENGLISH "~: ~ is not an 32-bit number"
  2614.       //: FRANCAIS "~ : ~ n'est pas un nombre à 32 bits."
  2615.       fehler(type_error, GETTEXT("~: ~ is not an 32-bit number"));
  2616.     }
  2617.  
  2618. # Fehler, wenn Argument kein Integer vom Typ `uint64' ist.
  2619. # fehler_uint64(obj);
  2620. # > obj: fehlerhaftes Argument
  2621. # > subr_self: Aufrufer (ein SUBR)
  2622.   nonreturning_function(global, fehler_uint64, (object obj));
  2623.   global void fehler_uint64(obj)
  2624.     var reg1 object obj;
  2625.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2626.       pushSTACK(O(type_uint64)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2627.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2628.       //: DEUTSCH "~: ~ ist keine 64-bit-Zahl."
  2629.       //: ENGLISH "~: ~ is not an 64-bit number"
  2630.       //: FRANCAIS "~ : ~ n'est pas un nombre à 64 bits."
  2631.       fehler(type_error, GETTEXT("~: ~ is not an 64-bit number"));
  2632.     }
  2633.  
  2634. # Fehler, wenn Argument kein Integer vom Typ `sint64' ist.
  2635. # fehler_sint64(obj);
  2636. # > obj: fehlerhaftes Argument
  2637. # > subr_self: Aufrufer (ein SUBR)
  2638.   nonreturning_function(global, fehler_sint64, (object obj));
  2639.   global void fehler_sint64(obj)
  2640.     var reg1 object obj;
  2641.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2642.       pushSTACK(O(type_sint64)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2643.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2644.       //: DEUTSCH "~: ~ ist keine 64-bit-Zahl."
  2645.       //: ENGLISH "~: ~ is not an 64-bit number"
  2646.       //: FRANCAIS "~ : ~ n'est pas un nombre à 64 bits."
  2647.       fehler(type_error, GETTEXT("~: ~ is not an 64-bit number"));
  2648.     }
  2649.  
  2650. # Fehler, wenn Argument kein Integer vom Typ `uint' ist.
  2651. # fehler_uint(obj);
  2652. # > obj: fehlerhaftes Argument
  2653. # > subr_self: Aufrufer (ein SUBR)
  2654.   nonreturning_function(global, fehler_uint, (object obj));
  2655.   global void fehler_uint(obj)
  2656.     var reg1 object obj;
  2657.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2658.       #if (int_bitsize==16)
  2659.       pushSTACK(O(type_uint16)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2660.       #else # (int_bitsize==32)
  2661.       pushSTACK(O(type_uint32)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2662.       #endif
  2663.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2664.       //: DEUTSCH "~: ~ ist keine `unsigned int'-Zahl."
  2665.       //: ENGLISH "~: ~ is not an `unsigned int' number"
  2666.       //: FRANCAIS "~ : ~ n'est pas un nombre «unsigned int»."
  2667.       fehler(type_error, GETTEXT("~: ~ is not an `unsigned int' number"));
  2668.     }
  2669.  
  2670. # Fehler, wenn Argument kein Integer vom Typ `sint' ist.
  2671. # fehler_sint(obj);
  2672. # > obj: fehlerhaftes Argument
  2673. # > subr_self: Aufrufer (ein SUBR)
  2674.   nonreturning_function(global, fehler_sint, (object obj));
  2675.   global void fehler_sint(obj)
  2676.     var reg1 object obj;
  2677.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2678.       #if (int_bitsize==16)
  2679.       pushSTACK(O(type_sint16)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2680.       #else # (int_bitsize==32)
  2681.       pushSTACK(O(type_sint32)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2682.       #endif
  2683.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2684.       //: DEUTSCH "~: ~ ist keine `int'-Zahl."
  2685.       //: ENGLISH "~: ~ is not an `int' number"
  2686.       //: FRANCAIS "~ : ~ n'est pas un nombre «int»."
  2687.       fehler(type_error, GETTEXT("~: ~ is not an `int' number"));
  2688.     }
  2689.  
  2690. # Fehler, wenn Argument kein Integer vom Typ `ulong' ist.
  2691. # fehler_ulong(obj);
  2692. # > obj: fehlerhaftes Argument
  2693. # > subr_self: Aufrufer (ein SUBR)
  2694.   nonreturning_function(global, fehler_ulong, (object obj));
  2695.   global void fehler_ulong(obj)
  2696.     var reg1 object obj;
  2697.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2698.       #if (long_bitsize==32)
  2699.       pushSTACK(O(type_uint32)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2700.       #else # (long_bitsize==64)
  2701.       pushSTACK(O(type_uint64)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2702.       #endif
  2703.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2704.       //: DEUTSCH "~: ~ ist keine `unsigned long'-Zahl."
  2705.       //: ENGLISH "~: ~ is not a `unsigned long' number"
  2706.       //: FRANCAIS "~ : ~ n'est pas un nombre «unsigned long»."
  2707.       fehler(type_error, GETTEXT("~: ~ is not a `unsigned long' number"));
  2708.     }
  2709.  
  2710. # Fehler, wenn Argument kein Integer vom Typ `slong' ist.
  2711. # fehler_slong(obj);
  2712. # > obj: fehlerhaftes Argument
  2713. # > subr_self: Aufrufer (ein SUBR)
  2714.   nonreturning_function(global, fehler_slong, (object obj));
  2715.   global void fehler_slong(obj)
  2716.     var reg1 object obj;
  2717.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2718.       #if (long_bitsize==32)
  2719.       pushSTACK(O(type_sint32)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2720.       #else # (long_bitsize==64)
  2721.       pushSTACK(O(type_sint64)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2722.       #endif
  2723.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2724.       //: DEUTSCH "~: ~ ist keine `long'-Zahl."
  2725.       //: ENGLISH "~: ~ is not a `long' number"
  2726.       //: FRANCAIS "~ : ~ n'est pas un nombre «long»."
  2727.       fehler(type_error, GETTEXT("~: ~ is not a `long' number"));
  2728.     }
  2729.  
  2730. # Fehler, wenn Argument kein Single-Float ist.
  2731. # fehler_ffloat(obj);
  2732. # > obj: fehlerhaftes Argument
  2733. # > subr_self: Aufrufer (ein SUBR)
  2734.   nonreturning_function(global, fehler_ffloat, (object obj));
  2735.   global void fehler_ffloat(obj)
  2736.     var reg1 object obj;
  2737.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2738.       pushSTACK(S(single_float)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2739.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2740.       //: DEUTSCH "~: ~ ist kein Single-Float."
  2741.       //: ENGLISH "~: ~ is not a single-float"
  2742.       //: FRANCAIS "~ : ~ n'est pas de type SINGLE-FLOAT."
  2743.       fehler(type_error, GETTEXT("~: ~ is not a single-float"));
  2744.     }
  2745.  
  2746. # Fehler, wenn Argument kein Double-Float ist.
  2747. # fehler_dfloat(obj);
  2748. # > obj: fehlerhaftes Argument
  2749. # > subr_self: Aufrufer (ein SUBR)
  2750.   nonreturning_function(global, fehler_dfloat, (object obj));
  2751.   global void fehler_dfloat(obj)
  2752.     var reg1 object obj;
  2753.     { pushSTACK(obj); # Wert für Slot DATUM von TYPE-ERROR
  2754.       pushSTACK(S(double_float)); # Wert für Slot EXPECTED-TYPE von TYPE-ERROR
  2755.       pushSTACK(obj); pushSTACK(TheSubr(subr_self)->name);
  2756.       //: DEUTSCH "~: ~ ist kein Double-Float."
  2757.       //: ENGLISH "~: ~ is not a double-float"
  2758.       //: FRANCAIS "~ : ~ n'est pas de type DOUBLE-FLOAT."
  2759.       fehler(type_error, GETTEXT("~: ~ is not a double-float"));
  2760.     }
  2761.  
  2762. #endif
  2763.  
  2764.