static bool readObjectAndPageTable( ExeFileInfo *exe )
/****************************************************/
{
RcStatus ret;
size_t table_size;
table_size = exe->u.LXInfo.OS2Head.num_objects * sizeof( object_record );
exe->u.LXInfo.Objects = RESALLOC( table_size );
ret = SeekRead( exe->fid,
exe->WinHeadOffset + exe->u.LXInfo.OS2Head.objtab_off,
exe->u.LXInfo.Objects, table_size );
if( ret == RS_OK ) {
table_size = exe->u.LXInfo.OS2Head.num_pages * sizeof( lx_map_entry );
exe->u.LXInfo.Pages = RESALLOC( table_size );
ret = SeekRead( exe->fid,
exe->WinHeadOffset + exe->u.LXInfo.OS2Head.objmap_off,
exe->u.LXInfo.Pages, table_size );
}
switch( ret ) {
case RS_OK:
break;
case RS_READ_ERROR:
RcError( ERR_READING_EXE, exe->name, strerror( errno ) );
break;
case RS_READ_INCMPLT:
RcError( ERR_UNEXPECTED_EOF, exe->name );
break;
default:
RcError( ERR_INTERNAL, INTERR_UNKNOWN_RCSTATUS );
break;
}
CheckDebugOffset( exe );
return( ret != RS_OK );
}
static FullFontDirEntry *NewFontDirEntry( FontInfo *info, char *devicename, char *facename, WResID *fontid )
/**********************************************************************************************************/
{
FullFontDirEntry *entry;
int structextra;
int devicelen;
int facelen;
devicelen = strlen( devicename ) + 1;
facelen = strlen( facename ) + 1;
structextra = devicelen + facelen;
/* -1 for the 1 char in the struct already */
entry = RESALLOC( sizeof( FullFontDirEntry ) + structextra - 1 );
entry->Next = NULL;
entry->Prev = NULL;
/* -1 for the 1 char in the struct already */
entry->Entry.StructSize = sizeof( FontDirEntry ) + structextra - 1;
entry->Entry.FontID = fontid->ID.Num;
entry->Entry.Info = *info;
memcpy( &(entry->Entry.DevAndFaceName[0]), devicename, devicelen );
memcpy( &(entry->Entry.DevAndFaceName[devicelen]), facename, facelen );
/* set dfDevice and dfFace to be the offset of the strings from the start */
/* of the FontInfo structure (entry->Entry.Info) */
entry->Entry.Info.dfDevice = sizeof( FontInfo );
entry->Entry.Info.dfFace = sizeof( FontInfo ) + devicelen;
return( entry );
}
static RcStatus readObjectTable( ExeFileInfo *exe )
/*************************************************/
{
RcStatus ret;
unsigned objects_size;
long file_offset;
exe_pe_header *pehdr;
pehdr = exe->u.PEInfo.WinHead;
if( IS_PE64( *pehdr ) ) {
objects_size = PE64( *pehdr ).num_objects * sizeof( pe_object );
file_offset = exe->WinHeadOffset + sizeof( pe_header64 );
} else {
objects_size = PE32( *pehdr ).num_objects * sizeof( pe_object );
file_offset = exe->WinHeadOffset + sizeof( pe_header );
}
exe->u.PEInfo.Objects = RESALLOC( objects_size );
ret = SeekRead( exe->fid, file_offset, exe->u.PEInfo.Objects, objects_size );
switch( ret ) {
case RS_OK:
break;
case RS_READ_ERROR:
RcError( ERR_READING_EXE, exe->name, strerror( errno ) );
break;
case RS_READ_INCMPLT:
RcError( ERR_UNEXPECTED_EOF, exe->name );
break;
default:
RcError( ERR_INTERNAL, INTERR_UNKNOWN_RCSTATUS );
break;
}
CheckDebugOffset( exe );
return( ret );
}
extern void RcIoTextInputInit( void )
/***********************************/
{
InStack.Buffer = RESALLOC( IO_BUFFER_SIZE );
InStack.BufferSize = IO_BUFFER_SIZE;
InStack.Current = InStack.Stack;
} /* RcIoTextInputInit */
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 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 */
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 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 */
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 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 bool OpenNewPhysicalFile( PhysFileInfo *phys, const char *filename )
/*************************************************************************/
{
phys->Filename = RESALLOC( strlen( filename ) + 1 );
strcpy( phys->Filename, filename );
phys->IsOpen = false;
phys->Offset = 0;
return( OpenPhysicalFile( phys ) );
} /* OpenNewPhysicalFile */
static bool OpenResFileInfo( ExeType type )
/*****************************************/
{
bool error;
ExtraRes *curfile;
char *name;
if( ( type == EXE_TYPE_NE_WIN || type == EXE_TYPE_NE_OS2 )
&& CmdLineParms.ExtraResFiles != NULL ) {
RcError( ERR_FR_NOT_VALID_FOR_WIN );
return( false );
}
Pass2Info.AllResFilesOpen = true;
if( CmdLineParms.NoResFile ) {
Pass2Info.ResFile = RESALLOC( sizeof( ResFileInfo ) );
Pass2Info.ResFile->next = NULL;
Pass2Info.ResFile->name = NULL;
Pass2Info.ResFile->IsOpen = false;
Pass2Info.ResFile->fp = NULL;
Pass2Info.ResFile->Dir = NULL;
return( true );
}
if( CmdLineParms.Pass2Only ) {
name = CmdLineParms.InFileName;
} else {
name = CmdLineParms.OutResFileName;
}
curfile = RESALLOC( sizeof( ExtraRes ) + strlen( name ) );
curfile->next = CmdLineParms.ExtraResFiles;
CmdLineParms.ExtraResFiles = curfile;
strcpy( curfile->name, name );
error = OpenResFiles( CmdLineParms.ExtraResFiles, &Pass2Info.ResFile,
&Pass2Info.AllResFilesOpen, type,
CmdLineParms.InExeFileName );
return( error );
} /* OpenResFileInfo */
static FullFontDir * NewFontDir( void )
/*************************************/
{
FullFontDir *newdir;
newdir = RESALLOC( sizeof( FullFontDir ) );
newdir->Head = NULL;
newdir->Tail = NULL;
newdir->NumOfFonts = 0;
return( newdir );
}
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 */
extern void RcIoSetLogicalFileInfo( int linenum, const char * filename )
/**********************************************************************/
{
LogicalFileInfo * log;
if( !IsEmptyFileStack( InStack ) ) {
log = &(InStack.Current->Logical);
log->LineNum = linenum;
if( filename != NULL ) {
if( log->Filename == NULL ) {
log->Filename = RESALLOC( strlen( filename ) + 1 );
strcpy( log->Filename, filename );
} else if( strcmp( log->Filename, filename ) != 0 ) {
RESFREE( log->Filename );
log->Filename = RESALLOC( strlen( filename ) + 1 );
strcpy( log->Filename, filename );
}
RcIoSetIsCOrHFlag();
}
}
} /* RcIoSetLogicalFileInfo */
DataElemList *SemNewDataElemList( RawDataItem node )
/**************************************************/
{
DataElemList *head;
head = RESALLOC( sizeof( DataElemList ) );
head->data[0] = node;
head->count = 1;
head->next = NULL;
return( head );
}
FullAccelTableOS2 *SemOS2NewAccelTable( FullAccelEntryOS2 firstentry )
/***************************************************************/
{
FullAccelTableOS2 *newtable;
FullAccelEntryOS2 *newentry;
newtable = RESALLOC( sizeof( FullAccelTableOS2 ) );
newentry = RESALLOC( sizeof( FullAccelEntryOS2 ) );
if( newtable == NULL || newentry == NULL ) {
RcError( ERR_OUT_OF_MEMORY );
ErrorHasOccured = true;
return( NULL );
}
*newentry = firstentry;
newtable->head = NULL;
newtable->tail = NULL;
ResAddLLItemAtEnd( (void **)&(newtable->head), (void **)&(newtable->tail), newentry );
return( newtable );
}
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 */
FullStringTable *SemOS2NewStringTable( void )
/*******************************************/
{
FullStringTable *newtable;
newtable = RESALLOC( sizeof( FullStringTable ) );
if( newtable != NULL ) {
newtable->Head = NULL;
newtable->Tail = NULL;
newtable->next = NULL;
newtable->lang.lang = DEF_LANG;
newtable->lang.sublang = DEF_SUBLANG;
}
return( newtable );
} /* SemOS2NewStringTable */
static FullStringTableBlock *newStringTableBlock( void )
/******************************************************/
{
FullStringTableBlock *newblock;
newblock = RESALLOC( sizeof( FullStringTableBlock ) );
if( newblock != NULL ) {
newblock->Next = NULL;
newblock->Prev = NULL;
newblock->BlockNum = 0;
newblock->UseUnicode = (CmdLineParms.TargetOS == RC_TARGET_OS_WIN32);
newblock->Flags = 0;
newblock->codePage = 850;
ResInitStringTableBlock( &(newblock->Block) );
}
return( newblock );
} /* newStringTableBlock */
FullAccelTableOS2 *SemOS2AddAccelEntry( FullAccelEntryOS2 currentry, FullAccelTableOS2 * currtable )
/**************************************************************************************************/
{
FullAccelEntryOS2 *newentry;
newentry = RESALLOC( sizeof( FullAccelEntryOS2 ) );
if( newentry == NULL ) {
RcError( ERR_OUT_OF_MEMORY );
ErrorHasOccured = true;
return( NULL );
}
*newentry = currentry;
ResAddLLItemAtEnd( (void **) &(currtable->head), (void **) &(currtable->tail), newentry );
return( currtable );
}
static RcStatus copyIcons( FullIconDir * dir, WResFileID fid, ResMemFlags flags, int *err_code )
/**********************************************************************************************/
{
RcStatus ret;
char * buffer;
FullIconDirEntry * entry;
BitmapInfoHeader dibhead;
ResLocation loc;
ret = RS_OK;
buffer = RESALLOC( 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), fid, 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( RESOURCE2INT( 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;
}
RESFREE( buffer );
return( ret );
} /* copyIcons */
void *PP_Malloc( size_t size )
/****************************/
{
return( RESALLOC( size ) );
}
void SemOS2AddSingleLineResource( WResID *name, YYTOKENTYPE type,
FullOptFlagsOS2 *fullflags, char *filename )
/*****************************************************************/
{
ResLocation start;
ResMemFlags flags, flagsMDP, flagsMP;
char full_filename[_MAX_PATH];
static bool firstIcon = true;
if( ErrorHasOccured ) {
RESFREE( name );
RESFREE( filename );
return;
}
if( RcFindSourceFile( filename, full_filename ) == -1 ) {
RcError( ERR_CANT_FIND_FILE, filename );
goto HANDLE_ERROR;
}
if( AddDependency( full_filename ) )
goto HANDLE_ERROR;
flagsMDP = MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE | MEMFLAG_PURE;
flagsMP = MEMFLAG_MOVEABLE | MEMFLAG_PURE;
switch( type ) {
case Y_DEFAULTICON:
/* DEFAULTICON doesn't have a name, let's make our own */
name = RESALLOC( sizeof( WResID ) );
name->IsName = false;
name->ID.Num = 999;
firstIcon = true; /* Trigger a warning if we have one already */
/* Note the fallthrough! */
case Y_POINTER:
case Y_ICON:
if( fullflags != NULL ) {
SemOS2CheckResFlags( fullflags, 0, MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE, 0 );
flags = fullflags->flags;
} else {
flags = flagsMDP;
}
/* Duplicate the first icon encountered as the default icon IFF it
has resource ID equal to 1
*/
if( firstIcon && !name->IsName && (name->ID.Num == 999 || name->ID.Num == 1) ) {
WResID *id;
id = RESALLOC( sizeof( WResID ) );
if( id == NULL )
break;
firstIcon = false;
id->IsName = false;
id->ID.Num = 22;
start = SemCopyRawFileOnly( full_filename );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_POINTER ), flags, start );
start = SemCopyRawFileOnly( full_filename );
SemAddResourceFree( id, WResIDFromNum( OS2_RT_DEFAULTICON ), flagsMDP, start );
} else {
start = SemCopyRawFileOnly( full_filename );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_POINTER ), flags, start );
}
break;
case Y_BITMAP:
if( fullflags != NULL ) {
SemOS2CheckResFlags( fullflags, 0, MEMFLAG_MOVEABLE, MEMFLAG_PURE );
flags = fullflags->flags;
} else {
flags = flagsMP;
}
start = SemCopyRawFileOnly( full_filename );
SemAddResourceFree( name, WResIDFromNum( OS2_RT_BITMAP ), flags, start );
break;
case Y_FONT:
if( fullflags != NULL ) {
SemOS2CheckResFlags( fullflags, 0, MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE, MEMFLAG_PURE );
flags = fullflags->flags;
} else {
flags = flagsMDP;
}
AddFontResources( name, flags, full_filename );
break;
default:
RESFREE( name );
break;
}
RESFREE( filename );
return;
HANDLE_ERROR:
ErrorHasOccured = true;
RESFREE( name );
RESFREE( filename );
} /* SemOS2AddSingleLineResource */
