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 */