static void Pass1ResFileShutdown( void )
/**************************************/
{
bool error;
error = false;
if( CurrResFile.fp != NULL ) {
if( CmdLineParms.TargetOS == RC_TARGET_OS_OS2 ) {
WriteOS2Tables();
} else {
WriteWINTables();
}
if( !ErrorHasOccured ) {
if( CurrResFile.IsWatcomRes ) {
error = WResWriteDir( CurrResFile.fp, CurrResFile.dir );
if( error ) {
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, LastWresErrStr() );
}
}
if( !error ) {
ChangeTmpToOutFile( CurrResFile.fp, CmdLineParms.OutResFileName );
}
}
if( CurrResFile.dir != NULL ) {
WResFreeDir( CurrResFile.dir );
CurrResFile.dir = NULL;
}
if( ResCloseFile( CurrResFile.fp ) ) {
RcError( ERR_CLOSING_TMP, CurrResFile.filename, LastWresErrStr() );
}
CurrResFile.fp = NULL;
}
} /* Pass1ResFileShutdown */
SemOffset SemStartResource( void )
/********************************/
{
if( StopInvoked ) {
RcFatalError( ERR_STOP_REQUESTED );
}
if (CurrResFile.IsWatcomRes) {
return( ResTell( CurrResFile.handle ) );
} else {
/* open a temporary file and trade handles with the RES file */
RcTmpFileName( MSFormatTmpFile );
MSFormatHandle = CurrResFile.handle;
CurrResFile.handle = MResOpenNewFile( MSFormatTmpFile );
if (CurrResFile.handle == -1) {
CurrResFile.handle = MSFormatHandle;
ResCloseFile( CurrResFile.handle );
remove( CurrResFile.filename );
RcFatalError( ERR_OPENING_TMP, MSFormatTmpFile, LastWresErrStr() );
} else {
RegisterTmpFile( MSFormatTmpFile );
CurrResFile.filename = MSFormatTmpFile;
}
/* The start position should be 0 but to be safe call ResTell */
return( ResTell( CurrResFile.handle ) );
}
}
void SemWriteRawDataItem( RawDataItem item )
/******************************************/
{
uint_16 num16;
uint_32 num32;
bool error;
if( item.IsString ) {
int len = item.StrLen;
if( item.WriteNull ) {
++len;
}
if( ResWriteStringLen( item.Item.String, item.LongItem, CurrResFile.handle, len ) ) {
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, LastWresErrStr() );
ErrorHasOccured = true;
}
if( item.TmpStr ) {
RCFREE( item.Item.String );
}
} else {
if( !item.LongItem ) {
if( (int_32)item.Item.Num < 0 ) {
if( (int_32)item.Item.Num < SHRT_MIN ) {
RcWarning( ERR_RAW_DATA_TOO_SMALL, item.Item.Num, SHRT_MIN );
}
} else {
if( item.Item.Num > USHRT_MAX ) {
RcWarning( ERR_RAW_DATA_TOO_BIG, item.Item.Num, USHRT_MAX );
}
}
}
if( !ErrorHasOccured ) {
if( !item.LongItem ) {
num16 = item.Item.Num;
error = ResWriteUint16( &(num16), CurrResFile.handle );
} else {
num32 = item.Item.Num;
error = ResWriteUint32( &(num32), CurrResFile.handle );
}
if( error ) {
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, LastWresErrStr() );
ErrorHasOccured = true;
}
}
}
}
static bool copyResourcesFromRes( const char *full_filename )
/***********************************************************/
{
WResFileID fid;
WResDir dir;
bool dup_discarded;
WResDirWindow wind;
char *buffer;
bool error;
buffer = NULL;
dir = WResInitDir();
fid = RcIoOpenInput( full_filename, false );
if( fid == WRES_NIL_HANDLE ) {
RcError( ERR_CANT_OPEN_FILE, full_filename, strerror( errno ) );
goto HANDLE_ERROR;
}
error = WResReadDir( fid, dir, &dup_discarded );
if( error ) {
switch( LastWresStatus() ) {
case WRS_BAD_SIG:
RcError( ERR_INVALID_RES, full_filename );
break;
case WRS_BAD_VERSION:
RcError( ERR_BAD_RES_VER, full_filename );
break;
default:
RcError( ERR_READING_RES, full_filename, LastWresErrStr() );
break;
}
goto HANDLE_ERROR;
}
if( WResGetTargetOS( dir ) != WResGetTargetOS( CurrResFile.dir ) ) {
RcError( ERR_RES_OS_MISMATCH, full_filename );
goto HANDLE_ERROR;
}
buffer = RESALLOC( BUFFER_SIZE );
wind = WResFirstResource( dir );
while( !WResIsEmptyWindow( wind ) ) {
copyAResource( fid, &wind, buffer, full_filename );
wind = WResNextResource( wind, dir );
}
RESFREE( buffer );
WResFreeDir( dir );
RESCLOSE( fid );
return( false );
HANDLE_ERROR:
ErrorHasOccured = true;
WResFreeDir( dir );
if( fid != WRES_NIL_HANDLE )
RESCLOSE( fid );
return( true );
}
static void Pass1ResFileShutdown( void )
/**************************************/
{
int error;
error = FALSE;
if( CurrResFile.IsOpen ) {
if( CmdLineParms.TargetOS == RC_TARGET_OS_OS2 )
WriteOS2Tables();
else
WriteTables();
if( ErrorHasOccured ) {
ResCloseFile( CurrResFile.handle );
CurrResFile.IsOpen = false;
RemoveCurrResFile();
} else {
if (CurrResFile.IsWatcomRes) {
error = WResWriteDir( CurrResFile.handle, CurrResFile.dir );
if( error ) {
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
LastWresErrStr() );
}
}
if( ResCloseFile( CurrResFile.handle ) == -1 ) {
RcError( ERR_CLOSING_TMP, CurrResFile.filename,
LastWresErrStr() );
remove( CurrResFile.filename );
UnregisterTmpFile( CurrResFile.filename );
} else if( !error ) {
#ifdef USE_TEMPFILE
ChangeTmpToOutFile( CurrResFile.filename,
CmdLineParms.OutResFileName );
#endif
}
CurrResFile.IsOpen = false;
}
WResFreeDir( CurrResFile.dir );
CurrResFile.dir = NULL;
}
} /* Pass1ResFileShutdown */
static bool Pass1InitRes( void )
/******************************/
{
WResID null_id;
ResMemFlags null_memflags;
ResLocation null_loc;
memset( &CurrResFile, 0, sizeof( CurrResFile ) );
/* open the temporary file */
CurrResFile.filename = "Temporary file 0 (res)";
CurrResFile.fp = ResOpenFileTmp( NULL );
if( CurrResFile.fp == NULL ) {
RcError( ERR_OPENING_TMP, CurrResFile.filename, LastWresErrStr() );
return( true );
}
/* initialize the directory */
CurrResFile.dir = WResInitDir();
if( CurrResFile.dir == NULL ) {
RcError( ERR_OUT_OF_MEMORY );
ResCloseFile( CurrResFile.fp );
CurrResFile.fp = NULL;
return( true );
}
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN16 ) {
WResSetTargetOS( CurrResFile.dir, WRES_OS_WIN16 );
} else if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
WResSetTargetOS( CurrResFile.dir, WRES_OS_WIN32 );
} else {
WResSetTargetOS( CurrResFile.dir, WRES_OS_OS2 );
}
if( CmdLineParms.MSResFormat ) {
CurrResFile.IsWatcomRes = false;
/* write null header here if it is win32 */
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
null_loc.start = SemStartResource();
null_loc.len = SemEndResource( null_loc.start );
null_id.IsName = false;
null_id.ID.Num = 0;
null_memflags = 0;
SemAddResource( &null_id, &null_id, null_memflags, null_loc );
}
} else {
CurrResFile.IsWatcomRes = true;
WResFileInit( CurrResFile.fp );
}
CurrResFile.NextCurOrIcon = 1;
return( false );
} /* Pass1InitRes */
void SemWINWriteAccelEntry( FullAccelEntry entry )
/************************************************/
{
bool error;
if( !ErrorHasOccured ) {
if( entry.Win32 ) {
error = ResWriteAccelEntry32( &entry.u.entry32, CurrResFile.fid );
} else {
error = ResWriteAccelEntry( &entry.u.entry, CurrResFile.fid );
}
if( error ) {
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, LastWresErrStr() );
ErrorHasOccured = true;
}
}
}
void SemOS2WriteFontDir( void )
/*****************************/
{
FullFontDirEntry * currentry;
ResLocation loc;
bool error;
if( CurrResFile.FontDir == NULL ) {
return;
}
loc.start = SemStartResource();
error = ResWriteUint16( &(CurrResFile.FontDir->NumOfFonts),
CurrResFile.handle );
if( error)
goto OUTPUT_WRITE_ERROR;
for( currentry = CurrResFile.FontDir->Head; currentry != NULL;
currentry = currentry->Next ) {
error = ResWriteFontDirEntry( &(currentry->Entry), CurrResFile.handle );
if( error ) {
goto OUTPUT_WRITE_ERROR;
}
}
loc.len = SemEndResource( loc.start );
SemAddResourceFree( WResIDFromStr( FONT_DIR_NAME ),
WResIDFromNum( (long)RT_FONTDIR ), FONT_DIR_FLAGS, loc );
FreeFontDir( CurrResFile.FontDir );
CurrResFile.FontDir = NULL;
return;
OUTPUT_WRITE_ERROR:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, LastWresErrStr() );
ErrorHasOccured = true;
FreeFontDir( CurrResFile.FontDir );
CurrResFile.FontDir = NULL;
return;
}
extern void SemOS2WriteStringTable( FullStringTable *currtable, WResID *type )
/****************************************************************************/
/* write the table identified by currtable as a table of type type and then */
/* free the memory that it occupied */
{
FullStringTableBlock *currblock;
FullStringTable *tofree;
WResID *name;
int error;
ResLocation loc;
while( currtable != NULL ) {
for( currblock = currtable->Head; currblock != NULL;
currblock = currblock->Next ) {
loc.start = SemStartResource();
error = ResOS2WriteStringTableBlock( &(currblock->Block),
CurrResFile.handle,
currblock->codePage );
if( error) {
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
LastWresErrStr() );
ErrorHasOccured = TRUE;
SemOS2FreeStringTable( currtable );
return;
}
loc.len = SemEndResource( loc.start );
/* +1 because WResID's can't be 0 */
name = WResIDFromNum( currblock->BlockNum + 1 );
SemAddResource( name, type, currblock->Flags, loc );
RcMemFree( name );
}
tofree = currtable;
currtable = currtable->next;
SemOS2FreeStringTable( tofree );
}
RcMemFree( type );
return;
}
SemLength SemEndResource( SemOffset start )
/*****************************************/
{
SemLength len;
if (CurrResFile.IsWatcomRes) {
return( ResTell( CurrResFile.handle ) - start );
} else {
/* Close the temperary file, reset the RES file handle and return */
/* the length of the resource */
len = ResTell( CurrResFile.handle ) - start;
if( ResCloseFile( CurrResFile.handle ) == -1 ) {
RcError( ERR_CLOSING_TMP, CurrResFile.filename, LastWresErrStr() );
ErrorHasOccured = TRUE;
}
CurrResFile.handle = MSFormatHandle;
CurrResFile.filename = CurrResFile.namebuf;
return( len );
}
}
static int Pass1InitRes( void )
/*****************************/
{
WResID null_id;
ResMemFlags null_memflags;
ResLocation null_loc;
/* put the temporary file in the same location as the output file */
CurrResFile.filename = CurrResFile.namebuf;
#ifdef USE_TEMPFILE
MakeTmpInSameDir( CmdLineParms.OutResFileName, CurrResFile.filename,
"res" );
#else
strcpy( CurrResFile.filename, CmdLineParms.OutResFileName );
#endif
/* initialize the directory */
CurrResFile.dir = WResInitDir();
if( CurrResFile.dir == NULL ) {
RcError( ERR_OUT_OF_MEMORY );
CurrResFile.IsOpen = false;
return( TRUE );
}
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN16 ) {
WResSetTargetOS( CurrResFile.dir, WRES_OS_WIN16 );
} else if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
WResSetTargetOS( CurrResFile.dir, WRES_OS_WIN32 );
} else {
WResSetTargetOS( CurrResFile.dir, WRES_OS_OS2 );
}
/* open the temporary file */
if( CmdLineParms.MSResFormat ) {
CurrResFile.IsWatcomRes = FALSE;
CurrResFile.handle = MResOpenNewFile( CurrResFile.filename );
/* write null header here if it is win32 */
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 &&
CmdLineParms.MSResFormat ) {
null_loc.start = SemStartResource();
null_loc.len = SemEndResource( null_loc.start );
null_id.IsName = FALSE;
null_id.ID.Num = 0;
null_memflags = 0;
SemAddResource( &null_id, &null_id, null_memflags, null_loc );
}
} else {
CurrResFile.IsWatcomRes = TRUE;
CurrResFile.handle = WResOpenNewFile( CurrResFile.filename );
}
if( CurrResFile.handle == NIL_HANDLE ) {
RcError( ERR_OPENING_TMP, CurrResFile.filename, LastWresErrStr() );
CurrResFile.IsOpen = false;
return( TRUE );
}
RegisterTmpFile( CurrResFile.filename );
CurrResFile.IsOpen = true;
CurrResFile.StringTable = NULL;
CurrResFile.ErrorTable = NULL;
CurrResFile.FontDir = NULL;
CurrResFile.NextCurOrIcon = 1;
return( FALSE );
} /* Pass1InitRes */
static void copyMSFormatRes( WResID * name, WResID * type, ResMemFlags flags,
ResLocation loc, WResLangType *lang )
/***************************************************************************/
{
MResResourceHeader ms_head;
long cur_byte_num;
uint_8 cur_byte;
long seek_rc;
int error;
int tmp_handle;
/* fill in and output a MS format resource header */
ms_head.Type = WResIDToNameOrOrd( type );
ms_head.Name = WResIDToNameOrOrd( name );
ms_head.MemoryFlags = flags;
ms_head.Size = loc.len;
ms_head.LanguageId = MAKELANGID( lang->lang, lang->sublang );
ms_head.Version = 0L; /* Currently Unsupported */
ms_head.DataVersion = 0L;
ms_head.Characteristics = 0L; /* Currently Unsupported */
/* OS/2 resource header happens to be identical to Win16 */
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN16 ||
CmdLineParms.TargetOS == RC_TARGET_OS_OS2 ) {
error = MResWriteResourceHeader( &ms_head, CurrResFile.handle, FALSE );
} else {
error = MResWriteResourceHeader( &ms_head, CurrResFile.handle, TRUE );
}
if (error) {
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
LastWresErrStr() );
RcMemFree( ms_head.Type );
RcMemFree( ms_head.Name );
ErrorHasOccured = TRUE;
} else {
RcMemFree( ms_head.Type );
RcMemFree( ms_head.Name );
tmp_handle = ResOpenFileRO( MSFormatTmpFile );
if (tmp_handle == -1) {
RcError( ERR_OPENING_TMP, MSFormatTmpFile, LastWresErrStr() );
ErrorHasOccured = TRUE;
return;
}
/* copy the data from the temperary file to the RES file */
seek_rc = ResSeek( tmp_handle, loc.start, SEEK_SET );
if (seek_rc == -1) {
RcError( ERR_READING_TMP, MSFormatTmpFile, LastWresErrStr() );
ResCloseFile( tmp_handle );
ErrorHasOccured = TRUE;
return;
}
/* this is very inefficient but hopefully the buffering in layer0.c */
/* will make it tolerable */
for (cur_byte_num = 0; cur_byte_num < loc.len; cur_byte_num++) {
error = ResReadUint8( &cur_byte, tmp_handle );
if( error ) {
RcError( ERR_READING_TMP, MSFormatTmpFile, LastWresErrStr() );
ResCloseFile( tmp_handle );
ErrorHasOccured = TRUE;
return;
} else {
error = ResWriteUint8( &cur_byte, CurrResFile.handle );
if( error ) {
RcError( ERR_WRITTING_RES_FILE,
CurrResFile.filename, LastWresErrStr() );
ResCloseFile( tmp_handle );
ErrorHasOccured = TRUE;
return;
}
}
}
if( ResCloseFile( tmp_handle ) == -1 ) {
RcError( ERR_WRITTING_RES_FILE, MSFormatTmpFile,
LastWresErrStr() );
ErrorHasOccured = TRUE;
}
}
}