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 );
}
static int CompareOneResource( WResFileID fid1, WResDirWindow wind1,
WResFileID fid2, WResDirWindow wind2 )
/********************************************************************/
{
int retcode;
int oldretcode;
WResResInfo *res1;
WResResInfo *res2;
WResLangInfo *lang1;
WResLangInfo *lang2;
char * resname1;
oldretcode = 0;
res1 = WResGetResInfo( wind1 );
res2 = WResGetResInfo( wind2 );
lang1 = WResGetLangInfo( wind1 );
lang2 = WResGetLangInfo( wind2 );
if (lang1->MemoryFlags != lang2->MemoryFlags) {
if (!CmdLineParms.Quiet) {
resname1 = WResIDToStr( &(res1->ResName) );
printf( "Error: memory flags for resource %s are not the same\n",
resname1 );
RESFREE( resname1 );
}
oldretcode = 1;
}
if (lang1->Length != lang2->Length) {
if (!CmdLineParms.Quiet) {
resname1 = WResIDToStr( &(res1->ResName) );
printf( "Error: resource %s does not have the same length\n",
resname1 );
RESFREE( resname1 );
}
oldretcode = 1;
} else {
retcode = BinaryCompare( fid1, lang1->Offset, fid2,
lang2->Offset, lang1->Length );
switch (retcode) {
case 1:
if (!CmdLineParms.Quiet) {
resname1 = WResIDToStr( &(res1->ResName) );
printf( "Error: contents of resource %s are different.\n",
resname1 );
RESFREE( resname1 );
}
oldretcode = retcode;
break;
case -1:
oldretcode = retcode;
break;
}
}
return( oldretcode );
}
static void AddBitmapResource( WResID * name, ResMemFlags flags,
const char * filename )
/**************************************************************/
{
BitmapFileHeader head;
WResFileID fid;
RcStatus ret;
int err_code;
fid = RcIoOpenInput( filename, false );
if( fid == WRES_NIL_HANDLE)
goto FILE_OPEN_ERROR;
ret = readBitmapFileHeader( fid, &head, &err_code );
if( ret != RS_OK )
goto READ_HEADER_ERROR;
if( head.Type != BITMAP_MAGIC )
goto NOT_BITMAP_ERROR;
ret = copyBitmap( &head, fid, name, flags, &err_code );
if( ret != RS_OK )
goto COPY_BITMAP_ERROR;
RESCLOSE( fid );
return;
FILE_OPEN_ERROR:
RcError( ERR_CANT_OPEN_FILE, filename, strerror( errno ) );
ErrorHasOccured = true;
RESFREE( name );
return;
READ_HEADER_ERROR:
ReportCopyError( ret, ERR_READING_BITMAP, filename, err_code );
ErrorHasOccured = true;
RESFREE( name );
RESCLOSE( fid );
return;
NOT_BITMAP_ERROR:
RcError( ERR_NOT_BITMAP_FILE, filename );
ErrorHasOccured = true;
RESFREE( name );
RESCLOSE( fid );
return;
COPY_BITMAP_ERROR:
ReportCopyError( ret, ERR_READING_BITMAP, filename, err_code );
ErrorHasOccured = true;
RESCLOSE( fid );
return;
}
static void FreeLXFileInfoPtrs( LXExeInfo *info )
/***********************************************/
{
if( info->Objects != NULL ) {
RESFREE( info->Objects );
}
if( info->Pages != NULL ) {
RESFREE( info->Pages );
}
if( info->Res.resources != NULL ) {
RESFREE( info->Res.resources );
}
}
static void FreeFontDir( FullFontDir *olddir )
/********************************************/
{
FullFontDirEntry *currentry;
FullFontDirEntry *nextentry;
for( currentry = olddir->Head; currentry != NULL; currentry = nextentry ) {
nextentry = currentry->Next;
RESFREE( currentry );
}
RESFREE( olddir );
}
static void SemOS2FreeAccelTable( FullAccelTableOS2 * acctable )
/**************************************************************/
{
FullAccelEntryOS2 *currentry;
FullAccelEntryOS2 *oldentry;
currentry = acctable->head;
while( currentry != NULL ) {
oldentry = currentry;
currentry = currentry->next;
RESFREE( oldentry );
}
RESFREE( acctable );
}
static WResDirWindow LookUpResource( WResDirWindow wind1, WResDir dir2 )
/**********************************************************************/
{
WResDirWindow wind2;
WResTypeInfo *type1;
WResResInfo *res1;
WResLangInfo *lang1;
char *resname1;
type1 = WResGetTypeInfo( wind1 );
res1 = WResGetResInfo( wind1 );
lang1 = WResGetLangInfo( wind1 );
wind2 = WResFindResource( &(type1->TypeName), &(res1->ResName), dir2,
&(lang1->lang) );
if (WResIsEmptyWindow( wind2 ) && !CmdLineParms.Quiet) {
resname1 = WResIDToStr( &(res1->ResName) );
printf( "Error: Resource %s (lang 0x%X SubLang 0x%X) not in file %s\n",
resname1, (int)lang1->lang.lang,
(int)lang1->lang.sublang,
CmdLineParms.FileName2 );
RESFREE( resname1 );
}
return( wind2 );
}
static void FreePEFileInfoPtrs( PEExeInfo * info )
/************************************************/
{
if( info->Objects != NULL ) {
RESFREE( info->Objects );
}
}
static void FreeNEFileInfoPtrs( NEExeInfo * info )
/*************************************************/
{
if( info->Seg.Segments != NULL ) {
RESFREE( info->Seg.Segments );
info->Seg.Segments = NULL;
}
if( info->Res.Str.StringBlock != NULL ) {
RESFREE( info->Res.Str.StringBlock );
info->Res.Str.StringBlock = NULL;
}
if( info->Res.Str.StringList != NULL ) {
RESFREE( info->Res.Str.StringList );
info->Res.Str.StringList = NULL;
}
} /* FreeNEFileInfoPtrs */
static RcStatus copyFont( FontInfo *info, FILE *fp, WResID *name,
ResMemFlags flags, int *err_code )
/*********************************************************************/
{
RcStatus ret;
char * buffer;
ResLocation loc;
long pos;
buffer = RESALLOC( FONT_BUFFER_SIZE );
loc.start = SemStartResource();
if( ResWriteFontInfo( info, CurrResFile.fp ) ) {
ret = RS_WRITE_ERROR;
*err_code = LastWresErr();
} else {
pos = RESTELL( fp );
if( pos == -1L ) {
ret = RS_READ_ERROR;
*err_code = errno;
} else {
ret = SemCopyDataUntilEOF( pos, fp, buffer, FONT_BUFFER_SIZE, err_code );
}
}
loc.len = SemEndResource( loc.start );
/* add the font to the RES file directory */
SemAddResourceFree( name, WResIDFromNum( RESOURCE2INT( RT_FONT ) ), flags, loc );
RESFREE( buffer );
return( ret );
} /* copyFont */
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 fid,
WResID *name, ResMemFlags flags, int *err_code )
/**************************************************************************/
{
RcStatus ret;
char * buffer;
ResLocation loc;
WResFileOffset pos;
buffer = RESALLOC( BITMAP_BUFFER_SIZE );
loc.start = SemStartResource();
pos = RESTELL( fid );
if( pos == -1 ) {
ret = RS_READ_ERROR;
*err_code = errno;
} else {
ret = CopyData( pos, head->Size - sizeof(BitmapFileHeader),
fid, buffer, BITMAP_BUFFER_SIZE, err_code );
}
loc.len = SemEndResource( loc.start );
/* add the bitmap to the RES file directory */
SemAddResourceFree( name, WResIDFromNum( RESOURCE2INT( RT_BITMAP ) ), flags, loc );
RESFREE( buffer );
return( ret );
} /* copyBitmap */
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 readCurFileDir( WResFileID fid, FullCurDir *dir, int *err_code )
/******************************************************************************/
/* this funtion returns one of the above enum constants */
{
RcStatus ret;
int currentry;
FullCurDirEntry * entry;
ret = readIcoCurFileDirHeader( &(dir->Header), fid, err_code );
/* type 2 is a cursor file */
if( ret == RS_OK && dir->Header.Type != 2 ) {
return( RS_INVALID_RESOURCE );
}
for( currentry = 0; ret == RS_OK && currentry < dir->Header.ResCount;
currentry++ ) {
entry = RESALLOC( sizeof(FullCurDirEntry) );
entry->Next = NULL;
entry->Prev = NULL;
entry->IsCurFileEntry = true;
ret = readCurFileDirEntry( &(entry->Entry.Cur), fid, err_code );
if( ret != RS_OK ) {
RESFREE( entry );
} else {
ResAddLLItemAtEnd( (void **) &(dir->Head), (void **) &(dir->Tail), entry );
}
}
return( ret );
} /* readCurFileDir */
static bool ChangeTmpToOutFile( FILE *tmpfile, const char *out_name )
/*******************************************************************/
{
RcStatus status; /* error while deleting or renaming */
FILE *outfile;
size_t numread;
char *buffer;
buffer = RESALLOC( BUFFER_SIZE );
status = RS_OK;
RESSEEK( tmpfile, 0, SEEK_SET );
outfile = ResOpenFileRW( out_name );
while( (numread = RESREAD( tmpfile, buffer, BUFFER_SIZE )) != 0 ) {
if( numread != BUFFER_SIZE && RESIOERR( tmpfile, numread ) ) {
status = RS_READ_ERROR;
break;
}
if( RESWRITE( outfile, buffer, numread ) != numread ) {
status = RS_WRITE_ERROR;
break;
}
}
ResCloseFile( outfile );
RESFREE( buffer );
return( status == RS_OK );
} /* ChangeTmpToOutFile */
static void FreeFontDir( FullFontDir * olddir )
/*********************************************/
{
FullFontDirEntry * currentry;
FullFontDirEntry * oldentry;
currentry = olddir->Head;
while( currentry != NULL ) {
oldentry = currentry;
currentry = currentry->Next;
RESFREE( oldentry );
}
RESFREE( olddir );
}
static void FreePhysicalFilename( void )
{
PhysFileInfo *phys;
phys = &(InStack.Current->Physical);
RESFREE( phys->Filename );
phys->Filename = NULL;
}
static void FreeLogicalFilename( void )
{
LogicalFileInfo *log;
log = &(InStack.Current->Logical);
RESFREE( log->Filename );
log->Filename = NULL;
}
static void SemOS2FreeStringTable( FullStringTable *oldtable )
/*****************************************************/
{
FullStringTableBlock *currblock;
FullStringTableBlock *oldblock;
currblock = oldtable->Head;
while( currblock != NULL ) {
ResFreeStringTableBlock( &(currblock->Block) );
oldblock = currblock;
currblock = currblock->Next;
RESFREE( oldblock );
}
RESFREE( oldtable );
} /* SemOS2FreeStringTable */
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 );
}
void SemWINAddMessageTable( WResID *name, ScanString *filename ) {
/****************************************************************/
ResLocation start;
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
start = SemCopyRawFile( filename->string );
RESFREE( filename->string );
RESFREE( filename );
SemAddResourceFree( name, WResIDFromNum( RESOURCE2INT( RT_MESSAGETABLE ) ),
MEMFLAG_MOVEABLE | MEMFLAG_PURE, start );
} else {
RcError( ERR_NT_KEYWORD, SemWINTokenToString( Y_MESSAGETABLE ) );
ErrorHasOccured = true;
RESFREE( name );
RESFREE( filename->string );
RESFREE( filename );
}
}
void SemFreeDataElemList( DataElemList *head )
/********************************************/
{
DataElemList *curnode;
DataElemList *nextnode;
int i;
curnode = head;
nextnode = head;
while( nextnode != NULL ) {
nextnode = curnode->next;
for( i = 0; i < curnode->count; i++ ) {
if( curnode->data[i].IsString ) {
RESFREE( curnode->data[i].Item.String );
}
}
RESFREE( curnode );
curnode = nextnode;
}
}
void SemWINAddResFile( char *filename )
/*************************************/
{
char full_filename[_MAX_PATH];
if( RcFindResource( filename, full_filename ) == -1 ) {
RcError( ERR_CANT_FIND_FILE, filename );
goto HANDLE_ERROR;
}
if( AddDependency( full_filename ) )
goto HANDLE_ERROR;
if( copyResourcesFromRes( full_filename ) )
goto HANDLE_ERROR;
RESFREE( filename );
return;
HANDLE_ERROR:
ErrorHasOccured = true;
RESFREE( filename );
}
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;
bool error;
ResLocation loc;
while( currtable != NULL ) {
for( currblock = currtable->Head; currblock != NULL;
currblock = currblock->Next ) {
loc.start = SemStartResource();
error = ResOS2WriteStringTableBlock( &(currblock->Block),
CurrResFile.fid,
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 );
RESFREE( name );
}
tofree = currtable;
currtable = currtable->next;
SemOS2FreeStringTable( tofree );
}
RESFREE( type );
return;
}
static RcStatus copyCursors( FullCurDir * dir, WResFileID fid, 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 = RESALLOC( 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.fid ) ) {
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), fid, 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( RESOURCE2INT( 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;
}
RESFREE( buffer );
return( ret );
} /* copyCursors */
static void FreeCurDir( FullCurDir * dir )
/****************************************/
{
FullCurDirEntry * currentry;
FullCurDirEntry * oldentry;
currentry = dir->Head;
while( currentry != NULL ) {
oldentry = currentry;
currentry = currentry->Next;
RESFREE( oldentry );
}
} /* FreeCurDir */
extern void RcPass2IoShutdown( bool noerror )
/******************************************/
{
ClosePass2FilesAndFreeMem();
if( Pass2Info.IoBuffer != NULL ) {
RESFREE( Pass2Info.IoBuffer );
Pass2Info.IoBuffer = NULL;
}
if( noerror ) {
ChangeTmpToOutFile( Pass2Info.TmpFile.fp, CmdLineParms.OutExeFileName );
}
ResCloseFile( Pass2Info.TmpFile.fp );
Pass2Info.TmpFile.fp = NULL;
} /* RcPass2IoShutdown */
static bool PreprocessInputFile( void )
/*************************************/
{
unsigned flags;
char rcdefine[13];
char **cppargs;
char *p;
int rc;
flags = PPFLAG_EMIT_LINE | PPFLAG_IGNORE_INCLUDE;
if( CmdLineParms.IgnoreCWD ) {
flags |= PPFLAG_IGNORE_CWD;
}
rc = PP_FileInit2( CmdLineParms.InFileName, flags, NULL, CharSetLen );
if( rc != 0 ) {
RcError( ERR_CANT_OPEN_FILE, CmdLineParms.InFileName, strerror(errno) );
return( true );
}
strcpy( rcdefine, "RC_INVOKED 1" );
PP_Define( rcdefine );
if( !CmdLineParms.NoTargetDefine ) {
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN16 ) {
strcpy( rcdefine, "__WINDOWS__" );
PP_Define( rcdefine );
} else if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
strcpy( rcdefine, "__NT__" );
PP_Define( rcdefine );
} else if( CmdLineParms.TargetOS == RC_TARGET_OS_OS2 ) {
strcpy( rcdefine, "__OS2__" );
PP_Define( rcdefine );
}
}
cppargs = CmdLineParms.CPPArgs;
if( cppargs != NULL ) {
for( ++cppargs; (p = *cppargs) != NULL; ++cppargs ) {
for( ; *p != '\0'; ++p ) {
if( *p == '=' ) {
*p = ' ';
break;
}
}
p = *cppargs;
PP_Define( p + 2 ); // skip over -d
RESFREE( p );
}
}
return( false ); // indicate no error
}
extern bool RcPass2IoInit( void )
/******************************/
{
bool noerror;
bool tmpexe_exists;
memset( &Pass2Info, 0, sizeof( RcPass2Info ) );
Pass2Info.IoBuffer = RESALLOC( IO_BUFFER_SIZE );
noerror = openExeFileInfoRO( CmdLineParms.InExeFileName, &(Pass2Info.OldFile) );
if( noerror ) {
Pass2Info.TmpFile.name = "Temporary file 2 (exe)";
Pass2Info.TmpFile.fp = ResOpenFileTmp( NULL );
if( Pass2Info.TmpFile.fp == NULL ) {
RcError( ERR_OPENING_TMP, Pass2Info.TmpFile.name, strerror( errno ) );
noerror = false;
}
}
tmpexe_exists = noerror;
if( noerror ) {
Pass2Info.TmpFile.Type = Pass2Info.OldFile.Type;
Pass2Info.TmpFile.WinHeadOffset = Pass2Info.OldFile.WinHeadOffset;
if( Pass2Info.OldFile.Type == EXE_TYPE_PE ) {
Pass2Info.TmpFile.u.PEInfo.WinHead = &Pass2Info.TmpFile.u.PEInfo.WinHeadData;
*Pass2Info.TmpFile.u.PEInfo.WinHead = *Pass2Info.OldFile.u.PEInfo.WinHead;
}
if( ( Pass2Info.OldFile.Type == EXE_TYPE_NE_WIN || Pass2Info.OldFile.Type == EXE_TYPE_NE_OS2 )
&& CmdLineParms.ExtraResFiles != NULL ) {
RcError( ERR_FR_NOT_VALID_FOR_WIN );
noerror = false;
} else {
noerror = OpenResFileInfo( Pass2Info.OldFile.Type );
}
}
if( !noerror ) {
RESFREE( Pass2Info.IoBuffer );
Pass2Info.IoBuffer = NULL;
ClosePass2FilesAndFreeMem();
if( tmpexe_exists ) {
ResCloseFile( Pass2Info.TmpFile.fp );
Pass2Info.TmpFile.fp = NULL;
}
}
return( noerror );
} /* RcPass2IoInit */
extern bool RcIoTextInputShutdown( void )
/***************************************/
{
if( InStack.Buffer != NULL ) {
RESFREE( InStack.Buffer );
InStack.Buffer = NULL;
InStack.BufferSize = 0;
if( IsEmptyFileStack( InStack ) ) {
return( false );
} else {
while( !IsEmptyFileStack( InStack ) ) {
RcIoPopTextInputFile();
}
// return( true );
}
}
return( true );
} /* RcIoTextInputShutdown */
