/* * RcIoOpenInput * NB when an error occurs this function MUST return without altering errno */ FILE *RcIoOpenInput( const char *filename, bool text_mode ) /*********************************************************/ { FILE *fp; FileStackEntry *currfile; bool no_handles_available; if( text_mode ) { fp = fopen( filename, "rt" ); } else { fp = ResOpenFileRO( filename ); } no_handles_available = ( fp == NULL && errno == EMFILE ); if( no_handles_available ) { /* set currfile to be the first (not before first) entry */ /* close open files except the current input file until able to open */ /* don't close the current file because Offset isn't set */ for( currfile = InStack.Stack + 1; currfile < InStack.Current && no_handles_available; ++currfile ) { if( currfile->Physical.IsOpen ) { ClosePhysicalFile( &(currfile->Physical) ); if( text_mode ) { fp = fopen( filename, "rt" ); } else { fp = ResOpenFileRO( filename ); } no_handles_available = ( fp == NULL && errno == EMFILE ); } } } return( fp ); } /* RcIoOpenInput */
WRFileType WR_EXPORT WRIdentifyFile( const char *file ) { WRFileType ftype; char ext[_MAX_EXT]; int fh; int ok; fh = -1; ok = (file != NULL); if( ok ) { _splitpath( file, NULL, NULL, NULL, ext ); if( !stricmp( ext, ".bmp" ) ) { ftype = WRIdentifyWinBMPFile( file ); } else if( !stricmp( ext, ".cur" ) ) { ftype = WRIdentifyWinICOFile( file ); } else if( !stricmp( ext, ".ico" ) ) { ftype = WRIdentifyWinICOFile( file ); } else if( !stricmp( ext, ".dlg" ) ) { //ftype = WRIdentifyWinRCFile( file ); ftype = WR_WIN_RC_DLG; } else if( !stricmp( ext, ".rc" ) ) { ftype = WRIdentifyWinRCFile( file ); } else if( !stricmp( ext, ".str" ) ) { ftype = WR_WIN_RC_STR; } else if( !stricmp( ext, ".mnu" ) ) { ftype = WR_WIN_RC_MENU; } else if( !stricmp( ext, ".acc" ) ) { ftype = WR_WIN_RC_ACCEL; } else if( !stricmp( ext, ".res" ) ) { ftype = WRIdentifyRESFile( file ); } else if( !stricmp( ext, ".exe" ) ) { ok = ((fh = ResOpenFileRO( file )) != -1); if( ok ) { ftype = WRIdentifyEXEFile( fh, FALSE ); } } else if( !stricmp( ext, ".dll" ) ) { ok = ((fh = ResOpenFileRO( file )) != -1); if ( ok ) { ftype = WRIdentifyEXEFile( fh, TRUE ); } } else { ok = FALSE; } } if( fh != -1 ) { ResCloseFile( fh ); } if( ok ) { return( ftype ); } else { return( WR_INVALID_FILE ); } }
static bool loadResDirFromRES( WRInfo *info, const char *filename, bool *is_wres ) { WResFileID fid; bool dup_discarded; bool ok; ok = ((fid = ResOpenFileRO( filename )) != WRES_NIL_HANDLE); if( ok ) { *is_wres = WResIsWResFile( fid ); } if( ok ) { ok = ((info->dir = WResInitDir()) != NULL); } if( ok ) { ok = !WResReadDir( fid, info->dir, &dup_discarded ); if( ok && dup_discarded ) { WRDisplayErrorMsg( WR_DUPRESDISCARD ); } } if( fid != WRES_NIL_HANDLE ) { ResCloseFile( fid ); } return( ok ); }
int WRLoadBitmapFile( WRInfo *info ) { int ok; int file_handle; long int file_length; char fn[_MAX_FNAME]; WResID *type; WResID *name; WResLangType def_lang; file_handle = -1; def_lang.sublang = DEF_LANG; def_lang.lang = DEF_SUBLANG; ok = ( info != NULL ); if( ok ) { ok = ( ( file_handle = ResOpenFileRO( info->file_name ) ) != -1 ); } if( ok ) { file_length = filelength( file_handle ); ok = ( ( file_length != 0 ) && ( file_length != -1 ) ); } if( ok ) { type = WResIDFromNum( (long)RT_BITMAP ); ok = ( type != NULL ); } if( ok ) { _splitpath( info->file_name, NULL, NULL, fn, NULL ); name = WResIDFromStr( fn ); ok = ( name != NULL ); } if( ok ) { ok = ( ( info->dir = WResInitDir() ) != NULL ); } if( ok ) { ok = !WResAddResource( type, name, 0, sizeof(BITMAPFILEHEADER), file_length - sizeof(BITMAPFILEHEADER), info->dir, &def_lang, NULL ); } if( file_handle != -1 ) { ResCloseFile( file_handle ); } if( name ) { WRMemFree( name ); } if( type ) { WRMemFree( type ); } return( ok ); }
int ConvertFiles( void ) /**********************/ { WResFileID infile; int error; int fileerror; /* error while deleting or renaming */ infile = ResOpenFileRO( CmdLineParms.InFileName ); if (infile == -1) { perror( "Error (input file): " ); return( TRUE ); } if (WResIsWResFile( infile )) { /* the input file is in Open Watcom format so convert to MS format */ error = ConvertFileWResToMRes( infile ); } else { /* the input file is in MS format so convert to Open Watcom format */ error = ConvertFileMResToWRes( infile ); } ResCloseFile( infile ); if (error) { puts("Error writing to output file"); fileerror = remove( TMP_FILENAME ); if (fileerror) { perror( NULL ); } } else { error = ChangeTmpToOutFile(); } return( error ); } /* ConvertFiles */
DepInfo *WResGetAutoDep( const char *fname ) { WResFileID handle; WResDir dir; bool dup_discarded; WResID *name; WResID *type; WResDirWindow window; WResLangInfo *info; DepInfo *ret; WResFileSSize numread; ret = NULL; handle = ResOpenFileRO( fname ); if( handle != WRES_NIL_HANDLE ) { if( WResIsWResFile( handle ) && (dir = WResInitDir()) != NULL ) { if( !WResReadDir( handle, dir, &dup_discarded ) ) { name = WResIDFromStr( DEP_LIST_NAME ); type = WResIDFromNum( DEP_LIST_TYPE ); if( name != NULL && type != NULL ) { window = WResFindResource( type, name, dir, NULL ); if( WResIsEmptyWindow( window ) ) { WRES_ERROR( WRS_RES_NOT_FOUND ); } else { info = WResGetLangInfo( window ); if( WRESSEEK( handle, info->Offset, SEEK_SET ) == -1 ) { WRES_ERROR( WRS_SEEK_FAILED ); } else { ret = WRESALLOC( info->Length ); if( ret == NULL ) { WRES_ERROR( WRS_MALLOC_FAILED ); } else { numread = WRESREAD( handle, ret, info->Length ); if( numread != (WResFileSSize)info->Length ) { WRES_ERROR( WRESIOERR( handle, numread ) ? WRS_READ_FAILED : WRS_READ_INCOMPLETE ); ret = NULL; } } } } } if( name != NULL ) { WResIDFree( name ); } if( type != NULL ) { WResIDFree( type ); } } WResFreeDir( dir ); } ResCloseFile( handle ); } return( ret ); }
static int OpenFiles( WResFileID * fileid1, WResFileID * fileid2 ) /****************************************************************/ /* opens the files named in CmdLineParms and puts their file ids in */ /* fileid1 and fileid2 */ { int error; *fileid1 = ResOpenFileRO( CmdLineParms.FileName1 ); if (*fileid1 == -1) { printf( "Unable to open %s\n", CmdLineParms.FileName1 ); *fileid2 = -1; return( true ); } *fileid2 = ResOpenFileRO( CmdLineParms.FileName2 ); if (*fileid2 == -1) { printf( "Unable to open %s\n", CmdLineParms.FileName2 ); ResCloseFile( *fileid1 ); *fileid1 = -1; return( true ); } error = (!WResIsWResFile( *fileid1 )); if (error) { printf( "File %s is not a Open Watcom .RES file\n", CmdLineParms.FileName1 ); } else { error = (!WResIsWResFile( *fileid2 )); if (error) { printf( "File %s is not a Open Watcom .RES file\n", CmdLineParms.FileName2 ); } } return( error ); }
int WRLoadResourceFromWin16EXE( WRInfo *info ) { WResFileID file_handle; int ok; ok = ((file_handle = ResOpenFileRO( info->file_name )) != -1); if( ok ) { ok = WRLoadWResDirFromWin16EXE( file_handle, &info->dir ); } if( file_handle != -1 ) { ResCloseFile( file_handle ); } return( ok ); }
extern int DumpFile( void ) /*************************/ { int error; int retcode; WResFileID handle; WResDir dir; handle = ResOpenFileRO( CmdLineParms.FileName ); if (handle == -1) { return( 2 ); } if (WResIsWResFile( handle )) { puts( "WATCOM format .RES file" ); } else { puts( "MS format .RES file" ); } dir = WResInitDir(); if (dir == NULL) { FatalError( "Out of memory" ); } error = WResReadDir( handle, dir, NULL ); if (error) { puts( "Unable to read directory" ); retcode = 2; } else { if( WResGetTargetOS( dir ) == WRES_OS_WIN16 ) { puts( "Target OS: Win16" ); } else { puts( "Target OS: Win32" ); } puts( "Type Name Language Flags" ); puts( "==== ==== ======== =====" ); retcode = DumpDir( dir, handle ); } WResFreeDir( dir ); ResCloseFile( handle ); return( retcode ); }
void * WRAPI WRLoadResData( char *file, uint_32 offset, uint_32 length ) { void *data; WResFileID handle; int ok; data = NULL; handle = -1; ok = (file != NULL && length != 0); if( ok ) { ok = ((data = WRMemAlloc( length )) != NULL); } if( ok ) { ok = ((handle = ResOpenFileRO( file )) != -1); } if( ok ) { ok = ((ResSeek( handle, offset, SEEK_SET )) != -1); } if( ok ) { ok = WRReadResData( handle, (BYTE *)data, length ); } if( handle != -1 ) { ResCloseFile( handle ); } if( !ok ) { if( data != NULL ) { WRMemFree( data ); data = NULL; } } return( data ); }
static bool openExeFileInfoRO( const char *filename, ExeFileInfo *info ) /**********************************************************************/ { RcStatus status; exe_pe_header *pehdr; info->fp = ResOpenFileRO( filename ); if( info->fp == NULL ) { RcError( ERR_CANT_OPEN_FILE, filename, strerror( errno ) ); return( false ); } info->IsOpen = true; info->Type = FindNEPELXHeader( info->fp, &info->WinHeadOffset ); info->name = filename; switch( info->Type ) { case EXE_TYPE_NE_WIN: case EXE_TYPE_NE_OS2: status = SeekRead( info->fp, info->WinHeadOffset, &info->u.NEInfo.WinHead, sizeof( os2_exe_header ) ); if( status != RS_OK ) { RcError( ERR_NOT_VALID_EXE, filename ); return( false ); } else { info->DebugOffset = info->WinHeadOffset + sizeof( os2_exe_header ); } break; case EXE_TYPE_PE: pehdr = &info->u.PEInfo.WinHeadData; info->u.PEInfo.WinHead = pehdr; status = SeekRead( info->fp, info->WinHeadOffset, &PE32( *pehdr ), sizeof( pe_header ) ); if( status != RS_OK ) { RcError( ERR_NOT_VALID_EXE, filename ); return( false ); } if( IS_PE64( *pehdr ) ) { status = SeekRead( info->fp, info->WinHeadOffset, &PE64( *pehdr ), sizeof( pe_header64 ) ); if( status != RS_OK ) { RcError( ERR_NOT_VALID_EXE, filename ); return( false ); } info->DebugOffset = info->WinHeadOffset + sizeof( pe_header64 ); } else { info->DebugOffset = info->WinHeadOffset + sizeof( pe_header ); } break; case EXE_TYPE_LX: status = SeekRead( info->fp, info->WinHeadOffset, &info->u.LXInfo.OS2Head, sizeof( os2_flat_header ) ); if( status != RS_OK ) { RcError( ERR_NOT_VALID_EXE, filename ); return( false ); } else { info->DebugOffset = info->WinHeadOffset + sizeof( os2_flat_header ); } break; default: RcError( ERR_NOT_VALID_EXE, filename ); return( false ); break; } return( !RESSEEK( info->fp, 0, SEEK_SET ) ); } /* openExeFileInfoRO */
int WRLoadCursorFile( WRInfo *info ) { BYTE *data; uint_32 data_size; CURSORHEADER *ch; uint_32 chsize; RESCURSORHEADER *rch; uint_32 rchsize; WResFileID file; WResID *tname; WResID *rname; WResLangType lang; char fn[_MAX_FNAME]; int dup; int i; int ok; data = NULL; rch = NULL; dup = FALSE; file = -1; lang.lang = DEF_LANG; lang.sublang = DEF_SUBLANG; tname = NULL; rname = NULL; ok = ( info && info->file_name ); if( ok ) { ok = ( ( file = ResOpenFileRO( info->file_name ) ) != -1 ); } if( ok ) { ok = WRReadEntireFile( file, &data, &data_size ); } if( ok ) { ch = (CURSORHEADER *) data; chsize = sizeof(CURSORHEADER); chsize += sizeof(CURSORDIRENTRY)*(ch->cdCount-1); ok = WRCreateCursorResHeader( &rch, &rchsize, data, data_size ); } if( ok ) { ok = ( ( info->dir = WResInitDir() ) != NULL ); } if( ok ) { tname = WResIDFromNum( (uint_16)RT_GROUP_CURSOR ); ok = ( tname != NULL ); } if( ok ) { _splitpath( info->file_name, NULL, NULL, fn, NULL ); rname = WResIDFromStr( fn ); ok = ( rname != NULL ); } if ( ok ) { ok = !WResAddResource( tname, rname, DEF_MEMFLAGS, 0, rchsize, info->dir, &lang, &dup ); } if( ok ) { ok = WRFindAndSetData( info->dir, tname, rname, &lang, rch ); } if( ok ) { for( i=0; ok && i<ch->cdCount ; i++ ) { ok = WRGetAndAddCursorImage( data, info->dir, &ch->cdEntries[i], i+1 ); } } if( !ok ) { if( info->dir ) { WRFreeWResDirData( info->dir ); WResFreeDir( info->dir ); info->dir = NULL; } } if( tname != NULL ) { WRMemFree( tname ); } if( rname != NULL ) { WRMemFree( rname ); } if( file != -1 ) { ResCloseFile( file ); } return( ok ); }
WdeDialogBoxInfo *WdeLoadDialogFromRes( WdeResInfo *res_info, WResLangNode *lnode, bool is32bit ) { DialogExHeader32 h32ex; DialogBoxHeader32 h32; DialogBoxHeader h16; DialogBoxControl c16; DialogBoxControl32 c32; DialogBoxExControl32 c32ex; WdeDialogBoxInfo *dlg_info; WResFileID fid; WdeDialogBoxControl *control; LIST *prev_control; #if 0 WdeDialogBoxControl *nc; LIST *clist; #endif int index; char *file_name; bool ok; dlg_info = NULL; fid = WRES_NIL_HANDLE; ok = (res_info != NULL && lnode != NULL); if( ok ) { file_name = res_info->info->tmp_file; dlg_info = (WdeDialogBoxInfo *)WRMemAlloc( sizeof( WdeDialogBoxInfo ) ); ok = (dlg_info != NULL); } if( ok ) { dlg_info->dialog_header = WdeAllocDialogBoxHeader(); ok = (dlg_info->dialog_header != NULL); } if( ok ) { dlg_info->dialog_header->is32bit = is32bit; dlg_info->control_list = NULL; dlg_info->MemoryFlags = 0; ok = ((fid = ResOpenFileRO( file_name )) != WRES_NIL_HANDLE); } if( ok ) { dlg_info->MemoryFlags = lnode->Info.MemoryFlags; ok = (ResSeek( fid, lnode->Info.Offset, SEEK_SET ) != -1); } if( ok ) { if( is32bit ) { /* JPK - check if its an extended dialog */ dlg_info->dialog_header->is32bitEx = ResIsDialogEx( fid ); ResSeek( fid, lnode->Info.Offset, SEEK_SET ); if( dlg_info->dialog_header->is32bitEx ) { ok = !ResReadDialogExHeader32( &h32, &h32ex, fid ); } else { ok = !ResReadDialogBoxHeader32( &h32, fid ); } } else { ok = !ResReadDialogBoxHeader( &h16, fid ); } } if( ok ) { if( is32bit ) { if( dlg_info->dialog_header->is32bitEx ) { dlg_info->dialog_header->FontWeight = h32ex.FontWeight; dlg_info->dialog_header->FontItalic = h32ex.FontItalic; dlg_info->dialog_header->FontCharset = h32ex.FontCharset; dlg_info->dialog_header->HelpId = h32ex.HelpId; dlg_info->dialog_header->FontWeightDefined = (h32ex.FontWeightDefined != 0); dlg_info->dialog_header->FontItalicDefined = (h32ex.FontItalicDefined != 0); dlg_info->dialog_header->FontCharsetDefined = (h32ex.FontCharsetDefined != 0); } dlg_info->dialog_header->Style = h32.Style; dlg_info->dialog_header->ExtendedStyle = h32.ExtendedStyle; dlg_info->dialog_header->NumOfItems = h32.NumOfItems; dlg_info->dialog_header->Size = h32.Size; dlg_info->dialog_header->MenuName = h32.MenuName; dlg_info->dialog_header->ClassName = h32.ClassName; dlg_info->dialog_header->Caption = h32.Caption; dlg_info->dialog_header->PointSize = h32.PointSize; dlg_info->dialog_header->FontName = h32.FontName; } else { dlg_info->dialog_header->Style = h16.Style; dlg_info->dialog_header->NumOfItems = h16.NumOfItems; dlg_info->dialog_header->Size = h16.Size; dlg_info->dialog_header->MenuName = h16.MenuName; dlg_info->dialog_header->ClassName = h16.ClassName; dlg_info->dialog_header->Caption = h16.Caption; dlg_info->dialog_header->PointSize = h16.PointSize; dlg_info->dialog_header->FontName = h16.FontName; } prev_control = NULL; for( index = 0; index < GETHDR_NUMITEMS( dlg_info->dialog_header ); index++ ) { control = WdeAllocDialogBoxControl(); if( control == NULL ) { ok = false; break; } if( is32bit ) { /* * JPK - check which control structure to expect based on * whether this an extended dialog or not */ if( dlg_info->dialog_header->is32bitEx ) { if( ResReadDialogExControl32( &c32ex, fid ) ) { ok = false; break; } control->HelpId = c32ex.HelpId; control->ExtendedStyle = c32ex.ExtendedStyle; control->Style = c32ex.Style; control->Size = c32ex.Size; control->ID = c32ex.ID; control->ClassID = c32ex.ClassID; control->Text = c32ex.Text; control->ExtraBytes = c32ex.ExtraBytes; } else { if( ResReadDialogBoxControl32( &c32, fid ) ) { ok = false; break; } control->Style = c32.Style; control->ExtendedStyle = c32.ExtendedStyle; control->Size = c32.Size; control->ID = c32.ID; control->ClassID = c32.ClassID; control->Text = c32.Text; control->ExtraBytes = c32.ExtraBytes; } } else { if( ResReadDialogBoxControl( &c16, fid ) ) { ok = false; break; } control->Size = c16.Size; control->ID = c16.ID; control->Style = c16.Style; control->ClassID = c16.ClassID; control->Text = c16.Text; control->ExtraBytes = c16.ExtraBytes; } if ( prev_control == NULL ) { ListAddElt( &dlg_info->control_list, (void *)control ); prev_control = dlg_info->control_list; } else { ListInsertElt( prev_control, (void *)control ); prev_control = ListNext( prev_control ); } } } #if 0 /* * JPK - if the dialog is 32 bit but not EX, then convert the dialog * header and the control list to EX; this will force all * dialogs to EX, for now */ if( is32bit && !dlg_info->dialog_header->is32bitEx ) { /* deal with the dialog header first */ dlg_info->dialog_header->is32bitEx = TRUE; dlg_info->dialog_header->FontWeight = 0; dlg_info->dialog_header->FontItalic = 0; dlg_info->dialog_header->FontCharset = DEFAULT_CHARSET; dlg_info->dialog_header->HelpId = 0; dlg_info->dialog_header->FontWeightDefined = FALSE; dlg_info->dialog_header->FontItalicDefined = FALSE; dlg_info->dialog_header->FontCharsetDefined = FALSE; /* now deal with the list of controls */ nc = (WdeDialogBoxControl *)WRMemAlloc( sizeof( WdeDialogBoxControl ) ); for( clist = dlg_info->control_list; clist != NULL; clist = ListNext( clist ) ) { control = (WdeDialogBoxControl *)ListElement( clist ); memcpy( nc, control, sizeof( WdeDialogBoxControl ) ); nc->HelpId = 0; nc->ExtendedStyle = control->ExtendedStyle; nc->Style = control->Style; memcpy( &nc->Size, &control->Size, sizeof( DialogSizeInfo ) ); nc->ID = control->ID; nc->ClassID = control->ClassID; nc->Text = control->Text; nc->ExtraBytes = control->ExtraBytes; memcpy( control, nc, sizeof( WdeDialogBoxControl ) ); } WRMemFree( nc ); } #endif if( !ok ) { if( dlg_info != NULL ) { WdeFreeDialogBoxInfo( dlg_info ); dlg_info = NULL; } } if( fid != WRES_NIL_HANDLE ) { ResCloseFile( fid ); } return( dlg_info ); }
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; } } }
static bool saveResourceToRES( WRInfo *info, bool backup, const char *save_name, const char *file_name ) { WResFileID src_fid; WResFileID dst_fid; bool is_wres; bool ok; bool use_rename; WRFileType save_type; src_fid = WRES_NIL_HANDLE; dst_fid = WRES_NIL_HANDLE; ok = true; if( ok ) { save_type = info->save_type; if( save_type != WR_WIN16M_RES && save_type != WR_WIN16W_RES && save_type != WR_WINNTM_RES && save_type != WR_WINNTW_RES ) { if( info->internal_type != WR_DONT_KNOW ) { save_type = info->internal_type; } } #ifndef __NT__ ok = !WRIs32Bit( save_type ); if( !ok ) { WRDisplayErrorMsg( WR_NOSAVE32IN16 ); } #endif } if( ok ) { if( backup && WRFileExists( save_name ) ) { use_rename = (file_name != NULL && stricmp( file_name, save_name )); ok = WRBackupFile( save_name, use_rename ); } } if( ok ) { if( file_name != NULL ) { ok = ((src_fid = ResOpenFileRO( info->tmp_file )) != WRES_NIL_HANDLE); } } is_wres = (save_type == WR_WIN16W_RES || save_type == WR_WINNTW_RES); if( ok ) { ok = ((dst_fid = ResOpenNewFile( save_name )) != WRES_NIL_HANDLE); if( ok && is_wres ) { ok = !WResFileInit( dst_fid ); } } if( ok ) { if( is_wres ) { ok = WRSaveResourceToWRES( info, src_fid, dst_fid ); } else { ok = WRSaveResourceToMRES( info, src_fid, dst_fid ); } } if( src_fid != WRES_NIL_HANDLE ) { ResCloseFile( src_fid ); } if( dst_fid != WRES_NIL_HANDLE ) { ResCloseFile( dst_fid ); } if( !ok ) { if( dst_fid != WRES_NIL_HANDLE ) { WRDeleteFile( save_name ); } } return( ok ); }
static int WRSaveImageToFile( WRInfo *info, WResTypeNode *tnode, int backup ) { WResFileID src; WResFileID dest; int ok; int use_rename; WResLangNode *lnode; src = -1; dest = -1; lnode = NULL; ok = ( info && tnode ); if( ok ) { if( backup && WRFileExists ( info->save_name ) ) { use_rename = ( info->file_name && stricmp( info->file_name, info->save_name ) ); ok = WRBackupFile( info->save_name, use_rename ); } } if( ok ) { if( info->file_name ) { ok = ( ( src = ResOpenFileRO( info->tmp_file ) ) != -1 ); } } if( ok ) { dest = open( info->save_name, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, S_IWRITE | S_IREAD ); ok = ( dest != -1 ); } if( ok ) { if( tnode->Head && tnode->Head->Head ) { lnode = tnode->Head->Head; } ok = ( lnode != NULL ); } if( ok ) { if ( lnode->data ) { ok = WRCopyResFromDataToFile( lnode->data, lnode->Info.Length, dest ); } else { ok = WRCopyResFromFileToFile( src, lnode->Info.Offset, lnode->Info.Length, dest ); } } if ( src != -1 ) { ResCloseFile( src ); } if ( dest != -1 ) { ResCloseFile( dest ); } if ( !ok ) { if ( dest != -1 ) { WRDeleteFile ( info->save_name ); } } return ( ok ); }
int WRLoadIconFile( WRInfo *info ) { BYTE *data; uint_32 data_size; ICONHEADER *pih; uint_32 pihsize; RESICONHEADER *rih; uint_32 rihsize; WResFileID file; WResID *tname; WResID *rname; WResLangType lang; char fn[_MAX_FNAME]; int dup; int i; int ok; data = NULL; rih = NULL; dup = FALSE; file = -1; lang.lang = DEF_LANG; lang.sublang = DEF_SUBLANG; tname = NULL; rname = NULL; ok = (info != NULL && info->file_name != NULL); if( ok ) { ok = ((file = ResOpenFileRO( info->file_name )) != -1); } if( ok ) { ok = WRReadEntireFile( file, &data, &data_size ); } if( ok ) { pih = (ICONHEADER *)data; pihsize = sizeof( ICONHEADER ); pihsize += sizeof( ICONDIRENTRY ) * (pih->idCount - 1); ok = WRCreateIconResHeader( &rih, &rihsize, data, data_size ); } if( ok ) { ok = ((info->dir = WResInitDir()) != NULL); } if( ok ) { tname = WResIDFromNum( (uint_16)RT_GROUP_ICON ); ok = (tname != NULL); } if( ok ) { _splitpath( info->file_name, NULL, NULL, fn, NULL ); rname = WResIDFromStr( fn ); ok = (rname != NULL); } if ( ok ) { ok = !WResAddResource( tname, rname, DEF_MEMFLAGS, 0, rihsize, info->dir, &lang, &dup ); } if( ok ) { ok = WRFindAndSetData( info->dir, tname, rname, &lang, rih ); } if( ok ) { for( i = 0; ok && i < pih->idCount; i++ ) { ok = WRGetAndAddIconImage( data, info->dir, &pih->idEntries[i], i + 1 ); } } if( !ok ) { if( info->dir != NULL ) { WRFreeWResDirData( info->dir ); WResFreeDir( info->dir ); info->dir = NULL; } } if( data != NULL ) { WRMemFree( data ); } if( tname != NULL ) { WRMemFree( tname ); } if( rname != NULL ) { WRMemFree( rname ); } if( file != -1 ) { ResCloseFile( file ); } return( ok ); }