void SemOS2WriteAccelTable( WResID *name, ResMemFlags flags, uint_32 codepage,
FullAccelTableOS2 *acctable )
/****************************************************************************/
{
ResLocation loc;
bool error;
int err_code;
if( !ErrorHasOccured ) {
loc.start = SemStartResource();
error = writeAccelTableEntries( acctable, CurrResFile.fid, codepage );
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_ACCELTABLE ), flags, loc );
} else {
RESFREE( name );
}
SemOS2FreeAccelTable( acctable );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, strerror( err_code ) );
ErrorHasOccured = true;
SemOS2FreeAccelTable( acctable );
return;
}
static RcStatus copyBitmap( BitmapFileHeader *head, WResFileID handle,
WResID *name, ResMemFlags flags, int *err_code )
/**************************************************************************/
{
RcStatus ret;
char * buffer;
ResLocation loc;
WResFileOffset pos;
buffer = RCALLOC( BITMAP_BUFFER_SIZE );
loc.start = SemStartResource();
pos = RCTELL( handle );
if( pos == -1 ) {
ret = RS_READ_ERROR;
*err_code = errno;
} else {
ret = CopyData( pos, head->Size - sizeof(BitmapFileHeader),
handle, buffer, BITMAP_BUFFER_SIZE, err_code );
}
loc.len = SemEndResource( loc.start );
/* add the bitmap to the RES file directory */
SemAddResourceFree( name, WResIDFromNum( (long)(pointer_int)RT_BITMAP ), flags, loc );
RCFREE( buffer );
return( ret );
} /* copyBitmap */
void SemOS2WriteHelpSubTable( WResID * name, int numWords,
ResMemFlags flags,
FullHelpSubTableOS2 * helptable )
/********************************************************************/
{
ResLocation loc;
bool error;
int err_code;
if( !ErrorHasOccured ) {
loc.start = SemStartResource();
if( helptable != NULL ) {
helptable->numWords = numWords;
}
error = SemOS2WriteHelpSubTableEntries( helptable, CurrResFile.handle );
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_HELPSUBTABLE ), flags, loc );
} else {
RCFREE( name );
}
SemOS2FreeHelpSubTable( helptable );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, strerror( err_code ) );
ErrorHasOccured = true;
SemOS2FreeHelpSubTable( helptable );
return;
}
static bool writeCurDir( FullCurDir *dir, WResID *name, ResMemFlags flags,
int *err_code )
/****************************************************************************/
{
bool error;
FullCurDirEntry * entry;
ResLocation loc;
loc.start = SemStartResource();
error = ResWriteIconCurDirHeader( &(dir->Header), CurrResFile.handle );
for( entry = dir->Head; !error && entry != NULL; entry = entry->Next ) {
error = ResWriteCurDirEntry( &(entry->Entry.Res), CurrResFile.handle );
}
if( !error ) {
loc.len = SemEndResource( loc.start );
#ifdef PREPROC_BUG
SemAddResourceFree( name, WResIDFromNum( (long)(pointer_int)RT_GROUP_CURSOR ),
flags, loc );
#else
SemAddResourceFree( name, WResIDFromNum( (long)12 ),
flags, loc );
#endif
} else {
*err_code = LastWresErr();
}
return( error );
}
ResLocation SemFlushDataElemList( DataElemList *head, bool call_startend )
/************************************************************************/
{
DataElemList *curnode;
DataElemList *nextnode;
ResLocation resLoc;
int i;
curnode = head;
nextnode = head;
resLoc.len = 0;
if( call_startend ) {
resLoc.start = SemStartResource();
} else {
resLoc.start = 0;
}
while( nextnode != NULL ) {
nextnode = curnode->next;
for( i = 0; i < curnode->count; i++ ) {
SemWriteRawDataItem( curnode->data[i] );
}
RESFREE( curnode );
curnode = nextnode;
}
if( call_startend ) {
if( CmdLineParms.MSResFormat
&& CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
ResWritePadDWord( CurrResFile.fid );
}
resLoc.len = SemEndResource( resLoc.start );
}
return( resLoc );
}
static RcStatus copyFont( FontInfo * info, WResFileID handle, WResID * name,
ResMemFlags flags, int *err_code )
/************************************************************************/
{
RcStatus ret;
char * buffer;
ResLocation loc;
long pos;
buffer = RCALLOC( FONT_BUFFER_SIZE );
loc.start = SemStartResource();
if( ResWriteFontInfo( info, CurrResFile.handle ) ) {
ret = RS_WRITE_ERROR;
*err_code = LastWresErr();
} else {
pos = RCTELL( handle );
if( pos == -1 ) {
ret = RS_READ_ERROR;
*err_code = errno;
} else {
ret = SemCopyDataUntilEOF( pos, handle, buffer,
FONT_BUFFER_SIZE, err_code );
}
}
loc.len = SemEndResource( loc.start );
/* add the font to the RES file directory */
SemAddResourceFree( name, WResIDFromNum( (long)RT_FONT ), flags, loc );
RCFREE( buffer );
return( ret );
} /* copyFont */
extern void SemOS2AddDlgincResource( WResID *name, char *filename )
/*****************************************************************/
{
ResLocation loc;
int error, err_code;
loc.start = SemStartResource();
error = ResWriteString( filename, FALSE, CurrResFile.handle );
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_DLGINCLUDE ),
MEMFLAG_DISCARDABLE | MEMFLAG_MOVEABLE | MEMFLAG_PURE,
loc );
RcMemFree( filename );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
strerror( err_code ) );
ErrorHasOccured = TRUE;
RcMemFree( filename );
return;
}
void SemOS2WriteMenu( WResID *name, ResMemFlags flags, FullMenuOS2 *menu,
YYTOKENTYPE tokentype, uint_32 codepage )
/***********************************************************************/
{
ResLocation loc;
int error;
int err_code;
tokentype = tokentype;
if( !ErrorHasOccured ) {
loc.start = SemStartResource();
error = SemOS2WriteSubMenu( menu, &err_code, codepage );
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_MENU ), flags, loc );
} else {
RCFREE( name );
}
SemOS2FreeSubMenu( menu );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename, strerror( err_code ) );
ErrorHasOccured = TRUE;
SemOS2FreeSubMenu( menu );
return;
}
extern void SemOS2WriteHelpTable( WResID * name, ResMemFlags flags,
FullHelpTableOS2 * helptable )
/******************************************************************/
{
ResLocation loc;
int error;
int err_code;
if( !ErrorHasOccured ) {
loc.start = SemStartResource();
error = SemOS2WriteHelpTableEntries( helptable, CurrResFile.handle );
if(error) {
err_code = LastWresErr();
goto OutputWriteError;
}
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_HELPTABLE ), flags, loc );
} else {
RcMemFree( name );
}
SemOS2FreeHelpTable( helptable );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
strerror( err_code ) );
ErrorHasOccured = TRUE;
SemOS2FreeHelpTable( helptable );
return;
}
ResLocation SemCopyRawFile( const char *filename )
/************************************************/
{
WResFileID fid;
RcStatus ret;
char *buffer;
char full_filename[_MAX_PATH];
ResLocation loc;
int err_code;
WResFileOffset pos;
buffer = RESALLOC( BUFFER_SIZE );
if( RcFindResource( filename, full_filename ) == -1 ) {
RcError( ERR_CANT_FIND_FILE, filename );
goto HANDLE_ERROR;
}
if( AddDependency( full_filename ) )
goto HANDLE_ERROR;
fid = RcIoOpenInput( full_filename, false );
if( fid == WRES_NIL_HANDLE ) {
RcError( ERR_CANT_OPEN_FILE, filename, strerror( errno ) );
goto HANDLE_ERROR;
}
loc.start = SemStartResource();
pos = RESTELL( fid );
if( pos == -1 ) {
RcError( ERR_READING_DATA, full_filename, strerror( errno ) );
RESCLOSE( fid );
goto HANDLE_ERROR;
} else {
ret = SemCopyDataUntilEOF( pos, fid, buffer, BUFFER_SIZE, &err_code );
if( ret != RS_OK ) {
ReportCopyError( ret, ERR_READING_DATA, full_filename, err_code );
RESCLOSE( fid );
goto HANDLE_ERROR;
}
}
loc.len = SemEndResource( loc.start );
RESCLOSE( fid );
RESFREE( buffer );
return( loc );
HANDLE_ERROR:
ErrorHasOccured = true;
loc.start = 0;
loc.len = 0;
RESFREE( buffer );
return( loc );
}
/* The OS/2 dialog templates present us with a problem because the
template items contain a number of offsets that are not known until
the template is processed; this means we cannot just start spitting
the data into a file. Instead we build an in-memory image of the
resource (the size must be < 64K) and then dump the entire resource
into the file - which certainly shouldn't hurt performance either.
*/
extern void SemOS2WriteDialogTemplate( WResID *name, ResMemFlags flags,
uint_32 codepage,
FullDiagCtrlListOS2 *ctrls )
/*********************************************************************/
{
ResLocation loc;
int err_code;
int error;
int size;
DialogHeaderOS2 *head = NULL;
char *tmpl;
char *ptr;
size = sizeof( DialogHeaderOS2 ) + SemOS2CalcControlSize( ctrls );
if( size > 65536 ) {
// TODO: Error, template is too big
}
tmpl = RcMemMalloc( size );
head = (DialogHeaderOS2 *)tmpl;
InitOS2DialogBoxHeader( head, codepage );
head->Size = size;
ptr = tmpl + sizeof( DialogHeaderOS2 );
// Create the DLGTITEM array in memory
ptr = SemOS2BuildTemplateArray( ptr, ctrls );
// Dump all other data into memory and update the offsets
SemOS2DumpTemplateData( tmpl, ptr, ctrls );
// Write the resource to file
loc.start = SemStartResource();
error = ResOS2WriteDlgTemplate( tmpl, size, CurrResFile.handle );
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
RcMemFree( tmpl );
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_DIALOG ), flags, loc );
SemOS2FreeDiagCtrlList( ctrls );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
strerror( err_code ) );
ErrorHasOccured = TRUE;
SemOS2FreeDiagCtrlList( ctrls );
return;
} /* SemOS2WriteDialogTemplate */
void SemWriteMenu( WResID *name, ResMemFlags flags, FullMenu *menu,
uint_16 tokentype )
/********************************************************************/
{
MenuHeader head;
ResLocation loc;
int error = 0;
int err_code;
uint_8 headerdata[ RES_HEADER_SIZE ];
if(!ErrorHasOccured) {
if( tokentype == Y_MENU ) {
head.Version = 0; /* currently these fields are both 0 */
head.HeaderSize = 0;
loc.start = SemStartResource();
error = ResWriteMenuHeader( &head, CurrResFile.handle );
} else if( tokentype == Y_MENU_EX ) {
head.Version = RES_HEADER_VERSION;
head.HeaderSize = RES_HEADER_SIZE;
memset( headerdata, 0, head.HeaderSize );
ResPadDWord( CurrResFile.handle );
loc.start = SemStartResource();
error = ResWriteMenuExHeader( &head, CurrResFile.handle, headerdata );
} else {
loc.start = 0; // Is this valid?
}
if(error) {
err_code = LastWresErr();
goto OutputWriteError;
}
error = SemWriteSubMenu( menu, &err_code, tokentype );
if( !error && CmdLineParms.MSResFormat &&
CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
error = ResPadDWord( CurrResFile.handle );
}
if(error) goto OutputWriteError;
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( RT_MENU ), flags, loc );
} else {
RcMemFree( name );
}
SemFreeSubMenu( menu );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
strerror( err_code ) );
ErrorHasOccured = TRUE;
SemFreeSubMenu( menu );
return;
}
static RcStatus copyCursors( FullCurDir * dir, WResFileID handle,
ResMemFlags flags, int *err_code )
/***********************************************************************/
/* This function uses the same size of buffers to copy info as for icons */
{
RcStatus ret = RS_OK; // should this be RS_PARAM_ERROR ??
char * buffer;
FullCurDirEntry * entry;
CurFileDirEntry fileentry;
CurHotspot hotspot;
BitmapInfoHeader dibhead;
ResLocation loc;
buffer = RCALLOC( BUFFER_SIZE );
for( entry = dir->Head; entry != NULL; entry = entry->Next ) {
/* copy the cursor */
loc.start = SemStartResource();
hotspot.X = entry->Entry.Cur.XHotspot;
hotspot.Y = entry->Entry.Cur.YHotspot;
if( ResWriteCurHotspot( &hotspot, CurrResFile.handle ) ) {
ret = RS_WRITE_ERROR;
*err_code = LastWresErr();
break;
}
/* NOTE: the dibhead structure is filled in as a result of this call */
ret = copyOneCursor( &(entry->Entry.Cur), handle, buffer,
BUFFER_SIZE, &(dibhead), err_code );
if( ret != RS_OK )
break;
loc.len = SemEndResource( loc.start );
/* add the cursor to the RES file directory */
SemAddResourceFree( WResIDFromNum( CurrResFile.NextCurOrIcon ),
WResIDFromNum( (long)(pointer_int)RT_CURSOR ), flags, loc );
/* change the reference in the cursor directory */
fileentry = entry->Entry.Cur;
entry->IsCurFileEntry = false;
entry->Entry.Res.Width = dibhead.Width;
entry->Entry.Res.Height = dibhead.Height;
entry->Entry.Res.Planes = dibhead.Planes;
entry->Entry.Res.BitCount = dibhead.BitCount;
/* the hotspot data is now part of the components */
entry->Entry.Res.Length = fileentry.Length + sizeof(CurHotspot);
entry->Entry.Res.CurID = CurrResFile.NextCurOrIcon;
CurrResFile.NextCurOrIcon += 1;
}
RCFREE( buffer );
return( ret );
} /* copyCursors */
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 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;
}
static bool copyAResource( WResFileID fid, WResDirWindow *wind,
char *buffer, const char *filename )
/****************************************************************/
{
ResLocation loc;
WResLangInfo *langinfo;
WResTypeInfo *typeinfo;
WResResInfo *resinfo;
// RcStatus rc;
int err_code;
langinfo = WResGetLangInfo( *wind );
resinfo = WResGetResInfo( *wind );
typeinfo = WResGetTypeInfo( *wind );
loc.start = SemStartResource();
/* rc = */ CopyData( langinfo->Offset, langinfo->Length, fid, buffer, BUFFER_SIZE, &err_code );
loc.len = SemEndResource( loc.start );
SemAddResource2( &resinfo->ResName, &typeinfo->TypeName, langinfo->MemoryFlags, loc, filename );
return( false );
}
static RcStatus copyIcons( FullIconDir * dir, WResFileID handle,
ResMemFlags flags, int *err_code )
/**************************************************************/
{
RcStatus ret;
char * buffer;
FullIconDirEntry * entry;
BitmapInfoHeader dibhead;
ResLocation loc;
ret = RS_OK;
buffer = RCALLOC( BUFFER_SIZE );
for( entry = dir->Head; entry != NULL; entry = entry->Next ) {
/* copy the icon */
loc.start = SemStartResource();
/* NOTE: the dibhead structure is filled in as a result of this call */
ret = copyOneIcon( &(entry->Entry.Ico), handle, buffer, BUFFER_SIZE, &(dibhead), err_code );
if( ret != RS_OK )
break;
loc.len = SemEndResource( loc.start );
/* add the icon to the RES file directory */
SemAddResourceFree( WResIDFromNum( CurrResFile.NextCurOrIcon ),
WResIDFromNum( (long)(pointer_int)RT_ICON ), flags, loc );
/* change the reference in the ICON directory */
entry->IsIcoFileEntry = false;
entry->Entry.Res.IconID = CurrResFile.NextCurOrIcon;
entry->Entry.Res.Info.Planes = dibhead.Planes;
entry->Entry.Res.Info.BitCount = dibhead.BitCount;
CurrResFile.NextCurOrIcon += 1;
}
RCFREE( buffer );
return( ret );
} /* copyIcons */
void SemWriteToolBar( WResID *name, ToolBar *toolbar,
unsigned long item1, unsigned long item2,
ResMemFlags flags ) {
ResLocation loc;
unsigned cnt;
ToolBarItems *cur;
if(!ErrorHasOccured) {
loc.start = SemStartResource();
cnt = ( toolbar->nodecnt - 1 ) * TB_ITEM_CNT;
cnt += toolbar->last->cnt;
ResWriteToolBarHeader( CurrResFile.handle, item1, item2, cnt );
cur = &toolbar->first;
while( cur != NULL ) {
ResWriteToolBarItems( CurrResFile.handle, cur->items, cur->cnt );
cur = cur->next;
}
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( RT_TOOLBAR ), flags, loc );
}
semFreeToolBar( toolbar );
}
static bool writeCurDir( FullCurDir *dir, WResID *name, ResMemFlags flags,
int *err_code )
/****************************************************************************/
{
bool error;
FullCurDirEntry * entry;
ResLocation loc;
loc.start = SemStartResource();
error = ResWriteIconCurDirHeader( &(dir->Header), CurrResFile.fid );
for( entry = dir->Head; !error && entry != NULL; entry = entry->Next ) {
error = ResWriteCurDirEntry( &(entry->Entry.Res), CurrResFile.fid );
}
if( !error ) {
loc.len = SemEndResource( loc.start );
SemAddResourceFree( name, WResIDFromNum( RESOURCE2INT( RT_GROUP_CURSOR ) ), flags, loc );
} else {
*err_code = LastWresErr();
}
return( error );
}
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 */
void SemWINWriteVerInfo( WResID * name, ResMemFlags flags,
VerFixedInfo * info, FullVerBlockNest * nest )
/********************************************************************/
{
WResLangType lang;
VerBlockHeader root;
ResLocation loc;
int padding;
bool error;
bool use_unicode;
uint_8 os;
int err_code;
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
use_unicode = true;
os = WRES_OS_WIN32;
} else {
use_unicode = false;
os = WRES_OS_WIN16;
}
root.Key = "VS_VERSION_INFO";
root.ValSize = sizeof(VerFixedInfo);
root.Type = 0;
padding = RES_PADDING( root.ValSize, sizeof(uint_32) );
root.Size = ResSizeVerBlockHeader( &root, use_unicode, os )
+ root.ValSize + padding + CalcNestSize( nest );
/* pad the start of the resource so that padding within the resource */
/* is easier */
error = ResPadDWord( CurrResFile.handle );
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
if( !ErrorHasOccured ) {
loc.start = SemStartResource();
error = ResWriteVerBlockHeader( &root, use_unicode, os,
CurrResFile.handle);
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
error = ResWriteVerFixedInfo( info, CurrResFile.handle );
if( error ) {
err_code = LastWresErr();
goto OutputWriteError;
}
if( ResSeek( CurrResFile.handle, padding, SEEK_CUR ) == -1 ) {
err_code = LastWresErr();
goto OutputWriteError;
}
error = SemWriteVerBlockNest( nest, CurrResFile.handle, &err_code );
if( error)
goto OutputWriteError;
loc.len = SemEndResource( loc.start );
/* version info resources must be language neutral */
lang.lang = DEF_LANG;
lang.sublang = DEF_SUBLANG;
SemWINSetResourceLanguage( &lang, false );
SemAddResourceFree( name, WResIDFromNum( RT_VERSIONINFO ), flags, loc );
} else {
RCFREE( name );
}
RCFREE( info );
FreeVerBlockNest( nest );
return;
OutputWriteError:
RcError( ERR_WRITTING_RES_FILE, CurrResFile.filename,
strerror( err_code ) );
ErrorHasOccured = true;
RCFREE( info );
FreeVerBlockNest( nest );
return;
}