/* e4error.c (c)Copyright Sequiter Software Inc., 1990-1994. All rights reserved. */ #include "d4all.h" #ifndef S4UNIX #ifdef __TURBOC__ #pragma hdrstop #endif /* __TUROBC__ */ #endif /* S4UNIX */ #ifndef S4WINDOWS #ifndef S4UNIX #include #endif /* S4UNIX */ #endif /* not S4WINDOWS */ #ifdef S4OS2PM #define E4MSGBOXID 9513 static void do_error_box( void ) ; #endif #ifdef S4VB_DOS #define V4ERROR 1 #define V4SEVERE 2 #endif #ifndef S4TEST /* Add alternative error display code here. Function e4hook() may be placed in your own separate source code file, but ensure that the same function prototype as below is used. */ void S4FUNCTION e4hook( CODE4 S4PTR *c4, int err_code, char *desc1, char *desc2, char *desc3 ) { return ; } #endif #ifdef S4TESTING extern int s4test_handle ; #endif #ifdef S4WINDOWS #ifdef __TURBOC__ #if __TURBOC__ == 0x297 /* if Borland C++ 2.0 */ #ifdef __cplusplus extern "C"{ void FAR PASCAL FatalAppExit(WORD,LPSTR) ; } #else void FAR PASCAL FatalAppExit(WORD,LPSTR) ; #endif /* __cplusplus */ #endif /* __TUROBC__ == 0x297 */ #endif /* __TUROBC__ */ #ifndef __SC__ #ifdef __ZTC__ #ifdef __cplusplus extern "C"{ void FAR PASCAL FatalAppExit(unsigned short,LPSTR) ; } #else void FAR PASCAL FatalAppExit(unsigned short,LPSTR) ; #endif /* __cplusplus */ #endif /* __ZTC__ */ #endif /* __SC__ */ #ifdef _MSC_VER #if _MSC_VER == 600 #ifdef __cplusplus extern "C"{ void FAR PASCAL FatalAppExit(WORD,LPSTR) ; } #else void FAR PASCAL FatalAppExit(WORD,LPSTR) ; #endif /* __cplusplus */ #endif /* _MSC_VER == 600 */ #endif /* _MSC_VER */ #endif /* S4WINDOWS */ #ifndef S4OFF_ERROR #ifndef S4LANGUAGE ERROR_DATA e4error_data[] = { /* General Disk Access Errors */ { e4create, "Creating File" }, { e4open, "Opening File" }, { e4read, "Reading File" }, { e4seek, "Seeking to File Position" }, { e4write, "Writing to File" }, { e4close, "Closing File" }, { e4remove, "Removing File" }, { e4lock, "Locking File" }, { e4unlock, "Unlocking File" }, { e4len, "Determining File Length" }, { e4len_set, "Setting File Length" }, { e4rename, "Renaming File" }, /* Database Specific Errors */ { e4data, "File is not a Data File" }, { e4record_len, "Record Length is too Large" }, { e4field_name, "Unrecognized Field Name" }, { e4field_type, "Unrecognized Field Type" }, /* Index File Specific Errors */ { e4index, "Not a Correct Index File" }, { e4entry, "Tag Entry Missing" }, { e4unique, "Unique Key Error" }, { e4tag_name, "Tag Name not Found" }, /* Expression Evaluation Errors */ { e4comma_expected, "Comma or Bracket Expected" }, { e4complete, "Expression not Complete" }, { e4data_name, "Data File Name not Located" }, { e4length_err, "IIF() Needs Parameters of Same Length" }, { e4not_constant, "SUBSTR() and STR() need Constant Parameters" }, { e4num_parms, "Number of Parameters is Wrong" }, { e4overflow, "Overflow while Evaluating Expression" }, { e4right_missing, "Right Bracket Missing" }, { e4type_sub, "Sub-expression Type is Wrong" }, { e4unrec_function, "Unrecognized Function" }, { e4unrec_operator, "Unrecognized Operator" }, { e4unrec_value, "Unrecognized Value"} , { e4unterminated, "Unterminated String"} , /* Optimization Errors */ { e4opt, "Optimization Error"} , { e4opt_suspend, "Optimization Removal Failure"} , { e4opt_flush, "Optimization File Flushing Failure"} , /* Relation Errors */ { e4relate, "Relation Error"} , { e4lookup_err, "Matching Slave Record Not Located"} , /* Report Errors */ { e4report, "Report Error"} , { e4style_create, "Error Creating Style"}, { e4style_select, "Error Selecting Style"}, { e4style_index, "Error Finding Style"}, { e4area_create, "Error Creating Area"}, { e4group_create, "Error Creating Group"}, { e4group_expr, "Error Setting Group Reset-Expression"}, { e4total_create, "Error Creating Total"}, { e4obj_create, "Error Creating Object"}, { e4rep_win, "Error In Windows Output"}, { e4rep_out, "Error In Report Output"}, { e4rep_save, "Error Saving Report"}, { e4rep_ret, "Error Retrieving Report"}, { e4rep_data, "Error In Sending Report to Data File"}, /* Critical Errors */ { e4memory, "Out of Memory"} , { e4info, "Unexpected Information"} , { e4parm, "Unexpected Parameter"} , { e4demo, "Exceeded Maximum Record Number for Demonstration"} , { e4result, "Unexpected Result"} , /* Not Supported Errors */ { e4not_memo, "Function unsupported: library compiled with S4OFF_MEMO" }, { e4not_write, "Function unsupported: library compiled with S4OFF_WRITE" }, { e4not_index, "Function unsupported: library compiled with S4OFF_INDEX" }, { e4not_rename, "Function unsupported: library compiled with S4NO_RENAME" }, { e4not_clipper, "Function unsupported: library not compiled with S4CLIPPER" }, { e4not_lock, "Function unsupported: library not compiled with S4LOCK_HOOK" }, { e4not_hook, "Function unsupported: library not compiled with S4ERROR_HOOK" }, { 0, 0 }, } ; #endif /* not S4LANGUAGE */ #ifdef S4LANGUAGE #ifdef S4GERMAN ERROR_DATA e4error_data[] = { /* Allgemeine Fehler beim Diskzugriff (General Disk Access Errors) */ { e4create, "Anlegen einer Datei" }, { e4open, "™ffnen einer Datei" }, { e4read, "Lesen einer Datei" }, { e4seek, "Suchen einer Position in der Datei " }, { e4write, "Schreiben einer Datei" }, { e4close, "Schlieáen einer Datei" }, { e4remove, "L”schen einer Datei" }, { e4lock, "Locken einer Datei" }, { e4unlock, "Freigeben einer Datei" }, { e4len, "Festlegen der L„nge einer Datei" }, { e4len_set, "Einstellen der L„nge einer Datei" }, { e4rename, "Umnennen einer Datei" }, /* Datenbank spezifische Fehler (Database Specific Errors) */ { e4data, "Datei is keiner DatenBank" }, { e4record_len, "Datensatzl„nge zu groá" }, { e4field_name, "Unbekannter Feldname" }, { e4field_type, "Feldtyp" }, /* Indexdatei spezifische Fehler (Index File Specific Errors) */ { e4index, "Datei is keine Indexdatei" }, { e4entry, "Indexdatei is veraltet" }, { e4unique, "Schulsel ist schon einmal vorhanden" }, { e4tag_name, "Name des 'Tag'"}, /* Fehler bei der Bewertung von Ausdrcken (Expressions Evaluation Errors) */ { e4comma_expected, "\",\" oder \")\" erwartet" }, { e4complete, "Ausdruck ist nich vollst„ndig" }, { e4data_name, "Keine offene Datenbank" }, { e4num_parms, "Ungltige Anzahl von Parametern im Ausdruck"}, { e4overflow, "šberlauf bei der Auswertung eines Ausdrucks" }, { e4right_missing, "Rechte Klammer im Ausdruck fehlt" }, { e4unrec_function, "Unbekannte Funktion im Ausdruck" }, { e4unrec_operator, "Unbekannter Operator im Ausdruck" }, { e4unrec_value, "Unbekannter Wert im Ausdruck"} , { e4unterminated, "Nicht abgeschlossene Zeichenkette im Ausdruck"} , /* Optimization Errors */ { e4opt, "Optimization Error"} , /*!!!GERMAN*/ { e4opt_suspend, "Optimization Removal Failure"} , /*!!!GERMAN*/ { e4opt_flush, "Optimization File Flushing Failure"} , /*!!!GERMAN*/ /* Relation Errors */ { e4lookup_err, "Matching Slave Record Not Located"} , /* Kritische Fehler (Critical Errors) */ { e4memory, "Kein Speicher mehr verfgbar"} , { e4info, "Unerwartete Information" }, { e4parm, "Unerwarteter Parameter"}, { e4demo, "Exceeded Maximum Record Number for Demonstration"} , /*!!!GERMAN*/ { e4result, "Unerwartetes Ergebnis"}, { 0, 0 }, } ; #endif /* S4GERMAN */ #ifdef S4FRENCH ERROR_DATA e4error_data[] = { /* General Disk Access Errors */ { e4create, "En cr‚ant le fichier" }, { e4open, "En engageant le fichier" }, { e4read, "En lisant le fichier" }, { e4seek, "En se pla‡ant dans le fichier" }, { e4write, "En ‚crivant dans le fichier" }, { e4close, "En lib‚rant le fichier" }, { e4remove, "En effa‡ant le fichier" }, { e4lock, "En bloquant le fichier" }, { e4unlock, "En d‚bloquant le fichier" }, { e4len, "En d‚terminant la longueur du fichier" }, { e4len_set, "Mise … jour de la longueur du fichier" }, { e4rename, "D‚nomination du fichier" }, /* Database Specific Errors */ { e4data, "Le fichier n'est pas une base de donn‚es:" }, { e4record_len, "La fiche est trop grande" }, { e4field_name, "Champ inconnu" }, { e4field_type, "Type de champ inconnu" }, /* Index File Specific Errors */ { e4index, "Ce n'est pas un fichier d'indice" }, { e4entry, "Le fichier d'indice n'est pas … jour" }, { e4unique, "La clef n'est pas unique" }, { e4tag_name, "L'article d‚sign‚ par l'indice n'existe pas" }, /* Expression Evaluation Errors */ { e4comma_expected, "\",\" ou \")\" manquant dans l'expression" }, { e4complete, "Expression incomplŠte" }, { e4data_name, "La base r‚f‚r‚e dans l'expression n'est pas pr‚sente" }, { e4num_parms, "Nombre ill‚gal de critŠres dans l'expression"}, { e4overflow, "L'expression donne un r‚sultat trop grand" }, { e4right_missing, "ParenthŠse manquante dans l'expression" }, { e4type_sub, "Un paramŠtre est de la mauvaise sorte" }, { e4unrec_function, "L'expression contient une fonction inconnue" }, { e4unrec_operator, "L'expression contient un op‚rateur inconnu" }, { e4unrec_value, "L'expression contient une valeur inconnue"} , { e4unterminated, "Apostrophe manquante dans l'expression"} , /* Optimization Errors */ { e4opt, "Optimization Error"} , { e4opt_suspend, "Optimization Removal Failure"} , { e4opt_flush, "Optimization File Flushing Failure"} , /* Relation Errors */ { e4lookup_err, "Matching Slave Record Not Located"} , /* Critical Errors */ { e4memory, "Plus de m‚moire disponible" } , { e4info, "Information inexpect‚e"} , { e4parm, "ParamŠtre inexpect‚"} , { e4demo, "Au maximum d'articles dans la version de d‚monstration" } , { e4result, "R‚sultat inexpect‚"} , { 0, 0 }, } ; #endif /* S4FRENCH */ #ifdef S4SCANDINAVIAN ERROR_DATA e4error_data[] = { /* General Disk Access Errors */ { e4create, "Creating File" }, { e4open, "Opening File" }, { e4read, "Reading File" }, { e4seek, "Seeking to File Position" }, { e4write, "Writing to File" }, { e4close, "Closing File" }, { e4remove, "Removing File" }, { e4lock, "Locking File" }, { e4unlock, "Unlocking File" }, { e4len, "Determining File Length" }, { e4len_set, "Setting File Length" }, { e4rename, "Renaming File" }, /* Database Specific Errors */ { e4data, "File is not a Data File" }, { e4record_len, "Record Length is too Large" }, { e4field_name, "Unrecognized Field Name" }, { e4field_type, "Unrecognized Field Type" }, /* Index File Specific Errors */ { e4index, "Not a Correct Index File" }, { e4entry, "Tag Entry Missing" }, { e4unique, "Unique Key Error" }, { e4tag_name, "Tag Name not Found" }, /* Expression Evaluation Errors */ { e4comma_expected, "Comma or Bracket Expected" }, { e4complete, "Expression not Complete" }, { e4data_name, "Data File Name not Located" }, { e4length_err, "IIF() Needs Parameters of Same Length" }, { e4not_constant, "SUBSTR() and STR() need Constant Parameters" }, { e4num_parms, "Number of Parameters is Wrong" }, { e4overflow, "Overflow while Evaluating Expression" }, { e4right_missing, "Right Bracket Missing" }, { e4type_sub, "Sub-expression Type is Wrong" }, { e4unrec_function, "Unrecognized Function" }, { e4unrec_operator, "Unrecognized Operator" }, { e4unrec_value, "Unrecognized Value"} , { e4unterminated, "Unterminated String"} , /* Optimization Errors */ { e4opt, "Optimization Error"} , { e4opt_suspend, "Optimization Removal Failure"} , { e4opt_flush, "Optimization File Flushing Failure"} , /* Relation Errors */ { e4relate, "Relation Error"} , { e4lookup_err, "Matching Slave Record Not Located"} , /* Report Errors */ { e4report, "Report Error"} , /* Critical Errors */ { e4memory, "Out of Memory"} , { e4info, "Unexpected Information"} , { e4parm, "Unexpected Parameter"} , { e4demo, "Exceeded Maximum Record Number for Demonstration"} , { e4result, "Unexpected Result"} , { 0, 0 }, } ; #endif /* S4SCANDINAVIAN */ #endif /* S4LANGUAGE */ #endif /* S4ERROR_OFF */ int S4FUNCTION e4code( CODE4 S4PTR *c4 ) { return c4->error_code ; } int S4FUNCTION e4set( CODE4 S4PTR *c4, int new_err_code ) { int old_err_code ; old_err_code = c4->error_code ; c4->error_code = new_err_code ; return old_err_code ; } char S4PTR * S4FUNCTION e4text( int err_code ) { #ifndef S4OFF_ERROR int i ; for ( i=0; (int) e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) return e4error_data[i].error_data ; #endif return (char *)0 ; /* err_code not matched */ } void S4FUNCTION e4exit_test( CODE4 S4PTR *c4 ) { if ( c4->error_code < 0 ) e4exit(c4) ; } #ifdef S4OS2PM #ifndef S4ERROR_HOOK static void e4do_err_out( int err_code, char *desc1, char *desc2, char *desc3 ) { int i, pos, desc_number = 1 ; char *ptr ; HAB e4hab ; HMQ e4hmq ; char e4error_str[100] ; strcpy( e4error_str, E4_ERROR ) ; strcat( e4error_str, " #: " ) ; c4ltoa45( err_code, (char *)e4error_str+9, 4 ) ; pos = 13 ; e4error_str[pos++] = '\n' ; for ( i=0; (int) e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { strcpy( e4error_str+pos, e4error_data[i].error_data ) ; pos += strlen( e4error_data[i].error_data ) ; e4error_str[pos++] = '\n' ; break ; } ptr = desc1 ; while ( (ptr != (char *) 0) && (desc_number <= 3 ) ) { if ( strlen(desc1)+pos+3 >= sizeof(e4error_str) ) break ; strcpy( e4error_str + pos, ptr ) ; pos += strlen(ptr) ; e4error_str[pos++] = '\n' ; if ( desc_number++ == 1 ) ptr = desc2 ; else ptr = desc3 ; } e4error_str[pos] = 0 ; /* In case the application has done no PM Initialization, set up an instance to allow for the error output to occur */ e4hab = WinInitialize(0) ; if ( e4hab == NULLHANDLE ) return ; e4hmq = WinCreateMsgQueue(e4hab, 0) ; if ( e4hmq == NULLHANDLE ) { WinTerminate(e4hab) ; return ; } /* And print out the error via a desktop message box */ WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, e4error_str, "Error", E4MSGBOXID, MB_OK | MB_MOVEABLE | MB_CUACRITICAL ) ; WinDestroyMsgQueue( e4hmq ); WinTerminate(e4hab) ; } #endif void S4FUNCTION e4exit( CODE4 S4PTR *c4 ) { exit( 0 ) ; } int S4FUNCTION e4( CODE4 S4PTR *c4, int err_code, char *desc ) { return e4describe( c4, err_code, desc, 0, 0 ) ; } int S4FUNCTION e4describe( CODE4 S4PTR *c4, int err_code, char *desc1, char *desc2, char *desc3 ) { #ifdef S4ERROR_HOOK c4->error_code = err_code ; e4hook( c4, err_code, desc1, desc2, desc3 ) ; #else c4->error_code = err_code ; #ifndef S4OFF_ERROR if ( c4->off_error == 0 ) e4do_err_out( err_code, desc1, desc2, desc3 ) ; #endif #endif /* ifdef S4ERROR_HOOK */ return err_code ; } void S4FUNCTION e4severe( int err_code, char *desc ) { #ifdef S4ERROR_HOOK e4hook( (char *)0, err_code, desc, (char *)0, (char *)0 ) ; FatalAppExit( 0, desc ) ; #else e4do_err_out( err_code, desc, 0, 0 ) ; e4exit( 0 ) ; ; #endif } #endif /* S4OS2PM */ #ifndef S4OS2PM #ifdef S4WINDOWS /* S4WINDOWS */ void S4FUNCTION e4exit( CODE4 S4PTR *c4 ) { FatalAppExit( 0, E4_MESSAG_EXI ) ; } /* S4WINDOWS */ int S4FUNCTION e4( CODE4 S4PTR *c4, int err_code, char *desc ) { return e4describe( c4, err_code, desc, 0, 0 ) ; } /* S4WINDOWS */ int S4FUNCTION e4describe( CODE4 S4PTR *c4, int err_code, char *desc1, char *desc2, char *desc3 ) { #ifdef S4ERROR_HOOK c4->error_code = err_code ; e4hook( c4, err_code, desc1, desc2, desc3 ) ; #else char error_str[257], *ptr ; int i, pos, desc_number = 1 ; WORD wType ; c4->error_code = err_code ; #ifndef S4OFF_ERROR if ( c4->off_error == 0 ) { strcpy( error_str, E4_ERROR ) ; strcat( error_str, " #: " ) ; c4ltoa45( err_code, (char S4PTR *)error_str+9, 4 ) ; pos = 13 ; error_str[pos++] = '\n' ; for ( i=0; (int) e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { strcpy( error_str+pos, e4error_data[i].error_data ) ; pos += strlen( e4error_data[i].error_data ) ; error_str[pos++] = '\n' ; break ; } ptr = desc1 ; while ( (ptr != (char *) 0) && (desc_number <= 3 ) ) { if ( strlen(desc1)+pos+3 >= sizeof(error_str) ) break ; strcpy( error_str+pos, ptr ) ; pos += strlen(ptr) ; error_str[pos++] = '\n' ; if ( desc_number++ == 1 ) ptr = desc2 ; else ptr = desc3 ; } error_str[pos] = 0 ; OemToAnsi( error_str, error_str ) ; wType = MB_OK | MB_ICONSTOP ; if ( err_code == e4memory ) wType |= MB_SYSTEMMODAL ; #ifndef S4TESTING #ifdef S4VBASIC if ( MessageBox( 0, error_str, E4_ERROR_BAS, wType ) == 0 ) #else if ( MessageBox( 0, error_str, E4_ERROR_COD, wType ) == 0 ) #endif FatalAppExit( 0, E4_MEMORY_ERR ) ; #else if( s4test_handle ) write( s4test_handle, error_str, (unsigned) strlen(error_str) ) ; #endif } #endif #endif /* ifdef S4ERROR_HOOK */ return err_code ; } /* S4WINDOWS */ void S4FUNCTION e4severe( int err_code, char *desc ) { #ifdef S4ERROR_HOOK e4hook( (char *)0, err_code, desc, (char *)0, (char *)0 ) ; FatalAppExit( 0, desc ) ; #else #ifndef S4OFF_ERROR char error_str[257] ; int pos, i ; strcpy( error_str, E4_ERROR_SEV ) ; strcat( error_str, " #: " ) ; c4ltoa45( err_code, (char S4PTR *)error_str+27, 4 ) ; pos = 31 ; error_str[pos++] = '\n' ; for ( i=0; e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { strcpy( error_str+pos, e4error_data[i].error_data ) ; pos += strlen( e4error_data[i].error_data ) ; error_str[pos++] = '\n' ; break ; } if ( strlen(desc)+pos+4 < sizeof(error_str) ) { strcpy( error_str+pos, desc ) ; pos += strlen(desc) ; error_str[pos++] = '\n' ; } error_str[pos] = '\0' ; OemToAnsi( error_str, error_str ) ; #ifndef S4TESTING MessageBox( 0, error_str, E4_ERROR_CDS, MB_OK | MB_ICONSTOP ) ; FatalAppExit( 0, error_str ) ; #else if( s4test_handle ) write( s4test_handle, error_str, (unsigned) strlen(error_str) ) ; #ifdef S4WIN32 ExitProcess(-1) ; #else u4terminate() ; #endif #endif #else FatalAppExit( 0, "" ) ; #endif #endif /* ifdef S4ERROR_HOOK */ } /* S4WINDOWS */ #ifdef S4VBASIC void S4FUNCTION e4severe_vbasic( int err_code, char *desc ) { char error_str[257] ; int i, pos ; strcpy( error_str, E4_ERROR_SEV ) ; strcat( error_str, " #: " ) ; c4ltoa45( err_code, (char S4PTR *)error_str+27, 4 ) ; pos = 31 ; error_str[pos++] = '\n' ; for ( i=0; e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { strcpy( error_str+pos, e4error_data[i].error_data ) ; pos += strlen( e4error_data[i].error_data ) ; error_str[pos++] = '\n' ; break ; } if ( strlen(desc)+pos+4 < sizeof(error_str) ) { strcpy( error_str+pos, desc ) ; pos += strlen(desc) ; error_str[pos++] = '\n' ; } error_str[pos] = 0 ; OemToAnsi( error_str, error_str ) ; #ifndef S4TESTING MessageBox( 0, error_str, E4_ERROR_BAS, MB_OK | MB_ICONSTOP ) ; #else if( s4test_handle ) write( s4test_handle, error_str, (unsigned) strlen(error_str) ) ; #endif } #endif /* S4VBASIC */ #endif /* S4WINDOWS */ #ifndef S4WINDOWS #ifdef S4VB_DOS /* S4VB_DOS */ int S4FUNCTION e4( CODE4 S4PTR *c4, int err_code, char *desc ) { return e4describe( c4, err_code, desc, 0, 0 ) ; } /* S4VB_ DOS */ int S4FUNCTION e4describe( CODE4 S4PTR *c4, int err_code, char *desc1, char *desc2, char *desc3 ) { char error_str[257], *ptr ; int i, pos, desc_number = 1 ; int err_type = V4ERROR ; c4->error_code = err_code ; strcpy( error_str, E4_ERROR ) ; strcat( error_str, " #: " ) ; c4ltoa45( err_code, (char far *)error_str+9, 4 ) ; pos = 13 ; error_str[pos++] = '\n' ; for ( i=0; (int) e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { strcpy( error_str+pos, e4error_data[i].error_data ) ; pos += strlen( e4error_data[i].error_data ) ; error_str[pos++] = '\n' ; break ; } ptr = desc1 ; while ( (ptr != (char *) 0) && (desc_number <= 3 ) ) { if ( strlen(desc1)+pos+3 >= sizeof(error_str) ) break ; strcpy( error_str+pos, ptr ) ; pos += strlen(ptr) ; error_str[pos++] = '\n' ; if ( desc_number++ == 1 ) ptr = desc2 ; else ptr = desc3 ; } error_str[pos] = 0 ; #ifndef S4TESTING u4MsgBox( v4str(error_str), (int near *)&err_type); #else if( s4test_handle ) write( s4test_handle, error_str, (unsigned) strlen(error_str) ) ; #endif return err_code ; } /* S4VB_DOS */ void S4FUNCTION e4severe( int err_code, char *desc ) { char error_str[257] ; int pos, i ,err_type = V4SEVERE ; strcpy( error_str, E4_ERROR_SEV ) ; strcat( error_str, " #: " ) ; c4ltoa45( err_code, (char far *)error_str+27, 4 ) ; pos = 31 ; error_str[pos++] = '\n' ; for ( i=0; e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { strcpy( error_str+pos, e4error_data[i].error_data ) ; pos += strlen( e4error_data[i].error_data ) ; error_str[pos++] = '\n' ; break ; } if ( strlen(desc)+pos+4 < sizeof(error_str) ) { strcpy( error_str+pos, desc ) ; pos += strlen(desc) ; error_str[pos++] = '\n' ; } error_str[pos] = 0 ; #ifndef S4TESTING u4MsgBox( v4str(error_str), (int near *)&err_type); #else if( s4test_handle ) write( s4test_handle, error_str, (unsigned) strlen(error_str) ) ; #endif exit(err_code) ; } /* S4VB_DOS */ void S4FUNCTION e4severe_vbasic( int err_code, char *desc ) { char error_str[257] ; int i, pos, err_type = V4SEVERE ; strcpy( error_str, E4_ERROR_SEV ) ; strcat( error_str, " #: " ) ; c4ltoa45( err_code, (char far *)error_str+27, 4 ) ; pos = 31 ; error_str[pos++] = '\n' ; for ( i=0; e4error_data[i].error_num != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { strcpy( error_str+pos, e4error_data[i].error_data ) ; pos += strlen( e4error_data[i].error_data ) ; error_str[pos++] = '\n' ; break ; } if ( strlen(desc)+pos+4 < sizeof(error_str) ) { strcpy( error_str+pos, desc ) ; pos += strlen(desc) ; error_str[pos++] = '\n' ; } error_str[pos] = 0 ; #ifndef S4TESTING u4MsgBox( v4str(error_str), (int near *)&err_type); #else if( s4test_handle ) write( s4test_handle, error_str, (unsigned) strlen(error_str) ) ; #endif } /* S4VB_DOS */ void S4FUNCTION e4exit( CODE4 S4PTR *c4 ) { if ( c4 == 0 ) exit(0) ; else exit( c4->error_code ) ; } #else /* S4VB_DOS */ /* not S4WINDOWS */ void S4FUNCTION e4exit( CODE4 S4PTR *c4 ) { if ( c4 == 0 ) exit(0) ; else exit( c4->error_code ) ; } /* not S4WINDOWS */ #ifndef S4OFF_ERROR static void e4error_out( char *ptr ) { #ifdef S4UNIX printf("%s", ptr ) ; #else #ifdef S4TESTING if( s4test_handle ) write( s4test_handle, ptr, (unsigned int) strlen(ptr) ) ; #endif write( 1, ptr, (unsigned int) strlen(ptr) ) ; #endif } /* not S4WINDOWS */ static void display( int err_code ) { char buf[11] ; int i ; c4ltoa45( (long) err_code, buf, 6 ) ; buf[6] = 0 ; e4error_out( buf ) ; for ( i = 0; e4error_data[i].error_data != 0; i++ ) if ( e4error_data[i].error_num == err_code ) { e4error_out( "\r\n" ) ; e4error_out( e4error_data[i].error_data ) ; break ; } } #endif /* not S4WINDOWS */ int S4FUNCTION e4( CODE4 S4PTR *c4, int err_code, char *desc ) { return e4describe( c4, err_code, desc, 0, 0 ) ; } int S4FUNCTION e4describe( CODE4 S4PTR *c4, int err_code, char *desc1, char *desc2, char *desc3 ) { #ifdef S4ERROR_HOOK e4hook( c4, err_code, desc1, desc2, desc3 ) ; #else char *ptr ; int desc_number = 1 ; c4->error_code = err_code ; #ifndef S4OFF_ERROR if ( c4->off_error == 0 ) { e4error_out( E4_ERROR_NUM ) ; display ( err_code ) ; ptr = desc1 ; while ( (ptr != (char *) 0) && (desc_number <= 3 ) ) { e4error_out( "\r\n" ) ; e4error_out( ptr ) ; if ( desc_number++ == 1 ) ptr = desc2 ; else ptr = desc3 ; } #ifdef S4UNIX e4error_out( E4_ERROR_ENT ) ; getchar() ; #else e4error_out( E4_ERROR_KEY ) ; #ifndef S4TESTING #ifndef S4PASCAL getch() ; #endif #endif #endif } #endif #endif /* ifdef S4ERROR_HOOK */ return( err_code ) ; } void S4FUNCTION e4severe( int err_code, char *desc ) { #ifdef S4ERROR_HOOK e4hook( 0, err_code, desc, (char *)0, (char *)0 ) ; #else #ifndef S4OFF_ERROR e4error_out( E4_ERROR_SEV ) ; display( err_code ) ; e4error_out( "\r\n" ) ; e4error_out( desc ) ; #ifdef S4UNIX e4error_out( E4_ERROR_ENT ) ; getchar() ; #else e4error_out( E4_ERROR_KEY ) ; #ifndef S4TESTING #ifndef S4PASCAL getch() ; #endif #endif #endif #endif #endif /* ifdef S4ERROR_HOOK */ exit(1) ; } #endif /* S4VB_DOS */ #endif /* S4WINDOWS */ #endif /* S4OS2PM */