int ResWriteNameOrOrdinal( ResNameOrOrdinal *name, uint_8 use_unicode, int handle )
/*********************************************************************************/
{
int error;
uint_16 flag;
uint_16 tmp16;
uint_8 tmp8;
if( name == NULL ) {
error = ResWriteString( "", use_unicode, handle );
} else {
if (name->ord.fFlag == 0xff) {
if( use_unicode ) {
flag = 0xffff;
error = ResWriteUint16( &flag, handle );
} else {
tmp8 = name->ord.fFlag;
error = ResWriteUint8( &tmp8, handle );
}
if (!error) {
tmp16 = name->ord.wOrdinalID;
ResWriteUint16( &tmp16, handle );
}
} else {
error = ResWriteString( name->name, use_unicode, handle );
}
}
return( error );
} /* ResWriteNameOrOrdinal */
static bool ResWriteDialogControlCommon32( ControlClass *class_id, ResNameOrOrdinal *text,
uint_16 extra_bytes, FILE *fp )
/****************************************************************************************/
{
bool error;
/* if the ClassID is one of the predefined ones write it out as a byte */
/* otherwise it is a string */
if( class_id->Class & 0x80 ) {
/*the class number is prefixed by 0xFFFF to distinguish it
* from a string */
error = ResWriteUint16( (uint_16)-1, fp );
if( !error ) {
error = ResWriteUint16( class_id->Class, fp );
}
} else {
error = ResWriteString( class_id->ClassName, true, fp );
}
if( !error ) {
error = ResWriteNameOrOrdinal( text, true, fp );
}
if( !error ) {
error = ResWriteUint16( extra_bytes, fp );
}
return( error );
}
static bool SemOS2WriteHelpSubTableEntries( FullHelpSubTableOS2 *helptable,
WResFileID handle )
/************************************************************************/
{
FullHelpSubEntryOS2 *currentry = NULL;
bool error;
uint_16 tmp = 2;
if( helptable != NULL ) {
currentry = helptable->head;
tmp = helptable->numWords;
}
error = ResWriteUint16( &tmp, handle );
while( currentry != NULL && !error ) {
error = SemOS2WriteHelpData( currentry->dataListHead, handle,
helptable->numWords );
currentry = currentry->next;
}
if( !error ) {
tmp = 0;
error = ResWriteUint16( &tmp, handle ); // Closing zero
}
return( error );
}
bool ResWriteDialogBoxHeader32( DialogBoxHeader32 *head, FILE *fp )
/*****************************************************************/
{
bool error;
error = ResWriteUint32( head->Style, fp );
if( !error ) {
error = ResWriteUint32( head->ExtendedStyle, fp );
}
if( !error ) {
error = ResWriteUint16( head->NumOfItems, fp );
}
if( !error ) {
error = ResWriteDialogSizeInfo( &(head->SizeInfo), fp );
}
if( !error ) {
error = ResWriteDialogHeaderCommon32( head, fp, false );
}
/* if the font was set output the font name and point size */
if( !error && (head->Style & DS_SETFONT) ) {
error = ResWriteUint16( head->PointSize, fp );
if( !error ) {
error = ResWriteString( head->FontName, true, fp );
}
}
if( !error ) {
/* padding full record to dword boundary if necessary */
error = ResWritePadDWord( fp );
}
return( error );
}
bool ResWriteDialogBoxExHeader32( DialogBoxHeader32 *head, DialogBoxExHeader32short *exhead, FILE *fp )
/*****************************************************************************************************/
{
bool error;
/* Write out the miscellaneous two WORDs 0x0001, 0xFFFF */
error = ResWriteUint16( 0x0001, fp );
if( !error ) {
error = ResWriteUint16( 0xFFFF, fp );
}
if( !error ) {
error = ResWriteUint32( exhead->HelpId, fp );
}
if( !error ) {
error = ResWriteUint32( head->ExtendedStyle, fp );
}
if( !error ) {
error = ResWriteUint32( head->Style, fp );
}
if( !error ) {
error = ResWriteUint16( head->NumOfItems, fp );
}
if( !error ) {
error = ResWriteDialogSizeInfo( &(head->SizeInfo), fp );
}
if( !error ) {
error = ResWriteDialogHeaderCommon32( head, fp, true );
}
/* If the font was set, write the font information */
if( !error && (head->Style & DS_SETFONT) ) {
error = ResWriteUint16( head->PointSize, fp );
if( !error ) {
error = ResWriteUint16( exhead->FontWeight, fp );
}
if( !error ) {
error = ResWriteUint8( exhead->FontItalic, fp );
}
if( !error ) {
error = ResWriteUint8( exhead->FontCharset, fp );
}
if( !error ) {
error = ResWriteString( head->FontName, true, fp );
}
}
if( !error ) {
/* padding full record to dword boundary if necessary */
error = ResWritePadDWord( fp );
}
return( error );
}
bool MResWriteResourceHeader( MResResourceHeader *currhead, WResFileID handle, bool iswin32 )
/*******************************************************************************************/
{
bool error;
if( !iswin32 ) {
error = ResWriteNameOrOrdinal( currhead->Type, false, handle );
if( !error ) {
error = ResWriteNameOrOrdinal( currhead->Name, false, handle );
}
if( !error ) {
error = ResWriteUint16( currhead->MemoryFlags, handle );
}
if( !error ) {
error = ResWriteUint32( currhead->Size, handle );
}
} else {
error = ResWriteUint32( currhead->Size, handle );
if( !error ) {
error = ResWriteUint32( MResFindHeaderSize( currhead, true ), handle );
}
if( !error ) {
error = ResWriteNameOrOrdinal( currhead->Type, true, handle );
}
if( !error ) {
error = ResWriteNameOrOrdinal( currhead->Name, true, handle );
}
if( !error ) {
error = ResWritePadDWord( handle );
}
if( !error ) {
error = ResWriteUint32( currhead->DataVersion, handle );
}
if( !error ) {
error = ResWriteUint16( currhead->MemoryFlags, handle );
}
if( !error ) {
error = ResWriteUint16( currhead->LanguageId, handle );
}
if( !error ) {
error = ResWriteUint32( currhead->Version, handle );
}
if( !error ) {
error = ResWriteUint32( currhead->Characteristics, handle );
}
}
return( error );
} /* MResWriteResourceHeader */
bool ResWriteMenuExItemNormal( const MenuItemNormal *curritem, const MenuExItemNormal *exdata,
bool use_unicode, WResFileID handle )
/*******************************************************************************************/
{
bool error;
uint_16 tmp16;
uint_32 tmp32;
if( curritem->ItemFlags & MENUEX_POPUP ) {
WRES_ERROR( WRS_BAD_PARAMETER );
error = true;
} else {
error = ResWriteUint32( &(exdata->ItemType), handle );
if( !error ) {
error = ResWriteUint32( &(exdata->ItemState), handle );
}
if( !error ) {
tmp32 = curritem->ItemID;
error = ResWriteUint32( &tmp32, handle );
}
if( !error ) {
tmp16 = curritem->ItemFlags;
error = ResWriteUint16( &tmp16, handle );
}
if( !error ) {
error = ResWriteString( curritem->ItemText, use_unicode, handle );
}
if( !error ) {
error = ResPadDWord( handle );
}
}
return( error );
}
bool ResWriteDialogBoxHeader( DialogBoxHeader *head, FILE *fp )
/*************************************************************/
{
bool error;
error = ResWriteUint32( head->Style, fp );
if( !error ) {
error = ResWriteUint8( head->NumOfItems, fp );
}
if( !error ) {
error = ResWriteDialogSizeInfo( &(head->SizeInfo), fp );
}
if( !error ) {
error = ResWriteNameOrOrdinal( head->MenuName, false, fp );
}
if( !error ) {
error = ResWriteNameOrOrdinal( head->ClassName, false, fp );
}
if( !error ) {
error = ResWriteString( head->Caption, false, fp );
}
/* if the font was set output the font name and point size */
if( !error && (head->Style & DS_SETFONT) ) {
error = ResWriteUint16( head->PointSize, fp );
if( !error ) {
error = ResWriteString( head->FontName, false, fp );
}
}
return( error );
}
bool ResWriteDialogBoxControl32( DialogBoxControl32 *control, FILE *fp )
/**********************************************************************/
{
bool error;
error = ResWriteUint32( control->Style, fp );
if( !error ) {
error = ResWriteUint32( control->ExtendedStyle, fp );
}
if( !error ) {
error = ResWriteDialogSizeInfo( &(control->SizeInfo), fp );
}
if( !error ) {
error = ResWriteUint16( control->ID, fp );
}
if( !error ) {
error = ResWriteDialogControlCommon32( control->ClassID, control->Text, control->ExtraBytes, fp );
}
if( !error ) {
/* padding full record to dword boundary if necessary */
error = ResWritePadDWord( fp );
}
return( error );
}
bool ResWriteDialogBoxControl( DialogBoxControl *control, FILE *fp )
/******************************************************************/
{
bool error;
error = ResWriteDialogSizeInfo( &(control->SizeInfo), fp );
if( !error ) {
error = ResWriteUint16( control->ID, fp );
}
if( !error ) {
error = ResWriteUint32( control->Style, fp );
}
/* if the ClassID is one of the predefined ones write it out as a byte */
/* otherwise it is a string */
if( !error ) {
if( control->ClassID->Class & 0x80 ) {
error = ResWriteUint8( control->ClassID->Class, fp );
} else {
error = ResWriteString( control->ClassID->ClassName, false, fp );
}
}
if( !error ) {
error = ResWriteNameOrOrdinal( control->Text, false, fp );
}
if( !error ) {
error = ResWriteUint8( control->ExtraBytes, fp );
}
return( error );
}
static bool ResWriteDialogSizeInfo( DialogSizeInfo *sizeinfo, FILE *fp )
/**********************************************************************/
{
bool error;
error = ResWriteUint16( sizeinfo->x, fp );
if( !error ) {
error = ResWriteUint16( sizeinfo->y, fp );
}
if( !error ) {
error = ResWriteUint16( sizeinfo->width, fp );
}
if( !error ) {
error = ResWriteUint16( sizeinfo->height, fp );
}
return( error );
}
static bool writeAccelTableEntries( FullAccelTableOS2 *acctable,
WResFileID fid, uint_32 codepage )
/*******************************************************************/
{
FullAccelEntryOS2 *currentry;
bool error;
error = ResWriteUint16( SemOS2CountAccelTableEntries( acctable ), fid );
if( !error ) {
error = ResWriteUint16( codepage, fid );
}
currentry = acctable->head;
while( currentry != NULL && !error ) {
ResOS2WriteAccelEntry( ¤try->entry, fid );
currentry = currentry->next;
}
return( error );
}
static int writeAccelTableEntries( FullAccelTableOS2 *acctable,
WResFileID handle, uint_32 codepage )
/**********************************************************************/
{
FullAccelEntryOS2 *currentry;
int error;
uint_16 tmp;
tmp = SemOS2CountAccelTableEntries( acctable );
error = ResWriteUint16( &tmp, handle );
if( !error ) {
tmp = codepage;
error = ResWriteUint16( &tmp, handle );
}
currentry = acctable->head;
while( currentry != NULL && !error ) {
ResOS2WriteAccelEntry( ¤try->entry, handle );
currentry = currentry->next;
}
return( error );
}
int ResWriteToolBarHeader( WResFileID handle, uint_16 item1, uint_16 item2, uint_16 cnt )
/***************************************************************************************/
{
uint_16 tmp;
int ret;
// don't know why but MS RC puts out a 1 at the start of the resourece
// perhaps this is a version ????
tmp = 1;
ret = ResWriteUint16( &tmp, handle );
if( !ret ) {
ret = ResWriteUint16( &item1, handle );
}
if( !ret ) {
ret = ResWriteUint16( &item2, handle );
}
if( !ret ) {
ret = ResWriteUint16( &cnt, handle );
}
return( ret );
}
extern int ResOS2WriteStringTableBlock( StringTableBlock *currblock,
int handle, uint_32 codepage )
/********************************************************************/
{
int stringid;
int error;
WResIDName *name;
uint_16 tmp16;
uint_8 tmp8;
uint_8 tmpzero = 0;
// Write string table codepage
tmp16 = codepage;
error = ResWriteUint16( &tmp16, handle );
if( error )
return( error );
tmp16 = 1;
for( stringid = 0, error = FALSE; stringid < STRTABLE_STRS_PER_BLOCK
&& !error; stringid++ ) {
name = currblock->String[ stringid ];
if( name == NULL ) {
// Write an empty string
error = ResWriteUint16( &tmp16, handle );
} else {
// The string can't be longer than 255 chars
tmp8 = (name->NumChars + 1) & 0xFF;
error = ResWriteUint8( &tmp8, handle );
if( !error )
error = ResWriteStringLen( name->Name, FALSE, handle, tmp8 - 1 );
// The terminating NULL is not stored in the table, need to add it now
if( !error )
error = ResWriteUint8( &tmpzero, handle );
}
}
return( error );
} /* ResOS2WriteStringTableBlock */
int ResOS2WriteMenuItemNormal( const MenuItemOS2 *curritem, WResFileID handle )
/*****************************************************************************/
{
int error;
uint_16 tmp16;
tmp16 = curritem->ItemStyle;
error = ResWriteUint16( &tmp16, handle );
if( !error ) {
tmp16 = curritem->ItemAttrs;
error = ResWriteUint16( &tmp16, handle );
}
if( !error ) {
tmp16 = curritem->ItemCmd;
error = ResWriteUint16( &tmp16, handle );
}
if( !error ) {
if( !(curritem->ItemStyle & OS2_MIS_SEPARATOR) && curritem->ItemText != NULL )
error = ResWriteString( curritem->ItemText, FALSE, handle );
}
return( error );
}
static bool ResOS2WriteStringTableBlock( StringTableBlock *currblock, WResFileID fid, uint_32 codepage )
/******************************************************************************************************/
{
int stringid;
bool error;
WResIDName *name;
// Write string table codepage
error = ResWriteUint16( codepage, fid );
if( error )
return( error );
error = false;
for( stringid = 0; stringid < STRTABLE_STRS_PER_BLOCK && !error; stringid++ ) {
name = currblock->String[stringid];
if( name == NULL ) {
// Write an empty string
error = ResWriteUint16( 1, fid );
} else {
size_t len;
// The string can't be longer than 255 chars
len = name->NumChars + 1;
if( len > 255 )
len = 255;
error = ResWriteUint8( len, fid );
if( !error )
error = ResWriteStringLen( name->Name, false, fid, len - 1 );
// The terminating NULL is not stored in the table, need to add it now
if( !error ) {
error = ResWriteUint8( 0, fid );
}
}
}
return( error );
} /* ResOS2WriteStringTableBlock */
bool ResWriteMenuItemNormal( const MenuItemNormal *curritem, bool use_unicode,
WResFileID handle )
/******************************************************************************/
{
bool error;
uint_16 tmp16;
if( curritem->ItemFlags & MENU_POPUP ) {
WRES_ERROR( WRS_BAD_PARAMETER );
error = true;
} else {
tmp16 = curritem->ItemFlags;
error = ResWriteUint16( &tmp16, handle );
if( !error ) {
tmp16 = curritem->ItemID;
error = ResWriteUint16( &tmp16, handle );
}
if( !error ) {
error = ResWriteString( curritem->ItemText, use_unicode, handle );
}
}
return( error );
}
bool ResWriteNameOrOrdinal( ResNameOrOrdinal *name, bool use_unicode, WResFileID handle )
/*****************************************************************************************/
{
bool error;
if( name == NULL ) {
error = ResWriteString( "", use_unicode, handle );
} else {
if( name->ord.fFlag == 0xff ) {
if( use_unicode ) {
error = ResWriteUint16( (uint_16)-1, handle );
} else {
error = ResWriteUint8( name->ord.fFlag, handle );
}
if( !error ) {
error = ResWriteUint16( name->ord.wOrdinalID, handle );
}
} else {
error = ResWriteString( name->name, use_unicode, handle );
}
}
return( error );
} /* ResWriteNameOrOrdinal */
int WResWriteWResIDNameUni( const WResIDName *name, uint_8 use_unicode, int handle )
/**********************************************************************************/
{
int error;
wio_ssize_t numwrote;
uint_16 numchars;
uint_8 tmp;
char *ptr;
int freebuf;
freebuf = FALSE;
error = FALSE;
if (name == NULL) {
/* a NULL name means write 0 length name */
numchars = 0;
} else {
numchars = name->NumChars;
}
if( use_unicode ) {
// for short strings use a static buffer in improve performance
if( numchars <= CONV_BUF_SIZE / 2 ) {
ptr = ConvBuffer;
} else {
freebuf = TRUE;
ptr = WRESALLOC( 2 * numchars );
}
numchars = (ConvToUnicode)( numchars, name->Name, ptr ) / 2;
error = ResWriteUint16( &numchars, handle );
numchars *= 2;
} else {
numchars &= 0xFF; /* in 16-bit the string can be no more than
256 characters*/
tmp = numchars;
ptr = (char *)name->Name;
error = ResWriteUint8( &tmp, handle );
}
if( !error && numchars > 0 ) {
numwrote = WRESWRITE( handle, ptr, numchars );
if( numwrote != numchars ) {
error = TRUE;
WRES_ERROR( WRS_WRITE_FAILED );
}
}
if( freebuf ) {
WRESFREE( ptr );
}
return( error );
} /* WResWriteWResIDNameUni */
bool WResWriteWResID( const WResID *name, WResFileID handle )
/***********************************************************/
{
bool error;
error = ResWriteUint8( name->IsName, handle );
if( !error ) {
if( name->IsName ) {
error = WResWriteWResIDName( &(name->ID.Name), handle );
} else {
error = ResWriteUint16( name->ID.Num, handle );
}
}
return( error );
} /* WResWriteWResID */
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;
}
}
}
}
bool WResWriteWResIDNameUni( const WResIDName *name, bool use_unicode, WResFileID handle )
/******************************************************************************************/
{
bool error;
uint_16 numchars;
char *ptr;
bool freebuf;
freebuf = false;
error = false;
if( name == NULL ) {
/* a NULL name means write 0 length name */
numchars = 0;
} else {
numchars = name->NumChars;
}
if( use_unicode ) {
// for short strings use a static buffer in improve performance
if( numchars <= CONV_BUF_SIZE / 2 ) {
ptr = ConvBuffer;
} else {
freebuf = true;
ptr = WRESALLOC( 2 * numchars );
}
numchars = (ConvToUnicode)( numchars, name->Name, ptr ) / 2;
error = ResWriteUint16( numchars, handle );
numchars *= 2;
} else {
/* in 16-bit resources the string can be no more than 255 characters */
if( numchars > 0xFF )
numchars = 0xFF;
ptr = (char *)name->Name;
error = ResWriteUint8( numchars, handle );
}
if( !error && numchars > 0 ) {
if( WRESWRITE( handle, ptr, numchars ) != numchars ) {
error = true;
WRES_ERROR( WRS_WRITE_FAILED );
}
}
if( freebuf ) {
WRESFREE( ptr );
}
return( error );
} /* WResWriteWResIDNameUni */
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;
}
static bool SemOS2WriteHelpData( DataElemList *list, WResFileID handle, int count )
/************************************************************************************/
{
uint_16 data;
bool error;
int i;
error = false;
if( list->count > count ) {
//TODO: output warning
} else if( list->count < count ) {
// error
return( true );
}
for( i = 0; i < count; i++ ) {
data = (uint_16)list->data[i].Item.Num;
error = ResWriteUint16( &data, handle );
}
return( error );
}
static int SemOS2WriteHelpTableEntries( FullHelpTableOS2 * helptable,
WResFileID handle )
/*********************************************************************/
{
FullHelpEntryOS2 *currentry;
int error = 0;
uint_16 tmp = 0;
if( helptable != NULL ) {
currentry = helptable->head;
while( currentry != NULL && !error ) {
error = ResOS2WriteHelpEntry( ¤try->entry, handle );
currentry = currentry->next;
}
}
if( !error )
error = ResWriteUint16( &tmp, handle ); // Closing zero
return( error );
}
int WResWriteWResID( const WResID *name, int handle )
/***************************************************/
{
int error;
uint_16 tmp16;
uint_8 tmp8;
tmp8 = name->IsName;
error = ResWriteUint8( &tmp8, handle );
if( !error ) {
if( name->IsName ) {
error = WResWriteWResIDName( &(name->ID.Name), handle );
} else {
tmp16 = name->ID.Num;
error = ResWriteUint16( &tmp16, handle );
}
}
return( error );
} /* WResWriteWResID */
int MResWriteResourceHeader( MResResourceHeader *currhead, int handle, char iswin32 )
/***********************************************************************************/
{
int error;
uint_32 headersize;
uint_16 tmp16;
uint_32 tmp32;
if( !iswin32 ) {
error = ResWriteNameOrOrdinal( currhead->Type, FALSE, handle );
if (!error) {
error = ResWriteNameOrOrdinal( currhead->Name, FALSE, handle );
}
if (!error) {
tmp16 = currhead->MemoryFlags;
error = ResWriteUint16( &tmp16, handle );
}
if (!error) {
tmp32 = currhead->Size;
error = ResWriteUint32( &tmp32, handle );
}
} else {
tmp32 = currhead->Size;
error = ResWriteUint32( &tmp32, handle );
if( !error ) {
headersize = MResFindHeaderSize( currhead, TRUE );
error = ResWriteUint32( &headersize, handle );
}
if( !error ) {
error = ResWriteNameOrOrdinal( currhead->Type, TRUE, handle );
}
if( !error ) {
error = ResWriteNameOrOrdinal( currhead->Name, TRUE, handle );
}
if( !error ) {
error = ResPadDWord( handle );
}
if( !error ) {
tmp32 = currhead->DataVersion;
error = ResWriteUint32( &tmp32, handle );
}
if( !error ) {
tmp16 = currhead->MemoryFlags;
error = ResWriteUint16( &tmp16, handle );
}
if( !error ) {
tmp16 = currhead->LanguageId;
error = ResWriteUint16( &tmp16, handle );
}
if( !error ) {
tmp32 = currhead->Version;
error = ResWriteUint32( &tmp32, handle );
}
if( !error ) {
tmp32 = currhead->Characteristics;
error = ResWriteUint32( &tmp32, handle );
}
}
return( error );
} /* MResWriteResourceHeader */
