void osexit(int c, const char* msg) {
if (msg) {
posix_write(2, msg, str_len(msg));
posix_write(2, "\n", 1);
}
exit(c);
}
bool GUILoadStrInit( const char *fname )
{
hInstance.status = 0;
if( OpenResFileX( &hInstance, fname, GUIGetExtName() != NULL ) ) {
// if we are using an external resource file then we don't have to search
return( true );
}
CloseResFile( &hInstance );
posix_write( fileno( stdout ), NO_RES_MESSAGE_PREFIX, sizeof( NO_RES_MESSAGE_PREFIX ) - 1 );
posix_write( fileno( stdout ), fname, strlen( fname ) );
posix_write( fileno( stdout ), NO_RES_MESSAGE_SUFFIX, sizeof( NO_RES_MESSAGE_SUFFIX ) - 1 );
return( false );
}
static bool MsgReadErrArray( void )
#endif
{
int i;
char buffer[128];
unsigned msg_shift;
msg_shift = _WResLanguage() * MSG_LANG_SPACING;
for( i = ERR_FIRST_MESSAGE; i <= ERR_LAST_MESSAGE; i++ ) {
#if !defined(__WINDOWS__)
if( WResLoadString( &hInstance, i + msg_shift, (lpstr)buffer, sizeof( buffer ) ) <= 0 ) {
#else
if( LoadString( inst, i + msg_shift, (LPSTR)buffer, sizeof( buffer ) ) <= 0 ) {
#endif
if( i == ERR_FIRST_MESSAGE )
return( false );
buffer[0] = '\0';
}
MsgArray[i - ERR_FIRST_MESSAGE] = my_alloc( strlen( buffer ) + 1 );
if( MsgArray[i - ERR_FIRST_MESSAGE] == NULL )
return( false );
_fstrcpy( MsgArray[i - ERR_FIRST_MESSAGE], buffer );
}
return( true );
}
#if !defined(__WINDOWS__)
bool MsgInit( void )
{
char buffer[_MAX_PATH];
#if defined(_PLS)
char *fname;
char fullpath[_MAX_PATH];
#endif
bool rc;
hInstance.status = 0;
if( _cmdname( buffer ) != NULL ) {
rc = OpenResFile( &hInstance, buffer );
#if defined(_PLS)
if( !rc ) {
_splitpath2( buffer, fullpath, NULL, NULL, &fname, NULL );
_makepath( buffer, NULL, NULL, fname, ".exp" );
_searchenv( buffer, "PATH", fullpath );
if( fullpath[0] != '\0' ) {
rc = OpenResFile( &hInstance, fullpath );
}
}
#endif
if( rc ) {
MsgReadErrArray();
CloseResFile( &hInstance );
return( true );
}
}
CloseResFile( &hInstance );
posix_write( STDOUT_FILENO, NO_RES_MESSAGE, NO_RES_SIZE );
return( false );
}
size_t LocalWrite( sys_handle sh, const void *ptr, size_t len )
{
ssize_t ret;
ret = posix_write( SYSH2LH( sh ), ptr, len );
if( ret < 0 ) {
StashErrCode( errno, OP_LOCAL );
return( ERR_RETURN );
}
return( ret );
}
size_t QWrite( int handle, const void *buffer, size_t len )
/*********************************************************/
{
size_t result;
result = posix_write( handle, buffer, len );
if( result == -1 ) {
IOError( "problem writing file" );
} else if( result != len ) {
Error( "disk full" );
}
return( result );
}
size_t QWrite( f_handle file, const void *buffer, size_t len, const char *name )
/******************************************************************************/
/* write from far memory */
{
size_t ret;
if( len == 0 )
return( 0 );
ret = posix_write( file, buffer, len );
if( ret == -1 ) {
IOError( "io error processing ", name );
}
return( ret );
}
WResFileSSize res_write( WResFileID fid, const void *out_buff, WResFileSize size )
/********************************************************************************/
{
RcBuffer *buff;
size_t copy_bytes;
size_t total_wrote;
int i;
i = RcFindIndex( fid );
if( i >= RC_MAX_FILES ) {
return( posix_write( WRES_FID2PH( fid ), out_buff, size ) );
}
buff = RcFileList[i].Buffer;
/* this is in case we have just read from the file */
if( !buff->IsDirty ) {
if( FlushRcBuffer( fid, buff ) ) {
return( -1 );
}
}
total_wrote = 0;
while( size > 0 ) {
copy_bytes = RC_BUFFER_SIZE - buff->Count;
if( copy_bytes > size )
copy_bytes = size;
memcpy( buff->NextChar, out_buff, copy_bytes );
buff->IsDirty = true;
buff->NextChar += copy_bytes;
buff->Count += copy_bytes;
out_buff = (char *)out_buff + copy_bytes;
size -= copy_bytes;
total_wrote += copy_bytes;
if( buff->Count == RC_BUFFER_SIZE ) {
if( FlushRcBuffer( fid, buff ) ) {
return( -1 );
}
}
}
return( total_wrote );
} /* RcWrite */
static bool FlushRcBuffer( WResFileID fid, RcBuffer *buff )
/*********************************************************/
{
bool error;
error = false;
if( buff->IsDirty ) {
error = ( (size_t)posix_write( WRES_FID2PH( fid ), buff->Buffer, buff->Count ) != buff->Count );
memset( buff->Buffer, 0, RC_BUFFER_SIZE );
}
buff->IsDirty = false;
buff->Count = 0;
buff->BytesRead = 0;
buff->NextChar = buff->Buffer;
return( error );
} /* FlushRcBuffer */
bool MsgInit( void )
{
#if !defined( USE_TEXT_MSGS )
char name[_MAX_PATH];
hInstance.status = 0;
if( _cmdname( name ) != NULL && OpenResFile( &hInstance, name ) ) {
MsgShift = _WResLanguage() * MSG_LANG_SPACING;
if( MsgGet( MSG_USAGE_BASE, name ) ) {
return( true );
}
}
CloseResFile( &hInstance );
posix_write( STDOUT_FILENO, NO_RES_MESSAGE, NO_RES_SIZE );
return( false );
#else
return( true );
#endif
}
bool MsgInit( void )
/******************/
{
#ifndef BOOTSTRAP
static char name[_MAX_PATH]; // static because address passed outside.
hInstance.status = 0;
if( _cmdname( name ) != NULL && OpenResFile( &hInstance, name ) ) {
MsgShift = _WResLanguage() * MSG_LANG_SPACING;
if( MsgGet( MSG_USAGE_BASE, name ) ) {
return( true );
}
}
CloseResFile( &hInstance );
posix_write( STDOUT_FILENO, NO_RES_MESSAGE, NO_RES_SIZE );
return( false );
#else
return( true );
#endif
}
WResFileSSize res_write( WResFileID fid, const void *buf, WResFileSize size )
{
return( posix_write( WRES_FID2PH( fid ), buf, size ) );
}
void Print( const char *string )
{
posix_write( CurrentDest, string, strlen( string ) );
}
static WResFileSSize wres_write( FILE *fp, const void *buf, WResFileSize size )
{
return( posix_write( FP2POSIX( fp ), buf, size ) );
}
void putlen( const char *str, size_t len )
/****************************************/
{
posix_write( STDOUT_HANDLE, str, len );
}
void put( const char * str )
/**************************/
{
posix_write( STDOUT_HANDLE, str, strlen( str ) );
}
