5829 lines
155 KiB
C++
5829 lines
155 KiB
C++
//// RSRC - Win32 command line resource manager
|
||
//
|
||
// Copyright (c) 1996-9, Microsoft Corporation. All rights reserved.
|
||
//
|
||
// David C Brown [dbrown] 29th October 1998.
|
||
|
||
|
||
|
||
|
||
|
||
///// RSRC Command line
|
||
//
|
||
//c RSRC Executable [-l LocLang] [-u UnlocLang] [-i Types] [-q]
|
||
//c [ [-t|-d] TextOutput [-c UnlocExecutable]
|
||
//c | [-a|-r] text-input [-s symbols] [-v] ]
|
||
//
|
||
//p Executable: Win32 binary to analyse (default), to generate tokens (-t)
|
||
// or dump (-d) from, or containing resources to be replaced (-r)
|
||
// or appended to (-a).
|
||
//
|
||
//p -l LocLang: Restrict processing to the specified localized language. LangId
|
||
// should be specified as a full hex NLS Language id, for example use
|
||
// '-l 409' for US English. Required for replace (-r) operation.
|
||
//
|
||
//p -u UnlocLang: Specifies unlocalized language, defaults to 409 (US English).
|
||
//
|
||
//p -i Types: Restrict processing to listed types. Each type is indicated by a letter
|
||
// as below:
|
||
//
|
||
//t Letter | Type | Letter | Type | Letter | Type
|
||
//t ------ | ---- | ------ | ---- | ------ | ----
|
||
//t c | Cursors | g | Message tables | n | INFs
|
||
//t b | Bitmaps | v | Version info | h | HTML
|
||
//t i | Icons | a | Accelerators | x | Binary data
|
||
//t m | Menus | f | Font directories | |
|
||
//t d | Dialogs | t | Fonts | o | All others
|
||
//t s | Strings | r | RCDATA | a | All (default)
|
||
//
|
||
//
|
||
//p -q: Quiet. By default Rsrc displays summary statistics of types and languages
|
||
// of resources processed. -q suppresses all output except warning and error messages.
|
||
//
|
||
//p -t TextOutput: Generate tokens in checkin format.
|
||
//
|
||
//p -d TextOutput: Dump resources in Hex & ASCII format.
|
||
//
|
||
//p -c UnlocExecutable: Compare with unlocalized (English) resources - localised
|
||
// resources in executable are compared with English resources in
|
||
// UnlocExecutable. When the localised resource is bit for bit identical
|
||
// with the English resource RSRC writes a one line unloc
|
||
// token instead of the full resource. Valid only with tokenise (-t)
|
||
// option.
|
||
//
|
||
//p -a TextInput: Append resources from text input file. Every resource in the
|
||
// text file is added to the executable. Resources already in the executable
|
||
// are not removed. When a resource from the token file has the same type, id
|
||
// and language as one in the executable, the executable resource is replaced
|
||
// by the token resource.
|
||
//
|
||
//p -r TextInput: Replace English resources in executable by localised resources
|
||
// from text file. Requires -l parameter to specify localisation language.
|
||
// When a resource from the token file has the same type and id as one in the
|
||
// executable, and the executable resource is US English (409) and the localised
|
||
// resource is in the language specified on the -l parameter, the US English
|
||
// resource is removed.
|
||
//
|
||
//p -s Symbols: Symbol file (.dbg format). When RSRC updates the header checksum
|
||
// in executable, it will also do so in the named symbol file. Valid only
|
||
// with the replace (-r) and append (-a) options.
|
||
//
|
||
//
|
||
// Miscellaneous options
|
||
//
|
||
//p -v: Update file and product version. By default any file and product version
|
||
// in the token file is ignored during update/append, the file and product
|
||
// versions from the original unlocalised resources are retained.
|
||
//
|
||
|
||
|
||
|
||
|
||
|
||
|
||
///// Definitions
|
||
//
|
||
//p Resource key: The combination of resource type, resource id and
|
||
// resource language. The resource key uniquely identifies the
|
||
// resource. A Win32 executable can contain any combination of
|
||
// languages, ids and types so long as no two resources have the
|
||
// same type, key and language.
|
||
//
|
||
//p Resource type: A numeric or string value. Some numeric values are
|
||
// predefined, for example menus and dialogs, but apps can and
|
||
// do use any value they choose.
|
||
//
|
||
//p Resource id: A numeric or string value. Used by an application to
|
||
// identify the resource when calling FindResource, LoadString etc.
|
||
//
|
||
//p Resource language: An NLS LANGID, i.e. a combination of primary and
|
||
// sub-language, such as 0409 (US English).
|
||
//
|
||
//p Unloc token: A line in the token file specifying a localised resource
|
||
// key followed by '=lang,cksum' where lang is the unlocalised
|
||
// language (usually 0409) and cksum is the checksum of the unlocalised
|
||
// resource. Used when the only difference between the localised and
|
||
// unlocalised resource is the language in the resource key.
|
||
|
||
|
||
|
||
|
||
|
||
///// Use during localisation checkin process
|
||
//
|
||
//c RSRC LocalisedExecutable -c UnlocExecutable -t Tokens -l LocLang [-u UnlocLang]
|
||
//
|
||
// Extracts localized tokens for the specified langauge.
|
||
//
|
||
// Where a resource in the localised executable is bit for bit identical
|
||
// to a resource in the unlocalized executable, the resource content is not
|
||
// written to the token file. In its place RSRC writes an unloc token
|
||
// giving the checksum of the resource and specifying the target language.
|
||
//
|
||
// Warnings are generated if the localised executable contains resources
|
||
// in languages other than that specified by the -l parameter.
|
||
//
|
||
// Unlocalised resources for comparison are looked up in the unlocalised
|
||
// executable in the language specified on the -u parameter, default 409
|
||
// (US ENglish).
|
||
|
||
|
||
|
||
|
||
|
||
|
||
///// Use during the build to update a single language executable
|
||
//
|
||
//c RSRC Executable [-u UnlocLang] -r Tokens -l LocLang -s SymbolFile
|
||
//
|
||
// Each localised resource in the token file is added to the executable.
|
||
//
|
||
// Each corresponding unlocalized resource is removed from the executable.
|
||
//
|
||
// For each unloc token the unlocalized resource is found in the executable
|
||
// and its language is updated to the target localized language recorded
|
||
// in the unloc token.
|
||
//
|
||
// Tokens of other than the specified localised language are not
|
||
// processed, but generate warnings.
|
||
//
|
||
// Warnings are generated for any resources not appearing in both the
|
||
// executable and token files.
|
||
//
|
||
// Warnings are also generated for resources of other than the unlocalised
|
||
// language found in the original executable, and resources of other than
|
||
// the localised language in the token file.
|
||
//
|
||
// The unlocalised language defaults to 409 (US English).
|
||
|
||
|
||
|
||
|
||
///// Use during the build to add resources to a multi-language executable
|
||
//
|
||
//c RSRC Executable [-u UnlocLang] -a Tokens [-l Language] -s SymbolFile
|
||
//
|
||
// Localised resources from the token file are added to the executable.
|
||
//
|
||
// For each unloc token the unlocalised resource is found in the executable
|
||
// and copied for the localised language recorded in the unloc token.
|
||
//
|
||
// If '-l Languge' is specified, only tokens of that language are added.
|
||
// When used with the append (-a) option, '-l Language' applies only to
|
||
// the token file: pre-existing resources in the executable are not affected.
|
||
//
|
||
// If a resource from the token file matches a resource already in the
|
||
// executable in type, name and language, the executable resource
|
||
// is replaced.
|
||
//
|
||
// Warnings are generated if any token in the executable is replaced, or
|
||
// if the unlocalised resource corresponding to an unloc token is missing
|
||
// or has a checksum which differs from the unlocalised resource that was
|
||
// passed on the '-u' parameter when the toke file was created.
|
||
//
|
||
// If the '-l Language' option is used, warnings are generated for any
|
||
// resources of other languages found in the token file.
|
||
|
||
|
||
|
||
|
||
|
||
///// Token format - resource key and header
|
||
//
|
||
// A resource may be represented by one or more lines. When
|
||
// a resource is spread over more than one line, all lines except the
|
||
// first are indented by three spaces.
|
||
//
|
||
// The first line of every resource starts with the resource key as follows:
|
||
//
|
||
// type,id,language;
|
||
//
|
||
// This is followed by the codepage recorded in the resource directory.
|
||
// Note that the codepage is not part of the resource key, and is not
|
||
// maintained consistently by all software. In particular:
|
||
//
|
||
// o RC writes the codepage as zero
|
||
// o The NT UpdateResource API writes the codepage as 1252
|
||
// o Locstudio writes a codepage that corresponds to the resource language
|
||
//
|
||
// Winnt.h documents the codepage as follows:
|
||
//
|
||
// "Each resource data entry ... contains ... a CodePage that should be
|
||
// used when decoding code point values within the resource data.
|
||
// Typically for new applications the code page would be the unicode
|
||
// code page.'
|
||
//
|
||
// In practise I have never seen the codepage value set to Unicode (1200).
|
||
//
|
||
// If the '-c' (unlocalised comparison) parameter was provided on the
|
||
// rsrc command, and there was an unlocalised resource with the same type
|
||
// and id, the language and checksum of that unlocalised resource are
|
||
// appended.
|
||
//
|
||
// Finally, the resource data is represented in one of the forms below,
|
||
// or as 'unloc' if the resource data exactly matches the unlocalised resource
|
||
// found in the file passed by 'c'.
|
||
//
|
||
//
|
||
// There are thus three possible token key/header formats as follows:
|
||
//
|
||
//c type,id,language;codepage;resource-data
|
||
//
|
||
// Resource recorded in full, either no '-c' parameter specified, or
|
||
// resource does not exist in unlocalised file.
|
||
//
|
||
//
|
||
//c type,id,language;codepage,unlocalised-checksum,language;resource-data
|
||
//
|
||
// Resource recorded in full, '-c' parameter was specified, and localised
|
||
// resource image differed from unlocalised resource image.
|
||
//
|
||
//
|
||
//c type,id,language;codepage,unlocalised-checksum,language;'Unloc'
|
||
//
|
||
// Resource recorded in full, '-c' parameter was specified, and localised
|
||
// resource image was identical to unlocalised resource image.
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
///// Token samples - default hex format
|
||
//
|
||
//
|
||
// For most resource types, RSRC generates resources
|
||
// as a string of hex digits.
|
||
//
|
||
// For example, the following represents an accelerator resource.
|
||
//
|
||
//c 0009,0002,0409;00000000;Hex;00000020:030074008e00000003002e00840000000b0044008400000087002e0084000000
|
||
//
|
||
// o Type 0x0009 (Accelerator)
|
||
// o Id 0x0002
|
||
// o Language 0x0409 (LANG_ENGLISH, SUBLANG_US)
|
||
// o Codepage 0 (implies resource was probably generated by RC)
|
||
// o Length in bytes 0x0020
|
||
//
|
||
// The resource is short, so its hex representation follows the length.
|
||
//
|
||
//
|
||
// A larger binary resource is represented on multiple lines as follows:
|
||
//
|
||
//c 000a,4000,0409;00000000;Hex;0000016a
|
||
//c 00000000:0000640100004c0000000114020000000000c000000000000046830000003508000050130852c8e0bd0170493f38ace1bd016044d085c9e0bd01003000000000000001000000000000000000000000000000590014001f0fe04fd020ea3a6910a2d808002b30309d190023563a5c000000000000000000000000000000000065
|
||
//c 00000080:7c15003100000000003025a49e308857696e6e74000015003100000000002f25d3863508466f6e747300000000490000001c000000010000001c0000003900000000000000480000001d0000000300000063de7d98100000005f535445504853544550485f00563a5c57494e4e545c466f6e7473000010000000050000a02400
|
||
//c 00000100:00004200000060000000030000a05800000000000000737465706800000000000000000000004255867d3048d211b5d8d085029b1cfa4119c94a9f4dd211871f0000000000004255867d3048d211b5d8d085029b1cfa4119c94a9f4dd211871f00000000000000000000
|
||
//
|
||
// o Type 0x000a (RCDATA)
|
||
// o Id 0x4000
|
||
// o Language 0x0409 (LANG_ENGLISH, SUBLANG_US)
|
||
// o Codepage 0
|
||
// o Length in bytes 0x016a
|
||
//
|
||
// The hex representation is split onto multiple lines each of 128 bytes.
|
||
|
||
|
||
|
||
|
||
|
||
|
||
///// Warnings and errors
|
||
//
|
||
//
|
||
//
|
||
//
|
||
//
|
||
// o warning RSRC100: Localised resource has no corresponding unlocalised resource in %s
|
||
// o warning RSRC110: Unlocalised resource from token file appended to executable
|
||
// o warning RSRC111: Unlocalised resource from token file replaced unlocalised resource in executable
|
||
// o warning RSRC112: Localised resource from token file replaced localised resource already present in executable
|
||
// o warning RSRC113: Localised resource from token file appended to executable - there was no matching unlocalised resource
|
||
//
|
||
// o warning RSRC120: Token file resource does not match specified language - ignored
|
||
// o warning RSRC121: Token file resource is not a requested resource type - ignored
|
||
// o warning RSRC122: executable unlocalised resource checksum does not match checksum recorded in token file for resource %s
|
||
// o warning RSRC124: missing executable unlocalised resource for %s
|
||
// o warning RSRC125: executable contains no unlocalised resource corresponding to resource %s
|
||
//
|
||
// o warning RSRC160: Symbol file does not match exectable
|
||
// o warning RSRC161: Symbol file not processed
|
||
// o warning RSRC162: Could not reopen executable %s to update checksum
|
||
// o warning RSRC163: Failed to write updated symbol checksum
|
||
//
|
||
// o warning RSRC170: No localizable resources in %s
|
||
// o warning RSRC171: could not close executable
|
||
//
|
||
//
|
||
// o error RSRC230: 'Unloc' token is missing unlocalised resource information for %s
|
||
// o error RSRC231: Failed to apply unloc token
|
||
// o error RSRC232: Failed to apply token
|
||
//
|
||
// o error RSRC300: Hex digit expected
|
||
// o error RSRC301: Hex value too large
|
||
// o error RSRC302: Unexpected end of file
|
||
// o error RSRC303: \'%s\' expected
|
||
// o error RSRC304: newline expected
|
||
// o error RSRC310: Unrecognised resource type for resource %s
|
||
//
|
||
// o error RSRC400: -t (tokenise) option excludes -d, -a, -r, and -s
|
||
// o error RSRC401: -d (dump) option excludes -t, -u, -a, -r, and -s
|
||
// o error RSRC402: -a (append) option excludes -t, -d, -u, and -r
|
||
// o error RSRC403: -r (replace) option excludes -t, -d, -u, and -a
|
||
// o error RSRC404: -r (replace) option requires -l (LangId)
|
||
// o error RSRC405: Analysis excludes -s
|
||
//
|
||
// o error RSRC420: Update failed.
|
||
// o error RSRC421: Token extraction failed.
|
||
// o error RSRC422: Analysis failed.
|
||
//
|
||
// o error RSRC500: Corrupt executable - resource appears more than once
|
||
// o error RSRC501: %s is not an executable file
|
||
// o error RSRC502: %s is not a Win32 executable file
|
||
// o error RSRC503: No resources in %s
|
||
//
|
||
// o error RSRC510: Cannot open executable file %s
|
||
// o error RSRC511: cannot find resource directory in %s
|
||
// o error RSRC512: Cannot create resource token file %s
|
||
// o error RSRC513: Cannot open unlocalised executable file %s
|
||
// o error RSRC514: cannot find resource directory in unlocalised executable %s
|
||
// o error RSRC515: cannot write delta token file %s
|
||
// o error RSRC516: cannot write stand alone token file %s
|
||
//
|
||
// o error RSRC520: Cannot open resource token file %s
|
||
// o error RSRC521: UTF8 BOM missing from token file
|
||
//
|
||
// o error RSRC530: Cannot read executable resources from %s
|
||
// o error RSRC531: Failed reading update tokens
|
||
//
|
||
// o error RSRC600: BeginUpdateResource failed on %s
|
||
// o error RSRC601: UpdateResourceW failed on %s
|
||
// o error RSRC602: EndUpdateResourceW failed on %s
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// From Adina
|
||
//
|
||
// Here is my follow up on 2.
|
||
//
|
||
// Abstract:
|
||
// The build team needs the new tool eventually run with build.exe, i.e.
|
||
// we need build.exe recognize the errors, warnings, and simple output
|
||
// messages from rsrc.exe and write them to build.err, build.wrn and
|
||
// build.log files respectively.
|
||
//
|
||
// Solution:
|
||
// All we need is RSRC complain to the general rule for the MS tools.
|
||
// That is (\\orville\razzle\src\sdktools\build\buildexe.c):
|
||
// {toolname} : {number}: {text}
|
||
//
|
||
// where:
|
||
//
|
||
// toolname If possible, the container and specific module that has
|
||
// the error. For instance, the compiler uses
|
||
// filename(linenum), the linker uses library(objname), etc.
|
||
// If unable to provide a container, use the tool name.
|
||
// number A number, prefixed with some tool identifier (C for
|
||
// compiler, LNK for linker, LIB for librarian, N for nmake,
|
||
// etc).
|
||
// test The descriptive text of the message/error.
|
||
//
|
||
// Accepted String formats are:
|
||
// container(module): error/warning NUM ...
|
||
// container(module) : error/warning NUM ...
|
||
// container (module): error/warning NUM ...
|
||
// container (module) : error/warning NUM ...
|
||
//
|
||
// Ex. of RSRC error:
|
||
//
|
||
// RSRC : error RSRC2001: unable to open file d:\nt\binaries\jpn\ntdll.dll
|
||
//
|
||
// Ex. of RSRC warning:
|
||
//
|
||
// RSRC : warning RSRC5000: unable to find symbol file
|
||
// d:\nt\binaries\jpn\retail\dll\ntdll.dbg
|
||
//
|
||
// Be aware that the error number after "error/warning" is NOT optional.
|
||
// As the format above says, you can also display any information you
|
||
// consider useful (for example the name of the binary being processed,
|
||
// or the line number in the token file that caused the error/warning)
|
||
// immediately after the name of the tool: RSRC(<info>).
|
||
//
|
||
// I confirm that RSRC_OK=0, RSRC_WRN=1, RSRC_ERR=2 are fine with us as
|
||
// return values. Also, it does not make any difference if you write the
|
||
// output to stderr ot stdout, but I would suggest to write the tool's
|
||
// usage and all the warning and error message lines to stderr, and any
|
||
// other text to stdout (based on other ms tools we're using, like
|
||
// rebase.exe, binplace.exe, etc).
|
||
//
|
||
// I can make the changes to build.exe so that it recognizes RSRC.
|
||
//
|
||
// Please let me know if you have any questions.
|
||
//
|
||
// Thank you
|
||
// Adina
|
||
|
||
|
||
|
||
|
||
/// Following meeting Joerg. here are my action items:
|
||
//
|
||
// Meet with Joerg, Uwe, Majd, Hideki, Adina to plan usage in bidi NT5
|
||
// build process and consider use for odd jobs in other languages.
|
||
//
|
||
// P1. Implement option to skip updating file and product version, and
|
||
// to omit these from token file.
|
||
// P1. Implement separate error code for detecting unhandled binary
|
||
// format (such as win16).
|
||
//
|
||
// P2. Add CRC to each resource to detect SLM or editor corruption.
|
||
// (Delete CRC in token file always accepted to allow hand modification).
|
||
// P2. Option to disable header comment in token file
|
||
//
|
||
// P3. Interpret MSGTBL, ACCELERATOR and RCDATA - RCDATA as string
|
||
// depending on option.
|
||
//
|
||
// Thanks -- Dave.
|
||
|
||
|
||
|
||
|
||
//// From Joerg
|
||
//
|
||
// Howdy,
|
||
// I'm playing with rsrc and ran into problems with ParseToken(): if rsrc
|
||
// is located in a directory with spaces (e.g. Program Files),
|
||
// the function fails to skip the command name, since it's quoted and
|
||
// ParseToken stops at the first blank within the quotes.
|
||
// I also had trouble compiling it (so I can step thru and see what it's
|
||
// doing) under VC5 because there is no default constructor
|
||
// for the class "LangId", so I just added a dummy constructor.
|
||
//
|
||
// J<>rg
|
||
|
||
|
||
|
||
|
||
//// Following meeting planning bidi build, Wednesday 2nd Dec.
|
||
//
|
||
// Checksum protection against user changes to tok file
|
||
// Include length in warning comparison
|
||
// Will need alpha build
|
||
// Default file name - add .rsrc
|
||
// Don't extract file or product version
|
||
// => If version resource updated use file and product version from
|
||
// US at write time
|
||
// Diagnose version only resources
|
||
// Diagnose not win32
|
||
// Warning for no translations on tokenisation
|
||
// Warning no no translations on update, and don't touch executable
|
||
// Ability to -r any unlocalised language
|
||
|
||
|
||
|
||
|
||
//// Resultant priorities (8th Dec):
|
||
//
|
||
// <20> 1. Use unlocalised file/product version if updating version resource
|
||
// <20> 2. Analyse mode diagnoses no localisable resources and unhandled binary formats
|
||
// 3. Warn when no translations, don't touch executable if updating
|
||
// <20> 4. Support -r from any language to any language
|
||
// 5. Allocate error numbers, clarify error messages
|
||
//
|
||
// 6. Include length in unloc token
|
||
// <20> 7. Handle quoted installation directory and default filenames
|
||
// 8. Add checksum protection against corruption of token file
|
||
// 9. Option to interpret RCDATA as Unicode string (for kernel)
|
||
// 10. Interpret MSGTBL and ACCELERATOR
|
||
// 11. Support Win16 binaries
|
||
// 12. ? Option to disable token file header
|
||
|
||
|
||
|
||
|
||
|
||
|
||
#pragma warning( disable : 4786 ) // map creates some ridiculously long debug identifiers
|
||
|
||
|
||
#include "stdio.h"
|
||
#include "windows.h"
|
||
#include "imagehlp.h"
|
||
#include "time.h"
|
||
#include <map>
|
||
|
||
using namespace std ;
|
||
using namespace std::rel_ops ;
|
||
|
||
|
||
|
||
#define DBG 1
|
||
|
||
|
||
//// OK and ASSERT macros
|
||
//
|
||
// All functions return an HRESULT.
|
||
// All function calls are wrapped in 'OK()'.
|
||
// OK checks for a failed HRESULT and if so returns that HRESULT directly.
|
||
// Thus all errors propagate back up the call chain.
|
||
//
|
||
// MUST issues a message if an HRESULT is not S_OK and returns E_FAIL
|
||
// back up the call chain.
|
||
|
||
|
||
void __cdecl DebugMsg(char *fmt, ...) {
|
||
|
||
va_list vargs;
|
||
|
||
va_start(vargs, fmt);
|
||
vfprintf(stderr, fmt, vargs);
|
||
}
|
||
|
||
|
||
|
||
#define MUST(a,b) {HRESULT hr; hr = (a); if (hr!= S_OK) {if (!g_fError) DebugMsg b; g_fError = TRUE; return E_FAIL;};}
|
||
#define SHOULD(a,b) {HRESULT hr; hr = (a); if (hr!= S_OK) {DebugMsg b; g_fWarn = TRUE; return S_FALSE;};}
|
||
|
||
|
||
#if DBG
|
||
|
||
#pragma message("Checked build")
|
||
|
||
#define OK(a) {HRESULT hr; hr = (a); if (hr!= S_OK) {DebugMsg("%s(%d): error RSRC999 : HRESULT not S_OK: "#a"\n", __FILE__, __LINE__); return hr;};}
|
||
#define ASSERT(a) {if (!(a)) {DebugMsg("%s(%d): error RSRC999 : Assertion failed: "#a"\n", __FILE__, __LINE__); return E_UNEXPECTED;};}
|
||
|
||
#else
|
||
|
||
#pragma message ("Free build")
|
||
|
||
#define OK(a) {HRESULT hr; hr = (a); if (hr != S_OK) return hr;}
|
||
#define ASSERT(a) {if (!(a)) {return E_UNEXPECTED;};}
|
||
|
||
#endif
|
||
|
||
|
||
const int MAXPATH = 128;
|
||
const char HexDigit[] = "0123456789abcdef";
|
||
const BYTE bZeroPad[] = { 0, 0, 0, 0};
|
||
|
||
const int MAXHEXLINELEN=128;
|
||
|
||
|
||
|
||
|
||
const int OPTHELP = 0x00000001;
|
||
const int OPTQUIET = 0x00000002;
|
||
const int OPTEXTRACT = 0x00000004;
|
||
const int OPTUNLOC = 0x00000008;
|
||
const int OPTHEXDUMP = 0x00000010;
|
||
const int OPTAPPEND = 0x00000020;
|
||
const int OPTREPLACE = 0x00000040;
|
||
const int OPTSYMBOLS = 0x00000080;
|
||
const int OPTVERSION = 0x00000100;
|
||
|
||
|
||
const int PROCESSCUR = 0x00000001;
|
||
const int PROCESSBMP = 0x00000002;
|
||
const int PROCESSICO = 0x00000004;
|
||
const int PROCESSMNU = 0x00000008;
|
||
const int PROCESSDLG = 0x00000010;
|
||
const int PROCESSSTR = 0x00000020;
|
||
const int PROCESSFDR = 0x00000040;
|
||
const int PROCESSFNT = 0x00000080;
|
||
const int PROCESSACC = 0x00000100;
|
||
const int PROCESSRCD = 0x00000200;
|
||
const int PROCESSMSG = 0x00000400;
|
||
const int PROCESSVER = 0x00000800;
|
||
const int PROCESSBIN = 0x00001000;
|
||
const int PROCESSINF = 0x00002000;
|
||
const int PROCESSOTH = 0x00004000;
|
||
|
||
|
||
const int PROCESSALL = 0xFFFFFFFF;
|
||
|
||
|
||
|
||
|
||
DWORD g_dwOptions = 0;
|
||
DWORD g_dwProcess = 0;
|
||
LANGID g_LangId = 0xffff;
|
||
BOOL g_fWarn = FALSE;
|
||
BOOL g_fError = FALSE;
|
||
LANGID g_liUnlocalized = 0x0409; // Standard unlocalized language
|
||
|
||
int g_cResourcesIgnored = 0;
|
||
int g_cResourcesUpdated = 0; // Simple replacement
|
||
int g_cResourcesTranslated = 0; // Changed from unloc language to loc language
|
||
int g_cResourcesAppended = 0; // Added without affecting existing resources
|
||
int g_cResourcesExtracted = 0; // Extracted to token file
|
||
|
||
char g_szTypes [MAXPATH];
|
||
char g_szExecutable [MAXPATH]; // Name of executable being analysed, tokenised or updated
|
||
char g_szResources [MAXPATH]; // Name of resource token file
|
||
char g_szUnloc [MAXPATH]; // Name of unlocalized executable for comparison
|
||
|
||
|
||
|
||
|
||
int HexCharVal(char c) {
|
||
switch (c) {
|
||
case '0':
|
||
case '1':
|
||
case '2':
|
||
case '3':
|
||
case '4':
|
||
case '5':
|
||
case '6':
|
||
case '7':
|
||
case '8':
|
||
case '9':
|
||
return c - '0';
|
||
case 'a':
|
||
case 'b':
|
||
case 'c':
|
||
case 'd':
|
||
case 'e':
|
||
case 'f':
|
||
return c - 'a' + 10;
|
||
case 'A':
|
||
case 'B':
|
||
case 'C':
|
||
case 'D':
|
||
case 'E':
|
||
case 'F':
|
||
return c - 'A' + 10;
|
||
}
|
||
return -1; // Not a hex value
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//// Scanner
|
||
//
|
||
// A structure for scanning through a block of memory
|
||
|
||
|
||
class Scanner {
|
||
|
||
protected:
|
||
|
||
const BYTE *m_pStart;
|
||
const BYTE *m_pRead;
|
||
const BYTE *m_pLimit;
|
||
|
||
|
||
public:
|
||
|
||
Scanner() {m_pStart = NULL; m_pRead = NULL; m_pLimit = NULL;}
|
||
Scanner(const BYTE *pb, DWORD dwLen) {m_pStart = pb; m_pRead = pb; m_pLimit = pb+dwLen;}
|
||
~Scanner() {m_pStart = NULL; m_pRead = NULL; m_pLimit=NULL;}
|
||
|
||
|
||
const BYTE* GetRead() {return m_pRead;}
|
||
const BYTE* GetLimit() {return m_pLimit;}
|
||
|
||
|
||
|
||
HRESULT Advance(UINT cBytes) {
|
||
ASSERT(m_pStart != NULL);
|
||
ASSERT(m_pRead+cBytes <= m_pLimit);
|
||
m_pRead += cBytes;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT Align(const BYTE *pb, int iAlignment) {
|
||
// Advance until read position is a multiple of iAlignment
|
||
// past pb. iAlignment MUST be a power of 2.
|
||
// Does not advance past limit.
|
||
|
||
|
||
// Ensure iAlignment is a power of 2
|
||
// This seems like a good test, though I'm not sure I could prove it!
|
||
ASSERT((iAlignment | iAlignment-1) == iAlignment*2 - 1);
|
||
|
||
|
||
if (m_pRead - pb & iAlignment - 1) {
|
||
|
||
m_pRead += (iAlignment - (m_pRead - pb & iAlignment - 1));
|
||
|
||
if (m_pRead > m_pLimit) {
|
||
m_pRead = m_pLimit;
|
||
}
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT SetRead(const BYTE *pb) {
|
||
ASSERT(m_pRead != NULL);
|
||
ASSERT(pb >= m_pStart);
|
||
ASSERT(pb < m_pLimit);
|
||
m_pRead = pb;
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
class TextScanner : public Scanner {
|
||
|
||
protected:
|
||
|
||
const BYTE *m_pLine; // Start of current line
|
||
int m_iLine; // Current line
|
||
char m_szTextPos[40];
|
||
|
||
public:
|
||
|
||
TextScanner() {m_pLine = NULL; m_iLine = 0; Scanner();}
|
||
|
||
virtual char *GetTextPos() {
|
||
sprintf(m_szTextPos, "%d:%d", m_iLine, m_pRead-m_pLine+1);
|
||
return m_szTextPos;
|
||
}
|
||
|
||
|
||
//// ReadString
|
||
//
|
||
// Translates UTF8 to Unicode
|
||
// Removes '\' escapes as necessary
|
||
// Always returns a new zero terminated string
|
||
|
||
HRESULT ReadString(WCHAR **ppwcString, int *piLen) {
|
||
|
||
char *pc;
|
||
WCHAR *pwc;
|
||
int iLen;
|
||
|
||
|
||
ASSERT(*((char*)m_pRead) == '\"');
|
||
OK(Advance(1));
|
||
|
||
pc = (char*)m_pRead;
|
||
iLen = 0;
|
||
|
||
|
||
// Count the number of unicode codepoints represented by the string
|
||
|
||
while ( *pc != '\"'
|
||
&& pc < (char*)m_pLimit) {
|
||
|
||
while ( pc < (char*)m_pLimit
|
||
&& *pc != '\\'
|
||
&& *pc != '\"' ) {
|
||
|
||
if (*pc < 128) {
|
||
pc++;
|
||
} else {
|
||
ASSERT(*pc >= 0xC0); // 80-BF reserved for trailing bytes
|
||
if (*pc < 0xE0) {
|
||
pc+=2;
|
||
} else if (*pc < 0xF0) {
|
||
pc+=3;
|
||
} else {
|
||
iLen++; // Additional Unicode codepoint required for surrogate
|
||
pc+=4;
|
||
}
|
||
ASSERT(pc <= (char*)m_pLimit);
|
||
}
|
||
iLen++;
|
||
}
|
||
|
||
if (*pc == '\\') {
|
||
pc++;
|
||
if (pc < (char*)m_pLimit) {
|
||
pc++;
|
||
iLen++;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
// Create a Unicode copy of the string
|
||
|
||
*ppwcString = new WCHAR[iLen+1];
|
||
|
||
ASSERT(*ppwcString != NULL);
|
||
|
||
pwc = *ppwcString;
|
||
|
||
while (*((char*)m_pRead) != '\"') {
|
||
|
||
while ( *((char*)m_pRead) != '\\'
|
||
&& *((char*)m_pRead) != '\"') {
|
||
|
||
if (*m_pRead < 0x80) {
|
||
*pwc++ = *(char*)m_pRead;
|
||
m_pRead++;
|
||
} else {
|
||
if (*m_pRead < 0xE0) {
|
||
*pwc++ = (WCHAR)(*m_pRead & 0x1F) << 6
|
||
| (WCHAR)(*(m_pRead+1) & 0x3F);
|
||
m_pRead+=2;
|
||
} else if (*m_pRead < 0xF0) {
|
||
*pwc++ = (WCHAR)(*m_pRead & 0x0F) << 12
|
||
| (WCHAR)(*(m_pRead+1) & 0x3F) << 6
|
||
| (WCHAR)(*(m_pRead+2) & 0x3F);
|
||
m_pRead+=3;
|
||
} else {
|
||
*pwc++ = 0xd800
|
||
| (( (WCHAR)(*m_pRead & 0x07 << 2)
|
||
| (WCHAR)(*(m_pRead+1) & 0x30 >> 4)) - 1) << 6
|
||
| (WCHAR)(*(m_pRead+1) & 0x0F) << 2
|
||
| (WCHAR)(*(m_pRead+2) & 0x30) >> 4;
|
||
*pwc++ = 0xdc00
|
||
| (WCHAR)(*(m_pRead+2) & 0x0f) << 6
|
||
| (WCHAR)(*(m_pRead+3) & 0x3f);
|
||
m_pRead+=4;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (*(char*)m_pRead == '\\') {
|
||
m_pRead++;
|
||
if (m_pRead < m_pLimit) {
|
||
switch (*(char*)m_pRead) {
|
||
case 'r': *pwc++ = '\r'; break;
|
||
case 'n': *pwc++ = '\n'; break;
|
||
case 't': *pwc++ = '\t'; break;
|
||
case 'z': *pwc++ = 0; break;
|
||
case 'L': *pwc++ = 0x2028; break; // Line separator
|
||
case 'P': *pwc++ = 0x2029; break; // Paragraph separator
|
||
default: *pwc++ = *(char*)m_pRead;
|
||
}
|
||
m_pRead++;
|
||
}
|
||
}
|
||
}
|
||
|
||
*pwc = 0; // Add zero terminator
|
||
m_pRead ++;
|
||
*piLen = pwc - *ppwcString;
|
||
|
||
|
||
ASSERT(m_pRead <= m_pLimit);
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
//// ReadHex
|
||
//
|
||
// Reads all characters up to he first non-hex digit and returns
|
||
// the value represented by the sequence as a DWORD
|
||
|
||
|
||
HRESULT ReadHex(DWORD *pdwVal) {
|
||
*pdwVal = 0;
|
||
|
||
MUST(HexCharVal(*(char*)m_pRead) >= 0
|
||
? S_OK : E_FAIL,
|
||
("%s: error RSRC300: Hex digit expected\n", GetTextPos()));
|
||
|
||
while ( HexCharVal(*(char*)m_pRead) >= 0
|
||
&& m_pRead < m_pLimit) {
|
||
|
||
MUST(*pdwVal < 0x10000000
|
||
? S_OK : E_FAIL,
|
||
("%s: error RSRC301: Hex value too large\n", GetTextPos()));
|
||
|
||
|
||
*pdwVal = *pdwVal << 4 | HexCharVal(*(char*)m_pRead);
|
||
OK(Advance(1));
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
//// ReadHexByte - Read exactly 2 hex digits
|
||
|
||
HRESULT ReadHexByte(BYTE *pb) {
|
||
int n1,n2; // The two nibbles.
|
||
n1 = HexCharVal(*(char*)m_pRead);
|
||
n2 = HexCharVal(*(char*)(m_pRead+1));
|
||
|
||
MUST( n1 >= 0
|
||
&& n2 >= 0
|
||
? S_OK : E_FAIL,
|
||
("%s: error RSRC300: Hex digit expected\n", GetTextPos()));
|
||
|
||
*pb = (n1 << 4) + n2;
|
||
|
||
MUST(Advance(2),
|
||
("%s: error RSRC302: Unexpected end of file\n", GetTextPos()));
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
HRESULT Expect(const char *pc) {
|
||
while ( *pc
|
||
&& m_pRead+1 <= m_pLimit) {
|
||
|
||
MUST(*(char*)m_pRead == *pc
|
||
? S_OK : E_FAIL,
|
||
("%s: error RSRC303: \'%s\' expected\n", GetTextPos(), pc));
|
||
m_pRead++;
|
||
pc++;
|
||
}
|
||
|
||
MUST(*pc == 0
|
||
? S_OK : E_FAIL,
|
||
("%s: error RSRC303: \'%s\' expected\n", GetTextPos(), pc));
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
//// SkipLn
|
||
//
|
||
// Skip to beginning of next non empty, non comment line.
|
||
|
||
|
||
HRESULT SkipLn() {
|
||
|
||
ASSERT(m_pRead != NULL);
|
||
|
||
while (m_pRead < m_pLimit) {
|
||
|
||
if (*(char*)m_pRead == '\r') {
|
||
|
||
m_pRead++;
|
||
|
||
if (m_pRead < m_pLimit && *(char*)m_pRead == '\n') {
|
||
|
||
m_pRead++;
|
||
m_pLine = m_pRead;
|
||
m_iLine++;
|
||
|
||
if ( m_pRead < m_pLimit
|
||
&& *(char*)m_pRead != '#'
|
||
&& *(char*)m_pRead != '\r') {
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
} else {
|
||
|
||
m_pRead++;
|
||
}
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
//// ExpectLn
|
||
//
|
||
// Expect end of line, preceeded by any whitespace
|
||
//
|
||
// Also skips trailing comments and whole line comments
|
||
//
|
||
// Any parameter is passed to Expect to vb found at the beginning of the new line
|
||
|
||
|
||
HRESULT ExpectLn(const char *pc) {
|
||
|
||
ASSERT(m_pRead != NULL);
|
||
|
||
while ( m_pRead < m_pLimit
|
||
&& ( *(char*)m_pRead == ' '
|
||
|| *(char*)m_pRead == '\t')) {
|
||
|
||
m_pRead++;
|
||
}
|
||
|
||
|
||
if ( m_pRead < m_pLimit
|
||
&& ( *(char*)m_pRead == '\r'
|
||
|| *(char*)m_pRead == '#')) {
|
||
|
||
// Condition satisfied, skip to first non comment line
|
||
|
||
SkipLn();
|
||
|
||
} else {
|
||
|
||
MUST(E_FAIL,("%s: error RSRC304: newline expected\n", GetTextPos()));
|
||
}
|
||
|
||
|
||
if (pc) {
|
||
return Expect(pc);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// Mapped files
|
||
//
|
||
// File mapping is used to read executable and token files.
|
||
//
|
||
// File mapping is also used to update in place checksum information
|
||
// in executable and symbol files.
|
||
|
||
|
||
class MappedFile : public TextScanner {
|
||
|
||
HANDLE m_hFileMapping;
|
||
BOOL fRW; // True when writeable
|
||
char m_szFileName[MAXPATH];
|
||
char m_szTextPos[MAXPATH+40];
|
||
|
||
public:
|
||
|
||
MappedFile() {m_hFileMapping = NULL; TextScanner();}
|
||
|
||
|
||
const BYTE* GetFile() {return m_pStart;}
|
||
virtual char *GetTextPos() {
|
||
sprintf(m_szTextPos, "%s(%s)", m_szFileName, TextScanner::GetTextPos());
|
||
return m_szTextPos;
|
||
}
|
||
|
||
|
||
HRESULT Open(const char *pcFileName, BOOL fWrite) {
|
||
|
||
HANDLE hFile;
|
||
|
||
m_pStart = NULL;
|
||
m_pRead = NULL;
|
||
m_pLimit = NULL;
|
||
|
||
strcpy(m_szFileName, pcFileName);
|
||
|
||
hFile = CreateFileA(
|
||
pcFileName,
|
||
GENERIC_READ | (fWrite ? GENERIC_WRITE : 0),
|
||
FILE_SHARE_READ | (fWrite ? FILE_SHARE_WRITE | FILE_SHARE_DELETE : 0 ),
|
||
NULL,
|
||
OPEN_EXISTING,
|
||
FILE_ATTRIBUTE_NORMAL,
|
||
NULL);
|
||
|
||
ASSERT(hFile != INVALID_HANDLE_VALUE);
|
||
|
||
m_hFileMapping = CreateFileMapping(
|
||
hFile,
|
||
NULL,
|
||
fWrite ? PAGE_READWRITE : PAGE_WRITECOPY,
|
||
0,0, NULL);
|
||
|
||
ASSERT(m_hFileMapping != NULL);
|
||
|
||
m_pStart = (BYTE*) MapViewOfFile(
|
||
m_hFileMapping,
|
||
fWrite ? FILE_MAP_WRITE : FILE_MAP_READ,
|
||
0,0, 0);
|
||
|
||
ASSERT(m_pStart != NULL);
|
||
|
||
m_pRead = m_pStart;
|
||
m_pLine = m_pStart;
|
||
m_pLimit = m_pStart + GetFileSize(hFile, NULL);
|
||
m_iLine = 1;
|
||
CloseHandle(hFile);
|
||
|
||
fRW = fWrite;
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
DWORD CalcChecksum() {
|
||
|
||
DWORD dwHeaderSum;
|
||
DWORD dwCheckSum;
|
||
|
||
if (CheckSumMappedFile((void*)m_pStart, m_pLimit-m_pStart, &dwHeaderSum, &dwCheckSum) == NULL) {
|
||
return 0;
|
||
} else {
|
||
return dwCheckSum;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
HRESULT Close() {
|
||
if (m_pStart) {
|
||
UnmapViewOfFile(m_pStart);
|
||
CloseHandle(m_hFileMapping);
|
||
m_hFileMapping = NULL;
|
||
m_pStart = NULL;
|
||
}
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// NewFile - services for writing a new text otr binary file
|
||
//
|
||
//
|
||
|
||
|
||
class NewFile {
|
||
|
||
HANDLE hFile;
|
||
DWORD cbWrite; // Bytes written
|
||
BYTE buf[4096]; // Performance buffer
|
||
int iBufUsed;
|
||
|
||
public:
|
||
|
||
NewFile() {iBufUsed = 0;}
|
||
|
||
int GetWrite() {return cbWrite;}
|
||
|
||
|
||
HRESULT OpenWrite(char *pcFileName) {
|
||
|
||
cbWrite = 0; // Bytes written
|
||
|
||
hFile = CreateFileA(
|
||
pcFileName,
|
||
GENERIC_READ | GENERIC_WRITE,
|
||
0, // Not shared
|
||
NULL,
|
||
CREATE_ALWAYS,
|
||
FILE_ATTRIBUTE_NORMAL,
|
||
NULL);
|
||
|
||
ASSERT(hFile != INVALID_HANDLE_VALUE);
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
HRESULT WriteBytes(const BYTE *pb, DWORD dwLen) {
|
||
|
||
DWORD dwWritten;
|
||
|
||
if (iBufUsed + dwLen <= sizeof(buf)) {
|
||
|
||
memcpy(buf+iBufUsed, pb, dwLen);
|
||
iBufUsed += dwLen;
|
||
|
||
} else {
|
||
|
||
ASSERT(hFile != NULL);
|
||
|
||
if (iBufUsed > 0) {
|
||
ASSERT(WriteFile(hFile, buf, iBufUsed, &dwWritten, NULL));
|
||
ASSERT(dwWritten == iBufUsed);
|
||
iBufUsed = 0;
|
||
}
|
||
|
||
if (dwLen <= sizeof(buf)) {
|
||
|
||
memcpy(buf, pb, dwLen);
|
||
iBufUsed = dwLen;
|
||
|
||
} else {
|
||
|
||
ASSERT(WriteFile(hFile, pb, dwLen, &dwWritten, NULL));
|
||
ASSERT(dwWritten == dwLen);
|
||
}
|
||
}
|
||
|
||
cbWrite += dwLen;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
HRESULT WriteS(const char *pc) {
|
||
return WriteBytes((BYTE*)pc, strlen(pc));
|
||
}
|
||
|
||
|
||
|
||
//// WriteString
|
||
//
|
||
// Translates Unicode to UTF8
|
||
// Adds '\' escapes as necessary
|
||
|
||
|
||
HRESULT WriteString(const WCHAR *pwc, int iLen) {
|
||
|
||
BYTE buf[3];
|
||
const WCHAR *pwcLimit;
|
||
|
||
pwcLimit = pwc + iLen;
|
||
OK(WriteBytes((BYTE*)"\"", 1));
|
||
while (pwc < pwcLimit) {
|
||
switch (*pwc) {
|
||
case 0: OK(WriteS("\\z")); break;
|
||
case '\r': OK(WriteS("\\r")); break;
|
||
case '\n': OK(WriteS("\\n")); break;
|
||
case '\t': OK(WriteS("\\t")); break;
|
||
case 0x2028: OK(WriteS("\\L")); break; // Line separator
|
||
case 0x2029: OK(WriteS("\\P")); break; // Paragraph separator
|
||
case '\"': OK(WriteS("\\\"")); break;
|
||
case '\\': OK(WriteS("\\\\")); break;
|
||
default:
|
||
if (*pwc < 128) {
|
||
OK(WriteBytes((BYTE*)pwc, 1));
|
||
} else if (*pwc < 0x7FF) {
|
||
buf[0] = 0xC0 | *pwc >> 6;
|
||
buf[1] = 0x80 | *pwc & 0x3F;
|
||
OK(WriteBytes(buf, 2));
|
||
} else {
|
||
// Note - should code surrogates properly, this doesn't
|
||
buf[0] = 0xE0 | *pwc>>12 & 0x0F;
|
||
buf[1] = 0x80 | *pwc>>6 & 0x3F;
|
||
buf[2] = 0x80 | *pwc & 0x3F;
|
||
OK(WriteBytes(buf, 3));
|
||
}
|
||
}
|
||
pwc++;
|
||
}
|
||
OK(WriteBytes((BYTE*)"\"", 1));
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
//// WriteHex
|
||
//
|
||
// Writes the given value in the given number of digits.
|
||
//
|
||
// If cDigits is zero, uses as many as necessary.
|
||
|
||
|
||
|
||
HRESULT WriteHex(DWORD dw, int cDigits) {
|
||
int i;
|
||
char cBuf[8];
|
||
|
||
i = 7;
|
||
|
||
while (dw && i >= 0) {
|
||
cBuf[i] = HexDigit[dw & 0xf];
|
||
dw >>= 4;
|
||
i--;
|
||
}
|
||
|
||
if (cDigits != 0) {
|
||
while (i >= (8-cDigits)) {
|
||
cBuf[i] = '0';
|
||
i--;
|
||
}
|
||
}
|
||
|
||
OK(WriteBytes((BYTE*)(cBuf+i+1), 7-i));
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
//// WriteHexBuffer
|
||
//
|
||
// Writes a buffer of up to 256 bytes as a continuous stream of hex digits
|
||
|
||
|
||
|
||
HRESULT WriteHexBuffer(const BYTE *pb, DWORD dwLength) {
|
||
DWORD i;
|
||
char cBuf[512];
|
||
|
||
ASSERT(hFile);
|
||
ASSERT(dwLength <= 256);
|
||
|
||
for (i=0; i<dwLength; i++) {
|
||
cBuf[2*i] = HexDigit[*pb >> 4 & 0xf];
|
||
cBuf[2*i+1] = HexDigit[*pb & 0xf];
|
||
pb++;
|
||
}
|
||
|
||
OK(WriteBytes((BYTE*)cBuf, 2*dwLength));
|
||
cbWrite += 2*dwLength;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
//// WriteLn
|
||
//
|
||
// Write end of line mark (CR,LF)
|
||
|
||
HRESULT WriteLn() {
|
||
return WriteS("\r\n");
|
||
}
|
||
|
||
|
||
HRESULT Close() {
|
||
DWORD dwWritten;
|
||
if (hFile) {
|
||
if (iBufUsed > 0) {
|
||
ASSERT(WriteFile(hFile, buf, iBufUsed, &dwWritten, NULL));
|
||
ASSERT(dwWritten == iBufUsed);
|
||
}
|
||
CloseHandle(hFile);
|
||
hFile = NULL;
|
||
}
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// Resource structures
|
||
//
|
||
// Each resource structure has an internal representation for the
|
||
// resource that may be read and written to/from both text and
|
||
// executable files.
|
||
//
|
||
// The ReadTok and WriteTok functions handle formatting and parsing
|
||
// of the token file.
|
||
//
|
||
// The ReadBin function unpacks a resource from a memory mapped
|
||
// executable into the internal representation.
|
||
//
|
||
// The cbBin function returns the unpadded length required for the
|
||
// item in executable (packed) format.
|
||
//
|
||
// The CopyBin function packs the internal representation into a
|
||
// target buffer.
|
||
|
||
|
||
class Resource {
|
||
public:
|
||
virtual HRESULT ReadTok (TextScanner &mfText) = 0;
|
||
virtual HRESULT ReadBin (Scanner &mfBin, DWORD dwLen) = 0;
|
||
|
||
virtual HRESULT WriteTok (NewFile &nfText) const = 0;
|
||
virtual size_t cbBin () const = 0;
|
||
virtual HRESULT CopyBin (BYTE **ppb) const = 0;
|
||
|
||
// For statistics
|
||
|
||
virtual int GetItems () const = 0;
|
||
virtual int GetWords () const = 0;
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ResourceBYTE
|
||
//
|
||
// BYTE value represented in hex digits.
|
||
|
||
|
||
class ResourceBYTE {
|
||
|
||
|
||
public:
|
||
|
||
BYTE b;
|
||
|
||
HRESULT ReadBin(Scanner *pmf) {
|
||
b = *((BYTE*)(pmf->GetRead()));
|
||
OK(pmf->Advance(sizeof(BYTE)));
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBin() const {
|
||
return 1;
|
||
}
|
||
|
||
HRESULT CopyBin(BYTE **ppb) const {
|
||
**ppb = b;
|
||
(*ppb)++;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
DWORD dw;
|
||
OK(pmf->ReadHex(&dw));
|
||
ASSERT(dw < 0x100);
|
||
b = (BYTE)dw;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
OK(pmf->WriteHex(b, 2));
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ResoureWORD
|
||
//
|
||
// WORD value represented in hex digits.
|
||
|
||
|
||
class ResourceWORD {
|
||
|
||
public:
|
||
|
||
WORD w;
|
||
|
||
HRESULT ReadBin(Scanner *pmf) {
|
||
w = *((WORD*)(pmf->GetRead()));
|
||
OK(pmf->Advance(sizeof(WORD)));
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBin() const {
|
||
return sizeof(WORD);
|
||
}
|
||
|
||
HRESULT CopyBin(BYTE **ppb) const {
|
||
*(WORD*)*ppb = w;
|
||
*ppb += sizeof(WORD);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
DWORD dw;
|
||
OK(pmf->ReadHex(&dw));
|
||
ASSERT(dw < 0x10000);
|
||
w = (WORD)dw;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
OK(pmf->WriteHex(w, 4));
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ResourceDWORD
|
||
//
|
||
// DWORD value represented in hex digits.
|
||
|
||
|
||
class ResourceDWORD {
|
||
|
||
public:
|
||
|
||
DWORD dw;
|
||
|
||
HRESULT ReadBin(Scanner *pmf) {
|
||
dw = *((DWORD*)(pmf->GetRead()));
|
||
OK(pmf->Advance(sizeof(DWORD)));
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBin() const {
|
||
return sizeof(DWORD);
|
||
}
|
||
|
||
HRESULT CopyBin(BYTE **ppb) const {
|
||
*(DWORD*)*ppb = dw;
|
||
*ppb += sizeof(DWORD);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
OK(pmf->ReadHex(&dw));
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
OK(pmf->WriteHex(dw, 8));
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ResourceString
|
||
//
|
||
// String displayed with quotes. May be zero terminated or length
|
||
// word.
|
||
|
||
|
||
const WCHAR wcZero = 0;
|
||
|
||
class ResourceString {
|
||
|
||
WCHAR *pwcString;
|
||
WORD iLen;
|
||
|
||
void rsFree() {
|
||
if (pwcString)
|
||
delete [] pwcString;
|
||
pwcString = NULL;
|
||
iLen = 0;
|
||
}
|
||
|
||
public:
|
||
|
||
ResourceString() {pwcString = NULL; iLen = 0;}
|
||
~ResourceString() {rsFree();}
|
||
|
||
ResourceString& operator= (const ResourceString &rs) {
|
||
iLen = rs.iLen;
|
||
pwcString = new WCHAR[iLen+1];
|
||
memcpy(pwcString, rs.pwcString, 2*(iLen+1));
|
||
return *this;
|
||
}
|
||
|
||
ResourceString(const ResourceString &rs) {
|
||
*this = rs;
|
||
}
|
||
|
||
|
||
const WCHAR *GetString() const {return pwcString;}
|
||
const int GetLength() const {return iLen;};
|
||
void SetEmpty () {iLen = 0; pwcString = NULL;}
|
||
|
||
HRESULT ReadBinL(Scanner *pmf) {
|
||
rsFree();
|
||
|
||
iLen = *((WORD*)(pmf->GetRead()));
|
||
OK(pmf->Advance(sizeof(WORD)));
|
||
|
||
pwcString = new WCHAR[iLen+1];
|
||
ASSERT(pwcString != NULL);
|
||
memcpy(pwcString, (WCHAR*)pmf->GetRead(), 2*iLen);
|
||
pwcString[iLen] = 0;
|
||
|
||
OK(pmf->Advance(iLen * sizeof(WCHAR)));
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBinL() const {
|
||
return iLen * sizeof(WCHAR) + sizeof(WORD);
|
||
}
|
||
|
||
HRESULT CopyBinL(BYTE **ppb) const {
|
||
*(WORD*)*ppb = iLen;
|
||
*ppb += sizeof(WORD);
|
||
memcpy(*ppb, pwcString, sizeof(WCHAR)*iLen);
|
||
*ppb += sizeof(WCHAR)*iLen;
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
// Zero terminated
|
||
|
||
HRESULT ReadBinZ(Scanner *pmf) {
|
||
|
||
const WCHAR* pwc;
|
||
rsFree();
|
||
|
||
pwc = (WCHAR*)pmf->GetRead();
|
||
while (*(WCHAR*)pmf->GetRead() != 0) {
|
||
OK(pmf->Advance(2));
|
||
}
|
||
|
||
iLen = (WCHAR*)pmf->GetRead() - pwc;
|
||
OK(pmf->Advance(2));
|
||
|
||
|
||
pwcString = new WCHAR[iLen+1];
|
||
ASSERT(pwcString != NULL);
|
||
memcpy(pwcString, pwc, 2*(iLen+1));
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBinZ() const {
|
||
return (iLen+1) * sizeof(WCHAR);
|
||
}
|
||
|
||
|
||
// Known length (dwLen excludes zero terminator)
|
||
|
||
HRESULT ReadBin(Scanner *pmf, DWORD dwLen) {
|
||
|
||
rsFree();
|
||
iLen = dwLen;
|
||
|
||
pwcString = new WCHAR[dwLen+1];
|
||
ASSERT(pwcString != NULL);
|
||
memcpy(pwcString, pmf->GetRead(), 2*dwLen);
|
||
pwcString[dwLen] = 0;
|
||
OK(pmf->Advance(2*dwLen));
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBin() const {
|
||
return iLen * sizeof(WCHAR);
|
||
}
|
||
|
||
HRESULT CopyBinZ(BYTE **ppb) const {
|
||
memcpy(*ppb, pwcString, sizeof(WCHAR)*iLen);
|
||
*ppb += sizeof(WCHAR)*iLen;
|
||
*(WCHAR*)*ppb = 0;
|
||
*ppb += sizeof(WCHAR);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
int l;
|
||
rsFree();
|
||
OK(pmf->ReadString(&pwcString, &l));
|
||
ASSERT(l < 0x10000 && l >= 0);
|
||
iLen = (WORD) l;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
OK(pmf->WriteString(pwcString, iLen));
|
||
return S_OK;
|
||
}
|
||
|
||
int GetWords() const {
|
||
|
||
int i;
|
||
int wc;
|
||
|
||
i = 0;
|
||
wc = 0;
|
||
|
||
while (i<iLen) {
|
||
|
||
while ( i < iLen
|
||
&& pwcString[i] <= ' ') {
|
||
i++;
|
||
}
|
||
|
||
if (i<iLen) {
|
||
wc++;
|
||
}
|
||
|
||
while ( i < iLen
|
||
&& pwcString[i] > ' ') {
|
||
i++;
|
||
}
|
||
}
|
||
|
||
return wc;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ResourceVariant
|
||
//
|
||
// A widely used alternative of either a Unicode string or a WORD value.
|
||
|
||
|
||
class ResourceVariant {
|
||
|
||
ResourceString *prs;
|
||
ResourceWORD rw;
|
||
BOOL fString;
|
||
|
||
void rvFree() {
|
||
if (fString && prs)
|
||
delete prs;
|
||
prs = NULL;
|
||
fString=FALSE;
|
||
}
|
||
|
||
public:
|
||
|
||
ResourceVariant() {fString=FALSE; prs=NULL;}
|
||
~ResourceVariant() {rvFree();}
|
||
|
||
// Copy and assignment constructors required as this is used as the key in an STL map
|
||
|
||
ResourceVariant& operator= (const ResourceVariant &rv) {
|
||
fString = rv.fString;
|
||
if (fString) {
|
||
prs = new ResourceString(*rv.prs);
|
||
} else {
|
||
prs = NULL;
|
||
rw = rv.rw;
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
ResourceVariant(const ResourceVariant &rv) {
|
||
*this = rv;
|
||
}
|
||
|
||
|
||
void fprint(FILE *fh) const {
|
||
if (fString) {
|
||
fprintf(fh, "%S", prs->GetString());
|
||
} else {
|
||
fprintf(fh, "%x", rw.w);
|
||
}
|
||
}
|
||
|
||
|
||
const BOOL GetfString() const {return fString;}
|
||
const WORD GetW() const {return rw.w;}
|
||
void SetW(WORD w) {if (fString) {delete prs; fString = FALSE;}rw.w = w;}
|
||
const WCHAR *GetString() const {return prs->GetString();}
|
||
const int GetLength() const {return prs->GetLength();}
|
||
const int GetWords() const {return fString ? prs->GetWords() : 0;}
|
||
|
||
|
||
HRESULT ReadBinFFFFZ(Scanner *pmf) {
|
||
rvFree();
|
||
fString = *(WORD*)pmf->GetRead() != 0xffff;
|
||
if (fString) {
|
||
prs = new ResourceString;
|
||
OK(prs->ReadBinZ(pmf));
|
||
} else {
|
||
OK(pmf->Advance(sizeof(WORD)));
|
||
OK(rw.ReadBin(pmf));
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBinFFFFZ() const {
|
||
return fString ? prs->cbBinZ() : rw.cbBin() + sizeof(WORD);
|
||
}
|
||
|
||
HRESULT CopyBinFFFFZ(BYTE **ppb) const {
|
||
if (fString) {
|
||
return prs->CopyBinZ(ppb);
|
||
} else {
|
||
*(WORD*)*ppb = 0xFFFF; // Mark as value
|
||
(*ppb) += sizeof(WORD);
|
||
return rw.CopyBin(ppb);
|
||
}
|
||
}
|
||
|
||
HRESULT ReadBinFFFFL(Scanner *pmf) {
|
||
rvFree();
|
||
fString = *(WORD*)pmf->GetRead() != 0xffff;
|
||
if (fString) {
|
||
prs = new ResourceString;
|
||
OK(prs->ReadBinL(pmf));
|
||
} else {
|
||
OK(pmf->Advance(sizeof(WORD)));
|
||
OK(rw.ReadBin(pmf));
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
size_t cbBinFFFFL() const {
|
||
return fString ? prs->cbBinL() : rw.cbBin() + sizeof(WORD);
|
||
}
|
||
|
||
HRESULT CopyBinFFFFL(BYTE **ppb) const {
|
||
if (fString) {
|
||
return prs->CopyBinL(ppb);
|
||
} else {
|
||
*(WORD*)*ppb = 0xFFFF; // Mark as value
|
||
(*ppb) += sizeof(WORD);
|
||
return rw.CopyBin(ppb);
|
||
}
|
||
}
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
rvFree();
|
||
fString = *(char*)pmf->GetRead() == '\"';
|
||
if (fString) {
|
||
prs = new ResourceString;
|
||
OK(prs->ReadTok(pmf));
|
||
} else {
|
||
OK(rw.ReadTok(pmf));
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
if (fString) {
|
||
OK(prs->WriteTok(pmf));
|
||
} else {
|
||
OK(rw.WriteTok(pmf));
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT ReadWin32ResDirEntry(
|
||
Scanner *pmf,
|
||
const BYTE *pRsrc,
|
||
IMAGE_RESOURCE_DIRECTORY_ENTRY *pirde) {
|
||
|
||
rvFree();
|
||
fString = pirde->NameIsString;
|
||
|
||
if (fString) {
|
||
prs = new ResourceString;
|
||
OK(pmf->SetRead(pRsrc + pirde->NameOffset));
|
||
OK(prs->ReadBinL(pmf));
|
||
} else {
|
||
OK(pmf->SetRead((BYTE*)&pirde->Id));
|
||
OK(rw.ReadBin(pmf));
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
bool operator< (const ResourceVariant &rv) const {
|
||
|
||
int l,c;
|
||
|
||
if (fString != rv.GetfString()) {
|
||
|
||
return !fString; // Numerics before strings
|
||
|
||
} else if (!fString) {
|
||
|
||
return rw.w < rv.GetW();
|
||
|
||
} else {
|
||
|
||
l = prs->GetLength();
|
||
if (l > rv.GetLength()) {
|
||
l = rv.GetLength();
|
||
}
|
||
|
||
c = wcsncmp(prs->GetString(), rv.GetString(), l);
|
||
|
||
if (c==0) {
|
||
return prs->GetLength() < rv.GetLength();
|
||
} else {
|
||
return c < 0;
|
||
}
|
||
}
|
||
|
||
return FALSE; // Equal at all depths
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ResourceKey
|
||
//
|
||
// The resource key is the unique identifier of a resource, containing
|
||
// a resource type, a programmer defined unique id for the resource, and
|
||
// a language identifier.
|
||
|
||
|
||
class ResourceKey {
|
||
|
||
public:
|
||
|
||
int iDepth;
|
||
ResourceVariant *prvId[3];
|
||
|
||
ResourceKey() {iDepth=0;}
|
||
|
||
ResourceKey& operator= (const ResourceKey &rk) {
|
||
int i;
|
||
iDepth = rk.iDepth;
|
||
for (i=0; i<iDepth; i++) {
|
||
prvId[i] = new ResourceVariant(*rk.prvId[i]);
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
ResourceKey(const ResourceKey& rk) {
|
||
*this = rk;
|
||
}
|
||
|
||
void fprint(FILE *fh) const {
|
||
|
||
prvId[0]->fprint(fh);
|
||
fprintf(fh, ",");
|
||
prvId[1]->fprint(fh);
|
||
fprintf(fh, ",");
|
||
prvId[2]->fprint(fh);
|
||
}
|
||
|
||
|
||
LPCWSTR GetResName(int i) const {
|
||
if (i >= iDepth) {
|
||
return (LPCWSTR) 0;
|
||
}
|
||
if (prvId[i]->GetfString()) {
|
||
return prvId[i]->GetString();
|
||
} else {
|
||
return (LPCWSTR)prvId[i]->GetW();
|
||
}
|
||
}
|
||
|
||
|
||
HRESULT SetLanguage(WORD lid) {
|
||
|
||
ASSERT(iDepth == 3);
|
||
ASSERT(prvId[2]->GetfString() == FALSE);
|
||
prvId[2]->SetW(lid);
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
prvId[0] = new ResourceVariant;
|
||
ASSERT(prvId[0] != NULL);
|
||
OK(prvId[0]->ReadTok(pmf));
|
||
iDepth = 1;
|
||
while (*(char*)pmf->GetRead() == ',') {
|
||
OK(pmf->Advance(1));
|
||
prvId[iDepth] = new ResourceVariant;
|
||
ASSERT(prvId[iDepth] != NULL);
|
||
OK(prvId[iDepth]->ReadTok(pmf));
|
||
iDepth++;
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
int i;
|
||
OK(prvId[0]->WriteTok(pmf));
|
||
for (i=1; i<iDepth; i++) {
|
||
OK(pmf->WriteS(","));
|
||
OK(prvId[i]->WriteTok(pmf));
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
bool operator< (const ResourceKey &rk) const {
|
||
int i,l,c;
|
||
|
||
if (iDepth != rk.iDepth) {
|
||
return iDepth < rk.iDepth; // Lower depths come first
|
||
} else {
|
||
for (i=0; i<iDepth; i++) {
|
||
if (prvId[i]->GetfString() != rk.prvId[i]->GetfString()) {
|
||
return prvId[i]->GetfString() ? true : false; // Strings come before values
|
||
} else {
|
||
if (prvId[i]->GetfString()) {
|
||
// Compare strings
|
||
l = prvId[i]->GetLength();
|
||
if (l > rk.prvId[i]->GetLength()) {
|
||
l = rk.prvId[i]->GetLength();
|
||
}
|
||
c = wcsncmp(prvId[i]->GetString(), rk.prvId[i]->GetString(), l);
|
||
if (c == 0) {
|
||
if (prvId[i]->GetLength() != rk.prvId[i]->GetLength()) {
|
||
return prvId[i]->GetLength() < rk.prvId[i]->GetLength();
|
||
}
|
||
} else {
|
||
return c < 0;
|
||
}
|
||
} else {
|
||
// Compare numeric values
|
||
if (prvId[i]->GetW() != rk.prvId[i]->GetW()) {
|
||
return prvId[i]->GetW() < rk.prvId[i]->GetW();
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
return FALSE; // Equal at all depths
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ResourceBinary
|
||
//
|
||
// Arbitrary binary resource
|
||
//
|
||
// Formatted as lines of hex digits
|
||
|
||
|
||
class ResourceBinary : public Resource {
|
||
|
||
protected: // Accessed by ResourceHexDump
|
||
|
||
BYTE *pb;
|
||
DWORD dwLength;
|
||
|
||
void rbFree() {if (pb) {delete[] pb; pb=NULL;}dwLength = 0;}
|
||
|
||
public:
|
||
|
||
ResourceBinary() {pb = NULL; dwLength = 0;}
|
||
~ResourceBinary() {rbFree();}
|
||
|
||
DWORD GetLength() const {return dwLength;}
|
||
|
||
HRESULT ReadTok(TextScanner &mfText) {
|
||
DWORD i;
|
||
DWORD dwOffset;
|
||
DWORD dwCheckOffset;
|
||
|
||
rbFree();
|
||
|
||
OK(mfText.Expect("Hex;"));
|
||
OK(mfText.ReadHex(&dwLength));
|
||
|
||
pb = new BYTE[dwLength];
|
||
ASSERT(pb != NULL);
|
||
|
||
if (dwLength <= MAXHEXLINELEN) {
|
||
|
||
// Hex follows on same line
|
||
|
||
OK(mfText.Expect(":"));
|
||
for (i=0; i<dwLength; i++) {
|
||
OK(mfText.ReadHexByte(pb+i));
|
||
}
|
||
|
||
} else {
|
||
|
||
// Hex follows on subsequent lines
|
||
|
||
dwOffset = 0;
|
||
while (dwLength - dwOffset > MAXHEXLINELEN) {
|
||
OK(mfText.ExpectLn(" "));
|
||
OK(mfText.ReadHex(&dwCheckOffset));
|
||
ASSERT(dwOffset == dwCheckOffset);
|
||
OK(mfText.Expect(":"));
|
||
for (i=0; i<MAXHEXLINELEN; i++) {
|
||
OK(mfText.ReadHexByte(pb+dwOffset+i));
|
||
}
|
||
dwOffset += MAXHEXLINELEN;
|
||
}
|
||
|
||
OK(mfText.ExpectLn(" "));
|
||
OK(mfText.ReadHex(&dwCheckOffset));
|
||
ASSERT(dwOffset == dwCheckOffset);
|
||
OK(mfText.Expect(":"));
|
||
for (i=0; i<dwLength - dwOffset; i++) {
|
||
OK(mfText.ReadHexByte(pb+dwOffset+i));
|
||
}
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT ReadBin(Scanner &mfText, DWORD dwLen) {
|
||
rbFree();
|
||
dwLength = dwLen;
|
||
pb = new BYTE[dwLength];
|
||
memcpy(pb, mfText.GetRead(), dwLength);
|
||
OK(mfText.Advance(dwLen));
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT WriteTok(NewFile &nfText) const {
|
||
|
||
DWORD dwOffset;
|
||
|
||
|
||
// Write binary resource in lines of up to 256 bytes
|
||
|
||
OK(nfText.WriteS("Hex;"));
|
||
OK(nfText.WriteHex(dwLength, 8));
|
||
|
||
|
||
if (dwLength <= MAXHEXLINELEN) {
|
||
|
||
// Write <= MAXHEXLINELEN bytes on same line
|
||
|
||
OK(nfText.WriteS(":"));
|
||
OK(nfText.WriteHexBuffer(pb, dwLength));
|
||
|
||
} else {
|
||
|
||
// write MAXHEXLINELEN bytes per line on subsequent lines
|
||
|
||
dwOffset = 0;
|
||
while (dwLength - dwOffset > MAXHEXLINELEN) {
|
||
OK(nfText.WriteS("\r\n "));
|
||
OK(nfText.WriteHex(dwOffset, 8));
|
||
OK(nfText.WriteS(":"));
|
||
OK(nfText.WriteHexBuffer(pb+dwOffset, MAXHEXLINELEN));
|
||
dwOffset += MAXHEXLINELEN;
|
||
}
|
||
|
||
// Write remaining bytes, if any
|
||
|
||
OK(nfText.WriteS("\r\n "));
|
||
OK(nfText.WriteHex(dwOffset, 8));
|
||
OK(nfText.WriteS(":"));
|
||
OK(nfText.WriteHexBuffer(pb+dwOffset, dwLength - dwOffset));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
size_t cbBin() const {
|
||
return dwLength;
|
||
}
|
||
|
||
HRESULT CopyBin(BYTE **ppb) const {
|
||
if (dwLength > 0) {
|
||
memcpy(*ppb, pb, dwLength);
|
||
*ppb += dwLength;
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
int GetItems() const {
|
||
return 0;
|
||
}
|
||
|
||
int GetWords() const {
|
||
return 0;
|
||
}
|
||
|
||
|
||
BOOL CompareBin(const BYTE *pbComp, DWORD dwLen) const {
|
||
|
||
if (dwLength != dwLen) return FALSE;
|
||
if (dwLength == 0) return TRUE;
|
||
if (pb ==pbComp) return true;
|
||
|
||
return !memcmp(pb, pbComp, dwLength);
|
||
}
|
||
|
||
};
|
||
|
||
|
||
|
||
|
||
//// ResourceHexDump
|
||
//
|
||
// Special version of ResourceBinary for generating a hex dump analysis
|
||
|
||
|
||
class ResourceHexDump : public ResourceBinary {
|
||
|
||
public:
|
||
HRESULT WriteTok(NewFile &nfText) const {
|
||
DWORD i,j;
|
||
ResourceDWORD rdw;
|
||
|
||
OK(nfText.WriteS("Hexdump,"));
|
||
OK(nfText.WriteHex(dwLength, 8));
|
||
OK(nfText.WriteS(":"));
|
||
for (i=0; i<dwLength; i++) {
|
||
if (i % 4 == 0) {
|
||
OK(nfText.WriteS(" "));
|
||
}
|
||
if (i % 8 == 0) {
|
||
OK(nfText.WriteS(" "));
|
||
}
|
||
if (i % 16 == 0) {
|
||
if (i>0) {
|
||
// Append ASCII interpretation
|
||
for (j=i-16; j<i; j++) {
|
||
if (pb[j] > 31) {
|
||
OK(nfText.WriteBytes(pb+j, 1));
|
||
} else {
|
||
OK(nfText.WriteS("."));
|
||
}
|
||
}
|
||
}
|
||
OK(nfText.WriteS("\r\n "));
|
||
rdw.dw = i; OK(rdw.WriteTok(&nfText));
|
||
OK(nfText.WriteS(": "));
|
||
}
|
||
OK(nfText.WriteHex(pb[i], 2));
|
||
OK(nfText.WriteS(" "));
|
||
}
|
||
|
||
// Append ANSI interpretation to last line
|
||
|
||
if (dwLength % 16 > 0) {
|
||
for (i = dwLength % 16 ; i < 16; i++) {
|
||
if (i % 4 == 0) {
|
||
OK(nfText.WriteS(" "));
|
||
}
|
||
if (i % 8 == 0) {
|
||
OK(nfText.WriteS(" "));
|
||
}
|
||
OK(nfText.WriteS(" "));
|
||
}
|
||
}
|
||
OK(nfText.WriteS(" "));
|
||
|
||
for (j=dwLength-1 & 0xfffffff0; j<dwLength; j++) {
|
||
if (pb[j] > 31) {
|
||
OK(nfText.WriteBytes(pb+j, 1));
|
||
} else {
|
||
OK(nfText.WriteS("."));
|
||
}
|
||
}
|
||
|
||
OK(nfText.WriteLn());
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// Menu32
|
||
//
|
||
//
|
||
|
||
|
||
class MenuItem32 {
|
||
|
||
ResourceDWORD rdwType;
|
||
ResourceDWORD rdwState;
|
||
ResourceDWORD rdwId; // Extended ID
|
||
ResourceWORD rwId; // Non-extended ID
|
||
ResourceWORD rwFlags;
|
||
ResourceDWORD rdwHelpId;
|
||
ResourceString rsCaption;
|
||
|
||
BOOL fExtended;
|
||
|
||
public:
|
||
|
||
void SetExtended(BOOL f) {fExtended = f;}
|
||
int GetWords() const {return rsCaption.GetWords();}
|
||
|
||
virtual HRESULT ReadTok(TextScanner &mfText) {
|
||
|
||
if (!fExtended) {
|
||
OK(rwFlags.ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
if (!(rwFlags.w & MF_POPUP)) {
|
||
OK(rwId .ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
}
|
||
} else {
|
||
OK(rdwType .ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
OK(rdwState .ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
OK(rdwId .ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
OK(rwFlags .ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
if (rwFlags.w & 1) {
|
||
OK(rdwHelpId.ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
}
|
||
}
|
||
|
||
OK(rsCaption.ReadTok(&mfText));
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT ReadBin(Scanner &mfBin) {
|
||
|
||
const BYTE *pb; // For tracking
|
||
|
||
pb = mfBin.GetRead();
|
||
|
||
if (!fExtended) {
|
||
OK(rwFlags.ReadBin(&mfBin));
|
||
if (!(rwFlags.w & MF_POPUP)) {
|
||
OK(rwId .ReadBin(&mfBin));
|
||
}
|
||
} else {
|
||
OK(rdwType .ReadBin(&mfBin));
|
||
OK(rdwState.ReadBin(&mfBin));
|
||
OK(rdwId .ReadBin(&mfBin));
|
||
OK(rwFlags .ReadBin(&mfBin));
|
||
}
|
||
|
||
OK(rsCaption.ReadBinZ(&mfBin));
|
||
|
||
if (fExtended && rwFlags.w & 1) {
|
||
|
||
OK(mfBin.Align(pb, 4));
|
||
|
||
OK(rdwHelpId.ReadBin(&mfBin));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT WriteTok(NewFile &nfText) const {
|
||
|
||
if (!fExtended) {
|
||
OK(rwFlags.WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
if (!(rwFlags.w & MF_POPUP)) {
|
||
OK(rwId .WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
}
|
||
} else {
|
||
OK(rdwType .WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
OK(rdwState .WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
OK(rdwId .WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
OK(rwFlags .WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
if (rwFlags.w & 1) {
|
||
OK(rdwHelpId.WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
}
|
||
}
|
||
|
||
OK(rsCaption.WriteTok(&nfText));
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
virtual size_t cbBin() const {
|
||
|
||
size_t cb;
|
||
|
||
if (!fExtended) {
|
||
|
||
cb = rwFlags.cbBin()
|
||
+ rsCaption.cbBinZ();
|
||
|
||
if (!(rwFlags.w & MF_POPUP)) {
|
||
cb += rwId.cbBin();
|
||
}
|
||
|
||
} else {
|
||
|
||
cb = rdwType.cbBin()
|
||
+ rdwState.cbBin()
|
||
+ rdwId.cbBin()
|
||
+ rwFlags.cbBin()
|
||
+ rsCaption.cbBinZ();
|
||
|
||
if (rwFlags.w & 1) {
|
||
|
||
cb = cb + 3 & ~3;
|
||
cb += rdwHelpId.cbBin();
|
||
}
|
||
}
|
||
|
||
return cb;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT CopyBin (BYTE **ppb) const {
|
||
|
||
const BYTE * pb;
|
||
|
||
pb = *ppb;
|
||
|
||
if (!fExtended) {
|
||
OK(rwFlags.CopyBin(ppb));
|
||
if (!(rwFlags.w & MF_POPUP)) {
|
||
OK(rwId .CopyBin(ppb));
|
||
}
|
||
} else {
|
||
OK(rdwType .CopyBin(ppb));
|
||
OK(rdwState.CopyBin(ppb));
|
||
OK(rdwId .CopyBin(ppb));
|
||
OK(rwFlags .CopyBin(ppb));
|
||
}
|
||
|
||
OK(rsCaption.CopyBinZ(ppb));
|
||
|
||
if (fExtended && rwFlags.w & 1) {
|
||
|
||
while (*ppb - pb & 3) {
|
||
**ppb = 0;
|
||
(*ppb)++;
|
||
}
|
||
|
||
OK(rdwHelpId.CopyBin(ppb));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
class Menu32 : public Resource {
|
||
|
||
ResourceWORD rwVer;
|
||
ResourceWORD rwHdrSize;
|
||
ResourceBinary rbHeader;
|
||
MenuItem32 *pMnuItm;
|
||
DWORD cItems;
|
||
BOOL fExtended;
|
||
|
||
|
||
public:
|
||
virtual HRESULT ReadTok(TextScanner &mfText) {
|
||
|
||
DWORD i, iItem;
|
||
|
||
OK(mfText.Expect("Mnu32"));
|
||
fExtended = *(char*)mfText.GetRead() == 'X';
|
||
if (fExtended) {
|
||
OK(mfText.Expect("X;"));
|
||
} else {
|
||
OK(mfText.Expect("N;"));
|
||
}
|
||
|
||
OK(rwVer .ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
OK(rwHdrSize.ReadTok(&mfText)); OK(mfText.Expect(","));
|
||
if (fExtended && rwHdrSize.w > 0) {
|
||
OK(rbHeader.ReadTok(mfText)); OK(mfText.Expect(","));
|
||
}
|
||
OK(mfText.ReadHex(&cItems)); OK(mfText.Expect(":"));
|
||
|
||
pMnuItm = new MenuItem32 [cItems];
|
||
ASSERT(pMnuItm != NULL);
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
OK(mfText.ExpectLn(" ")); OK(mfText.ReadHex(&iItem));
|
||
ASSERT(i == iItem);
|
||
pMnuItm[i].SetExtended(fExtended);
|
||
OK(mfText.Expect(";")); OK(pMnuItm[i].ReadTok(mfText));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT ReadBin(Scanner &mfBin, DWORD dwLen) {
|
||
|
||
const BYTE *pb; // For tracking
|
||
MenuItem32 mi; // For counting menu items
|
||
const BYTE *pbFirstItem;
|
||
int i;
|
||
|
||
cItems = 0;
|
||
pb = mfBin.GetRead();
|
||
|
||
OK(rwVer .ReadBin(&mfBin));
|
||
OK(rwHdrSize.ReadBin(&mfBin));
|
||
|
||
ASSERT(rwVer.w == 0 || rwVer.w == 1);
|
||
fExtended = rwVer.w;
|
||
|
||
if (fExtended && rwHdrSize.w > 0) {
|
||
rbHeader.ReadBin(mfBin, rwHdrSize.w);
|
||
}
|
||
|
||
|
||
ASSERT(mfBin.GetRead() - pb < dwLen);
|
||
|
||
|
||
// Count menu items
|
||
|
||
if (fExtended) {
|
||
OK(mfBin.Align(pb, 4));
|
||
}
|
||
|
||
pbFirstItem = mfBin.GetRead();
|
||
mi.SetExtended(fExtended);
|
||
while (mfBin.GetRead() - pb < dwLen) {
|
||
|
||
OK(mi.ReadBin(mfBin));
|
||
cItems++;
|
||
|
||
if (fExtended) {
|
||
OK(mfBin.Align(pb, 4));
|
||
}
|
||
}
|
||
|
||
pMnuItm = new MenuItem32 [cItems];
|
||
ASSERT(pMnuItm != NULL);
|
||
|
||
|
||
// Record the menus
|
||
|
||
OK(mfBin.SetRead(pbFirstItem));
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
if (fExtended) {
|
||
OK(mfBin.Align(pb, 4));
|
||
}
|
||
|
||
pMnuItm[i].SetExtended(fExtended);
|
||
OK(pMnuItm[i].ReadBin(mfBin));
|
||
}
|
||
|
||
|
||
ASSERT(mfBin.GetRead() - pb <= dwLen);
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT WriteTok(NewFile &nfText) const {
|
||
|
||
DWORD i;
|
||
|
||
OK(nfText.WriteS(fExtended ? "Mnu32X;": "Mnu32N;"));
|
||
|
||
OK(rwVer .WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
OK(rwHdrSize.WriteTok(&nfText)); OK(nfText.WriteS(","));
|
||
if (fExtended && rwHdrSize.w > 0) {
|
||
OK(rbHeader.WriteTok(nfText)); OK(nfText.WriteS(","));
|
||
}
|
||
OK(nfText.WriteHex(cItems,4)); OK(nfText.WriteS(":"));
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
OK(nfText.WriteS("\r\n "));
|
||
OK(nfText.WriteHex(i, 4));
|
||
OK(nfText.WriteS(";"));
|
||
OK(pMnuItm[i].WriteTok(nfText));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
virtual size_t cbBin() const {
|
||
int i;
|
||
size_t cb;
|
||
|
||
cb = rwVer.cbBin()
|
||
+ rwHdrSize.cbBin();
|
||
|
||
if (fExtended && rwHdrSize.w > 0) {
|
||
cb += rbHeader.cbBin();
|
||
}
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
if (fExtended) {
|
||
cb = cb + 3 & ~3;
|
||
}
|
||
|
||
cb += pMnuItm[i].cbBin();
|
||
}
|
||
|
||
return cb;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT CopyBin (BYTE **ppb) const {
|
||
|
||
const BYTE *pb; // For tracking
|
||
int i;
|
||
|
||
pb = *ppb;
|
||
|
||
OK(rwVer .CopyBin(ppb));
|
||
OK(rwHdrSize.CopyBin(ppb));
|
||
|
||
if (fExtended && rwHdrSize.w > 0) {
|
||
rbHeader.CopyBin(ppb);
|
||
}
|
||
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
if (fExtended) {
|
||
while (*ppb - pb & 3) {
|
||
**ppb = 0;
|
||
(*ppb)++;
|
||
}
|
||
}
|
||
|
||
OK(pMnuItm[i].CopyBin(ppb));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
int GetItems() const {
|
||
return cItems;
|
||
}
|
||
|
||
int GetWords() const {
|
||
int i;
|
||
int wc;
|
||
|
||
wc = 0;
|
||
for (i=0; i<cItems; i++) {
|
||
wc += pMnuItm[i].GetWords();
|
||
}
|
||
|
||
return wc;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// String32
|
||
//
|
||
// Strings are represented as a sequence of WCHARS, each string
|
||
// preceeded by its length. Each resource contains 16 strings.
|
||
|
||
|
||
class String32 : public Resource {
|
||
|
||
ResourceString rs[16];
|
||
DWORD cStrings;
|
||
DWORD cNonEmpty;
|
||
|
||
public:
|
||
virtual HRESULT ReadTok(TextScanner &mfText) {
|
||
|
||
DWORD i, iString, cLoaded;
|
||
|
||
OK(mfText.Expect("Str;"));
|
||
OK(mfText.ReadHex(&cStrings));
|
||
OK(mfText.Expect(","));
|
||
OK(mfText.ReadHex(&cNonEmpty));
|
||
OK(mfText.Expect(":"));
|
||
|
||
ASSERT(cStrings == 16);
|
||
ASSERT(cNonEmpty <= cStrings);
|
||
|
||
i=0;
|
||
cLoaded = 0;
|
||
while (cLoaded < cNonEmpty) {
|
||
|
||
OK(mfText.ExpectLn(" "));
|
||
OK(mfText.ReadHex(&iString));
|
||
OK(mfText.Expect(":"));
|
||
ASSERT(iString >= i);
|
||
ASSERT(iString < cStrings);
|
||
while (i<iString) {
|
||
rs[i].SetEmpty();
|
||
i++;
|
||
}
|
||
OK(rs[i].ReadTok(&mfText));
|
||
i++;
|
||
cLoaded++;
|
||
}
|
||
|
||
while (i<cStrings) {
|
||
rs[i].SetEmpty();
|
||
i++;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT ReadBin(Scanner &mfBin, DWORD dwLen) {
|
||
|
||
const BYTE *pb; // For tracking
|
||
|
||
cStrings = 0;
|
||
cNonEmpty = 0;
|
||
pb = mfBin.GetRead();
|
||
|
||
while ( cStrings < 16
|
||
&& mfBin.GetRead() - pb < dwLen) {
|
||
|
||
rs[cStrings].ReadBinL(&mfBin);
|
||
if (rs[cStrings].GetLength() > 0) {
|
||
cNonEmpty++;
|
||
}
|
||
cStrings++;
|
||
}
|
||
|
||
ASSERT(mfBin.GetRead() - pb <= dwLen);
|
||
ASSERT(cStrings == 16);
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT WriteTok(NewFile &nfText) const {
|
||
|
||
int i;
|
||
|
||
ASSERT(cStrings <= 16);
|
||
|
||
OK(nfText.WriteS("Str;"));
|
||
OK(nfText.WriteHex(cStrings, 2));
|
||
OK(nfText.WriteS(","));
|
||
OK(nfText.WriteHex(cNonEmpty, 2));
|
||
OK(nfText.WriteS(":"));
|
||
|
||
|
||
for (i=0; i<cStrings; i++) {
|
||
if (rs[i].GetLength() > 0) {
|
||
OK(nfText.WriteS("\r\n "));
|
||
OK(nfText.WriteHex(i, 1));
|
||
OK(nfText.WriteS(":"));
|
||
OK(rs[i].WriteTok(&nfText));
|
||
}
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
virtual size_t cbBin() const {
|
||
int i;
|
||
size_t cb;
|
||
|
||
cb = 0;
|
||
|
||
for (i=0; i<cStrings; i++) {
|
||
cb += rs[i].cbBinL();
|
||
}
|
||
|
||
return cb;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT CopyBin (BYTE **ppb) const {
|
||
int i;
|
||
|
||
for (i=0; i<cStrings; i++) {
|
||
OK(rs[i].CopyBinL(ppb));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
int GetItems() const {
|
||
return cNonEmpty;
|
||
}
|
||
|
||
int GetWords() const {
|
||
|
||
int i, wc;
|
||
|
||
wc = 0;
|
||
for (i=0; i<cStrings; i++) {
|
||
wc += rs[i].GetWords();
|
||
}
|
||
|
||
return wc;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
class DialogHeader32 {
|
||
|
||
BOOL fExtended;
|
||
|
||
ResourceDWORD rdwStyle;
|
||
ResourceDWORD rdwSignature;
|
||
ResourceDWORD rdwHelpId;
|
||
ResourceDWORD rdwExStyle;
|
||
ResourceWORD rwcDit; // Count of dialog items
|
||
ResourceWORD rwX;
|
||
ResourceWORD rwY;
|
||
ResourceWORD rwCx;
|
||
ResourceWORD rwCy;
|
||
ResourceVariant rvMenu;
|
||
ResourceVariant rvClass;
|
||
ResourceVariant rvTitle;
|
||
ResourceWORD rwPointSize;
|
||
ResourceWORD rwWeight;
|
||
ResourceBYTE rbItalic;
|
||
ResourceBYTE rbCharSet;
|
||
ResourceString rsFaceName;
|
||
|
||
public:
|
||
|
||
WORD GetItemCount() const {return rwcDit.w;}
|
||
BOOL GetExtended() const {return fExtended;}
|
||
int GetWords() const {return rvTitle.GetWords();}
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
|
||
OK(rwcDit .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
|
||
OK(rdwStyle .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rdwExStyle .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rdwSignature.ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rdwHelpId .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwX .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwY .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwCx .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwCy .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rvMenu .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rvClass .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rvTitle .ReadTok(pmf));
|
||
if (rdwStyle.dw & DS_SETFONT) {
|
||
OK(pmf->Expect(","));
|
||
OK(rwPointSize.ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwWeight .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rbItalic .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rbCharSet .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rsFaceName .ReadTok(pmf));
|
||
}
|
||
|
||
fExtended = rdwSignature.dw != 0;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
HRESULT ReadBin(Scanner *pmf) {
|
||
|
||
OK(rdwSignature.ReadBin(pmf));
|
||
|
||
fExtended = HIWORD(rdwSignature.dw) == 0xFFFF;
|
||
if (!fExtended) {
|
||
|
||
rdwStyle.dw = rdwSignature.dw;
|
||
OK(rdwExStyle.ReadBin(pmf));
|
||
rdwSignature.dw = 0;
|
||
rdwHelpId.dw = 0;
|
||
|
||
} else {
|
||
|
||
// Extended dialog adds signature and HelpID
|
||
OK(rdwHelpId.ReadBin(pmf));
|
||
OK(rdwExStyle.ReadBin(pmf));
|
||
OK(rdwStyle.ReadBin(pmf));
|
||
}
|
||
|
||
|
||
OK(rwcDit .ReadBin(pmf));
|
||
OK(rwX .ReadBin(pmf));
|
||
OK(rwY .ReadBin(pmf));
|
||
OK(rwCx .ReadBin(pmf));
|
||
OK(rwCy .ReadBin(pmf));
|
||
OK(rvMenu .ReadBinFFFFZ(pmf));
|
||
OK(rvClass .ReadBinFFFFZ(pmf));
|
||
OK(rvTitle .ReadBinFFFFZ(pmf));
|
||
if (rdwStyle.dw & DS_SETFONT) {
|
||
OK(rwPointSize.ReadBin(pmf));
|
||
if (!fExtended) {
|
||
rwWeight.w = 0;
|
||
rbItalic.b = 0;
|
||
rbCharSet.b = 0;
|
||
} else {
|
||
OK(rwWeight .ReadBin(pmf));
|
||
OK(rbItalic .ReadBin(pmf));
|
||
OK(rbCharSet .ReadBin(pmf));
|
||
}
|
||
OK(rsFaceName .ReadBinZ(pmf));
|
||
}
|
||
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
size_t cbBin() const {
|
||
size_t cb;
|
||
cb = rdwStyle .cbBin() // Basics for all dialogs
|
||
+ rdwExStyle .cbBin()
|
||
+ rwcDit .cbBin()
|
||
+ rwX .cbBin()
|
||
+ rwY .cbBin()
|
||
+ rwCx .cbBin()
|
||
+ rwCy .cbBin()
|
||
+ rvMenu .cbBinFFFFZ()
|
||
+ rvClass .cbBinFFFFZ()
|
||
+ rvTitle .cbBinFFFFZ();
|
||
|
||
if (rdwStyle.dw & DS_SETFONT) { // Facname additions
|
||
cb += rwPointSize .cbBin()
|
||
+ rsFaceName .cbBinZ();
|
||
}
|
||
|
||
if (fExtended) { // Extended dialog addtions
|
||
cb += rdwSignature .cbBin()
|
||
+ rdwHelpId .cbBin();
|
||
|
||
if (rdwStyle.dw & DS_SETFONT) {
|
||
cb += rwWeight .cbBin()
|
||
+ rbItalic .cbBin()
|
||
+ rbCharSet .cbBin();
|
||
}
|
||
}
|
||
|
||
return cb;
|
||
}
|
||
|
||
|
||
|
||
HRESULT CopyBin(BYTE **ppb) const {
|
||
|
||
BYTE *pbOriginal;
|
||
|
||
pbOriginal = *ppb;
|
||
|
||
if (!fExtended) {
|
||
|
||
OK(rdwStyle .CopyBin(ppb));
|
||
OK(rdwExStyle.CopyBin(ppb));
|
||
|
||
} else {
|
||
|
||
OK(rdwSignature.CopyBin(ppb));
|
||
OK(rdwHelpId .CopyBin(ppb));
|
||
OK(rdwExStyle .CopyBin(ppb));
|
||
OK(rdwStyle .CopyBin(ppb));
|
||
}
|
||
OK(rwcDit .CopyBin(ppb));
|
||
OK(rwX .CopyBin(ppb));
|
||
OK(rwY .CopyBin(ppb));
|
||
OK(rwCx .CopyBin(ppb));
|
||
OK(rwCy .CopyBin(ppb));
|
||
OK(rvMenu .CopyBinFFFFZ(ppb));
|
||
OK(rvClass .CopyBinFFFFZ(ppb));
|
||
OK(rvTitle .CopyBinFFFFZ(ppb));
|
||
if (rdwStyle.dw & DS_SETFONT) {
|
||
OK(rwPointSize.CopyBin(ppb));
|
||
if (fExtended) {
|
||
OK(rwWeight .CopyBin(ppb));
|
||
OK(rbItalic .CopyBin(ppb));
|
||
OK(rbCharSet.CopyBin(ppb));
|
||
}
|
||
OK(rsFaceName .CopyBinZ(ppb));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
|
||
OK(rwcDit .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
|
||
OK(rdwStyle .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rdwExStyle .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rdwSignature.WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rdwHelpId .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwX .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwY .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwCx .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwCy .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rvMenu .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rvClass .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rvTitle .WriteTok(pmf));
|
||
if (rdwStyle.dw & DS_SETFONT) {
|
||
OK(pmf->WriteS(","));
|
||
OK(rwPointSize.WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwWeight .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rbItalic .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rbCharSet .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rsFaceName .WriteTok(pmf));
|
||
}
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
class DialogItem32 {
|
||
|
||
BOOL fExtended;
|
||
|
||
ResourceDWORD rdwStyle;
|
||
ResourceDWORD rdwHelpId;
|
||
ResourceDWORD rdwExStyle;
|
||
ResourceWORD rwX;
|
||
ResourceWORD rwY;
|
||
ResourceWORD rwCx;
|
||
ResourceWORD rwCy;
|
||
ResourceWORD rwId; // Normal
|
||
ResourceDWORD rdwId; // Extended
|
||
ResourceVariant rvClass;
|
||
ResourceVariant rvTitle;
|
||
|
||
ResourceWORD rwcbRawData; // Raw data size (extended only)
|
||
ResourceBinary rbRawData;
|
||
|
||
ResourceWORD rwDummy; // Replaces raw data on normal dialogs
|
||
|
||
public:
|
||
|
||
void SetExtended(BOOL f) {fExtended = f;}
|
||
int GetWords() const {return rvTitle.GetWords();}
|
||
|
||
HRESULT ReadTok(TextScanner *pmf) {
|
||
|
||
if (fExtended) {
|
||
OK(rdwId.ReadTok(pmf)); OK(pmf->Expect(","));
|
||
} else {
|
||
OK(rwId.ReadTok(pmf)); OK(pmf->Expect(","));
|
||
}
|
||
|
||
OK(rdwStyle .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rdwExStyle .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rdwHelpId .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwX .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwY .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwCx .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rwCy .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
|
||
OK(rvClass .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
OK(rvTitle .ReadTok(pmf)); OK(pmf->Expect(","));
|
||
|
||
if (fExtended) {
|
||
|
||
OK(rbRawData.ReadTok(*pmf));
|
||
ASSERT(rbRawData.GetLength() < 0x10000);
|
||
rwcbRawData.w = (WORD)rbRawData.GetLength();
|
||
|
||
} else {
|
||
|
||
OK(rwDummy.ReadTok(pmf));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
HRESULT ReadBin(Scanner *pmf) {
|
||
|
||
if (!fExtended) {
|
||
|
||
OK(rdwStyle.ReadBin(pmf));
|
||
OK(rdwExStyle.ReadBin(pmf));
|
||
rdwHelpId.dw = 0;
|
||
|
||
} else {
|
||
|
||
OK(rdwHelpId.ReadBin(pmf));
|
||
OK(rdwExStyle.ReadBin(pmf));
|
||
OK(rdwStyle.ReadBin(pmf));
|
||
}
|
||
|
||
|
||
OK(rwX .ReadBin(pmf));
|
||
OK(rwY .ReadBin(pmf));
|
||
OK(rwCx.ReadBin(pmf));
|
||
OK(rwCy.ReadBin(pmf));
|
||
|
||
if (fExtended) {
|
||
OK(rdwId.ReadBin(pmf));
|
||
} else {
|
||
OK(rwId.ReadBin(pmf));
|
||
}
|
||
|
||
OK(rvClass.ReadBinFFFFZ(pmf));
|
||
OK(rvTitle.ReadBinFFFFZ(pmf));
|
||
|
||
if (fExtended) {
|
||
|
||
OK(rwcbRawData.ReadBin(pmf));
|
||
OK(rbRawData.ReadBin(*pmf, rwcbRawData.w));
|
||
|
||
} else {
|
||
|
||
OK(rwDummy.ReadBin(pmf));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
size_t cbBin() const {
|
||
size_t cb;
|
||
|
||
cb = rdwStyle .cbBin()
|
||
+ rdwExStyle .cbBin()
|
||
+ rwX .cbBin()
|
||
+ rwY .cbBin()
|
||
+ rwCx .cbBin()
|
||
+ rwCy .cbBin()
|
||
+ rvClass .cbBinFFFFZ()
|
||
+ rvTitle .cbBinFFFFZ();
|
||
|
||
if (!fExtended) {
|
||
cb += rwId .cbBin()
|
||
+ rwDummy .cbBin();
|
||
} else {
|
||
cb += rdwId .cbBin()
|
||
+ rdwHelpId .cbBin()
|
||
+ rbRawData .cbBin()
|
||
+ rwcbRawData .cbBin();
|
||
}
|
||
return cb;
|
||
}
|
||
|
||
|
||
|
||
HRESULT CopyBin(BYTE **ppb) const {
|
||
|
||
BYTE *pbOriginal;
|
||
|
||
pbOriginal = *ppb;
|
||
|
||
if (!fExtended) {
|
||
|
||
OK(rdwStyle.CopyBin(ppb));
|
||
OK(rdwExStyle.CopyBin(ppb));
|
||
|
||
} else {
|
||
|
||
OK(rdwHelpId.CopyBin(ppb));
|
||
OK(rdwExStyle.CopyBin(ppb));
|
||
OK(rdwStyle.CopyBin(ppb));
|
||
}
|
||
|
||
|
||
OK(rwX .CopyBin(ppb));
|
||
OK(rwY .CopyBin(ppb));
|
||
OK(rwCx.CopyBin(ppb));
|
||
OK(rwCy.CopyBin(ppb));
|
||
|
||
if (fExtended) {
|
||
OK(rdwId.CopyBin(ppb));
|
||
} else {
|
||
OK(rwId.CopyBin(ppb));
|
||
}
|
||
|
||
OK(rvClass.CopyBinFFFFZ(ppb));
|
||
OK(rvTitle.CopyBinFFFFZ(ppb));
|
||
|
||
if (fExtended) {
|
||
|
||
OK(rwcbRawData.CopyBin(ppb));
|
||
OK(rbRawData.CopyBin(ppb));
|
||
|
||
} else {
|
||
|
||
OK(rwDummy.CopyBin(ppb));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
HRESULT WriteTok(NewFile *pmf) const {
|
||
|
||
if (fExtended) {
|
||
OK(rdwId.WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
} else {
|
||
OK(rwId.WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
}
|
||
|
||
OK(rdwStyle .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rdwExStyle .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rdwHelpId .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwX .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwY .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwCx .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rwCy .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
|
||
OK(rvClass .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
OK(rvTitle .WriteTok(pmf)); OK(pmf->WriteS(","));
|
||
|
||
if (fExtended) {
|
||
|
||
OK(rbRawData.WriteTok(*pmf));
|
||
|
||
} else {
|
||
|
||
OK(rwDummy.WriteTok(pmf));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// Dialog32
|
||
//
|
||
//
|
||
|
||
|
||
class Dialog32 : public Resource {
|
||
|
||
|
||
DialogHeader32 DlgHdr; // Header
|
||
DialogItem32 *pDlgItm; // Array of items
|
||
|
||
BOOL fExtended;
|
||
int cItems;
|
||
|
||
public:
|
||
|
||
Dialog32() {pDlgItm = NULL;};
|
||
|
||
virtual HRESULT ReadTok(TextScanner &mfText) {
|
||
|
||
DWORD i, dwSeq;
|
||
|
||
OK(mfText.Expect("Dlg32"));
|
||
fExtended = *(char*)mfText.GetRead() == 'X';
|
||
if (fExtended) {
|
||
OK(mfText.Expect("X;"));
|
||
} else {
|
||
OK(mfText.Expect("N;"));
|
||
}
|
||
|
||
OK(DlgHdr.ReadTok(&mfText));
|
||
ASSERT(fExtended == DlgHdr.GetExtended());
|
||
|
||
cItems = DlgHdr.GetItemCount();
|
||
|
||
pDlgItm = new DialogItem32 [cItems];
|
||
ASSERT(pDlgItm != NULL);
|
||
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
OK(mfText.ExpectLn(" "));
|
||
OK(mfText.ReadHex(&dwSeq));
|
||
ASSERT(dwSeq == i+1);
|
||
OK(mfText.Expect(";"));
|
||
|
||
pDlgItm[i].SetExtended(fExtended);
|
||
OK(pDlgItm[i].ReadTok(&mfText));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT WriteTok(NewFile &nfText) const {
|
||
|
||
DWORD i;
|
||
|
||
OK(nfText.WriteS(fExtended ? "Dlg32X;": "Dlg32N;"));
|
||
|
||
OK(DlgHdr.WriteTok(&nfText));
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
OK(nfText.WriteS("\r\n "));
|
||
OK(nfText.WriteHex(i+1, 4));
|
||
OK(nfText.WriteS(";"));
|
||
OK(pDlgItm[i].WriteTok(&nfText));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT ReadBin(Scanner &mfBinary, DWORD dwLen) {
|
||
|
||
const BYTE *pb; // File pointer for tracking alignment
|
||
int i;
|
||
|
||
pb = mfBinary.GetRead();
|
||
|
||
OK(DlgHdr.ReadBin(&mfBinary));
|
||
fExtended = DlgHdr.GetExtended();
|
||
cItems = DlgHdr.GetItemCount();
|
||
|
||
pDlgItm = new DialogItem32 [cItems];
|
||
ASSERT(pDlgItm != NULL);
|
||
|
||
|
||
// Read items
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
OK(mfBinary.Align(pb, 4)); // Advance over any alignment padding
|
||
|
||
pDlgItm[i].SetExtended(fExtended);
|
||
OK(pDlgItm[i].ReadBin(&mfBinary));
|
||
|
||
ASSERT(mfBinary.GetRead() - pb <= dwLen);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
virtual size_t cbBin() const {
|
||
|
||
size_t cb;
|
||
int i;
|
||
|
||
cb = DlgHdr.cbBin();
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
cb = cb + 3 & ~3; // alignment padding
|
||
|
||
cb += pDlgItm[i].cbBin();
|
||
}
|
||
|
||
return cb;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT CopyBin (BYTE **ppb) const {
|
||
|
||
BYTE *pb; // Pointer for tracking alignment
|
||
int i;
|
||
|
||
pb = *ppb;
|
||
|
||
DlgHdr.CopyBin(ppb);
|
||
|
||
for (i=0; i<cItems; i++) {
|
||
|
||
// Insert alignment padding
|
||
|
||
while (*ppb - pb & 3) {
|
||
**ppb = 0;
|
||
(*ppb)++;
|
||
}
|
||
|
||
pDlgItm[i].CopyBin(ppb);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
int GetItems() const {
|
||
return cItems;
|
||
}
|
||
|
||
int GetWords() const {
|
||
|
||
int i, wc;
|
||
|
||
wc = DlgHdr.GetWords();
|
||
for (i=0; i<cItems; i++) {
|
||
wc += pDlgItm[i].GetWords();
|
||
}
|
||
return wc;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
//// VersionInfo
|
||
//
|
||
// The documentation in the Win32 SDK doesn't clearly capture the
|
||
// usage of block headers, or the nesting of blocks in the Version resource.
|
||
//
|
||
// Each block has the following format
|
||
//
|
||
// wLength Total length including key, value and subblocks
|
||
// wValueLength Length of value in bytes or characters according to bText
|
||
// bText Whether value is in bytes or zero terminated WCHARs
|
||
// szKey Zero terminated WCHAR key, padded with zeros to next DWORD boundary
|
||
// Value Size determined by bText and wValueLength, padded to DWORD boundary
|
||
// Sub-blocks Remaining space (if any, up to wLength) is an array of sub blocks
|
||
|
||
|
||
class VersionInfo : public Resource {
|
||
|
||
struct VersionBlock {
|
||
VersionBlock *pNext; // Next block at this level
|
||
VersionBlock *pSub; // First contained subblock
|
||
int iDepth; // Starts at zero
|
||
DWORD cSub; // Number of contained subblocks
|
||
BOOL bValue; // Set if a vlue is present
|
||
ResourceWORD rwbText;
|
||
ResourceString rsKey;
|
||
ResourceString rsValue; // Value when a string
|
||
ResourceBinary rbValue; // Value when bytes
|
||
};
|
||
|
||
|
||
VersionBlock *pvb; // First root level block
|
||
DWORD cBlocks; // Number of root level blocks
|
||
|
||
|
||
|
||
HRESULT ReadBinVersionBlocks(
|
||
Scanner &mfBinary,
|
||
DWORD dwLength, // Length of binary to read
|
||
VersionBlock **ppvb,
|
||
int iDepth,
|
||
DWORD *cSub) {
|
||
|
||
const BYTE *pbBlock;
|
||
const BYTE *pbResource;
|
||
ResourceWORD rwLength;
|
||
WORD wValueLength;
|
||
|
||
|
||
pbResource = mfBinary.GetRead();
|
||
(*cSub) = 0;
|
||
while (mfBinary.GetRead() < pbResource + dwLength) {
|
||
|
||
// Read one version block
|
||
|
||
pbBlock = mfBinary.GetRead();
|
||
OK(rwLength.ReadBin(&mfBinary));
|
||
|
||
ASSERT(pbBlock + rwLength.w <= mfBinary.GetLimit());
|
||
|
||
//OK((*ppvb)->rwValueLength.ReadBin(&mfBinary));
|
||
|
||
wValueLength = *(WORD*)mfBinary.GetRead();
|
||
OK(mfBinary.Advance(2));
|
||
|
||
if (rwLength.w > 0) {
|
||
|
||
// Block is not empty
|
||
|
||
*ppvb = new VersionBlock;
|
||
ASSERT(*ppvb != NULL);
|
||
|
||
(*ppvb)->pNext = NULL;
|
||
(*ppvb)->pSub = NULL;
|
||
(*ppvb)->iDepth = iDepth;
|
||
|
||
OK((*ppvb)->rwbText.ReadBin(&mfBinary));
|
||
OK((*ppvb)->rsKey.ReadBinZ(&mfBinary));
|
||
OK(mfBinary.Align(pbResource, 4));
|
||
|
||
(*ppvb)->bValue = wValueLength > 0;
|
||
|
||
if ((*ppvb)->bValue) {
|
||
|
||
if ((*ppvb)->rwbText.w == 0) {
|
||
|
||
// Binary value
|
||
|
||
OK((*ppvb)->rbValue.ReadBin(mfBinary, wValueLength));
|
||
|
||
} else {
|
||
|
||
// WCHAR string.
|
||
|
||
// Some writers include a zero terminator, some don't.
|
||
// Some incode zero codepoints inside the string
|
||
// Some writers get the length right, some dont.
|
||
// msvcrt20.dll text lengths are too long.
|
||
|
||
// Choose a length that is min(ValueLength, length remaining),
|
||
// and then drop any trailing zeros.
|
||
|
||
// Clip ValueLength to length remaining
|
||
|
||
ASSERT(mfBinary.GetRead() < pbBlock + rwLength.w);
|
||
|
||
if (wValueLength > (pbBlock + rwLength.w - mfBinary.GetRead()) / 2) {
|
||
wValueLength = (pbBlock + rwLength.w - mfBinary.GetRead()) / 2;
|
||
}
|
||
|
||
// Clip trailing zeros
|
||
|
||
while ( wValueLength > 0
|
||
&& ((WCHAR*)mfBinary.GetRead())[wValueLength-1] == 0) {
|
||
wValueLength--;
|
||
}
|
||
|
||
// Extract whatever remains
|
||
|
||
OK((*ppvb)->rsValue.ReadBin(&mfBinary, wValueLength));
|
||
|
||
// Check that there's nothing being lost between the end of
|
||
// the string and the end of the block.
|
||
|
||
// Note that we assume here that blocks containing text values
|
||
// cannot have variety of messes that value text is stored in
|
||
// in exisiting executables.
|
||
|
||
while (mfBinary.GetRead() < pbBlock + rwLength.w) {
|
||
|
||
ASSERT(*(WCHAR*)mfBinary.GetRead() == 0);
|
||
OK(mfBinary.Advance(2));
|
||
}
|
||
}
|
||
OK(mfBinary.Align(pbResource, 4));
|
||
}
|
||
|
||
if (mfBinary.GetRead() - pbBlock < rwLength.w) {
|
||
|
||
ASSERT(mfBinary.GetLimit() > mfBinary.GetRead());
|
||
|
||
// Read subblocks
|
||
|
||
OK(ReadBinVersionBlocks(
|
||
mfBinary,
|
||
rwLength.w - (mfBinary.GetRead() - pbBlock),
|
||
&((*ppvb)->pSub),
|
||
iDepth + 1,
|
||
&(*ppvb)->cSub));
|
||
}
|
||
|
||
if (mfBinary.GetRead() < pbResource + dwLength) {
|
||
|
||
// Prepare to read more blocks at this level
|
||
|
||
ppvb = &((*ppvb)->pNext);
|
||
}
|
||
}
|
||
|
||
(*cSub)++;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
HRESULT WriteTokVersionBlocks(
|
||
NewFile &nfText,
|
||
VersionBlock *pvb) const {
|
||
|
||
while (pvb) {
|
||
|
||
OK(nfText.WriteS("\r\n "));
|
||
OK(nfText.WriteHex(pvb->iDepth, 2));
|
||
OK(nfText.WriteS(","));
|
||
OK(pvb->rsKey.WriteTok(&nfText));
|
||
|
||
if (pvb->bValue) {
|
||
|
||
OK(nfText.WriteS("="));
|
||
|
||
if (pvb->rwbText.w == 0) {
|
||
|
||
OK(pvb->rbValue.WriteTok(nfText)); // Binary value
|
||
|
||
} else {
|
||
|
||
OK(pvb->rsValue.WriteTok(&nfText)); // String value
|
||
|
||
}
|
||
|
||
}
|
||
|
||
if (pvb->pSub) {
|
||
OK(nfText.WriteS(";"));
|
||
OK(nfText.WriteHex(pvb->cSub,4));
|
||
OK(WriteTokVersionBlocks(nfText, pvb->pSub));
|
||
}
|
||
|
||
pvb = pvb->pNext;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT ReadTokVersionBlocks(
|
||
TextScanner &mfText,
|
||
VersionBlock **ppvb,
|
||
int iDepth,
|
||
DWORD *pcBlocks) {
|
||
|
||
int i;
|
||
DWORD dwRecordedDepth;
|
||
|
||
|
||
OK(mfText.ReadHex(pcBlocks));
|
||
|
||
for (i=0; i<*pcBlocks; i++) {
|
||
*ppvb = new VersionBlock;
|
||
ASSERT(*ppvb != NULL);
|
||
|
||
(*ppvb)->pNext = NULL;
|
||
(*ppvb)->pSub = NULL;
|
||
(*ppvb)->iDepth = iDepth;
|
||
(*ppvb)->cSub = 0;
|
||
|
||
OK(mfText.ExpectLn(" "));
|
||
OK(mfText.ReadHex(&dwRecordedDepth));
|
||
ASSERT(dwRecordedDepth == iDepth);
|
||
OK(mfText.Expect(","));
|
||
OK((*ppvb)->rsKey.ReadTok(&mfText));
|
||
|
||
if (*(char*)mfText.GetRead() != '=') {
|
||
|
||
// No value
|
||
|
||
(*ppvb)->rwbText.w = 1;
|
||
(*ppvb)->bValue = FALSE;
|
||
|
||
} else {
|
||
|
||
OK(mfText.Expect("="));
|
||
(*ppvb)->bValue = TRUE;
|
||
|
||
|
||
if (*(char*)mfText.GetRead() == '\"') {
|
||
|
||
// String value
|
||
|
||
(*ppvb)->rwbText.w = 1;
|
||
OK((*ppvb)->rsValue.ReadTok(&mfText));
|
||
|
||
} else {
|
||
|
||
// Binary value
|
||
|
||
(*ppvb)->rwbText.w = 0;
|
||
OK((*ppvb)->rbValue.ReadTok(mfText));
|
||
}
|
||
}
|
||
|
||
if (*(char*)mfText.GetRead() == ';') {
|
||
|
||
// Process subkeys
|
||
|
||
OK(mfText.Expect(";"));
|
||
OK(ReadTokVersionBlocks(
|
||
mfText,
|
||
&(*ppvb)->pSub,
|
||
iDepth+1,
|
||
&(*ppvb)->cSub));
|
||
}
|
||
|
||
// Prepare to add another block
|
||
|
||
ppvb = &(*ppvb)->pNext;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
size_t cbBinVersionBlocks(const VersionBlock *pvb) const {
|
||
|
||
size_t cb;
|
||
|
||
cb = 6; // Header
|
||
cb += pvb->rsKey.cbBinZ();
|
||
|
||
cb = cb+3 & ~3; // DWORD align
|
||
|
||
if (pvb->bValue) {
|
||
|
||
if (pvb->rwbText.w) {
|
||
|
||
cb += pvb->rsValue.cbBinZ();
|
||
|
||
} else {
|
||
|
||
cb += pvb->rbValue.cbBin();
|
||
}
|
||
|
||
cb = cb + 3 & ~3; // DWORD align
|
||
}
|
||
|
||
if (pvb->pSub != NULL) {
|
||
|
||
pvb = pvb->pSub;
|
||
while (pvb) {
|
||
cb += cbBinVersionBlocks(pvb);
|
||
pvb = pvb->pNext;
|
||
}
|
||
}
|
||
|
||
return cb;
|
||
}
|
||
|
||
|
||
HRESULT CopyBinVersionBlocks(
|
||
BYTE **ppb,
|
||
const VersionBlock *pvb) const {
|
||
|
||
const BYTE *pbResource;
|
||
size_t cb;
|
||
|
||
pbResource = *ppb;
|
||
|
||
|
||
while (pvb != NULL) {
|
||
|
||
cb = cbBinVersionBlocks(pvb);
|
||
ASSERT(cb < 0x1000);
|
||
|
||
*((WORD*)(*ppb)) = (WORD)cb;
|
||
(*ppb) += 2;
|
||
|
||
// Generate value length
|
||
|
||
if (pvb->bValue) {
|
||
if (pvb->rwbText.w) {
|
||
*((WORD*)(*ppb)) = pvb->rsValue.GetLength()+1;
|
||
} else {
|
||
*((WORD*)(*ppb)) = pvb->rbValue.GetLength();
|
||
}
|
||
} else {
|
||
*((WORD*)(*ppb)) = 0;
|
||
}
|
||
(*ppb) += 2;
|
||
|
||
OK(pvb->rwbText.CopyBin(ppb));
|
||
OK(pvb->rsKey.CopyBinZ(ppb));
|
||
|
||
while (*ppb - pbResource & 3) {
|
||
**ppb = 0;
|
||
(*ppb)++;
|
||
}
|
||
|
||
if (pvb->bValue) {
|
||
|
||
if (pvb->rwbText.w) {
|
||
OK(pvb->rsValue.CopyBinZ(ppb));
|
||
} else {
|
||
OK(pvb->rbValue.CopyBin(ppb));
|
||
}
|
||
|
||
while (*ppb - pbResource & 3) {
|
||
**ppb = 0;
|
||
(*ppb)++;
|
||
}
|
||
}
|
||
|
||
if (pvb->pSub) {
|
||
OK(CopyBinVersionBlocks(ppb, pvb->pSub));
|
||
}
|
||
|
||
pvb = pvb->pNext;
|
||
}
|
||
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
int GetItemsVersionBlocks(const VersionBlock *pvb) const {
|
||
|
||
int iItems = 0;
|
||
|
||
while (pvb != NULL) {
|
||
|
||
if ( pvb->bValue
|
||
&& pvb->rwbText.w != 0) {
|
||
|
||
iItems++;
|
||
}
|
||
|
||
iItems += GetItemsVersionBlocks(pvb->pSub);
|
||
|
||
pvb = pvb->pNext;
|
||
}
|
||
|
||
return iItems;
|
||
}
|
||
|
||
|
||
int GetWordsVersionBlocks(const VersionBlock *pvb) const {
|
||
|
||
int iWords = 0;
|
||
|
||
while (pvb != NULL) {
|
||
|
||
if ( pvb->bValue
|
||
&& pvb->rwbText.w != 0) {
|
||
|
||
iWords += pvb->rsValue.GetWords();
|
||
}
|
||
|
||
iWords += GetWordsVersionBlocks(pvb->pSub);
|
||
|
||
pvb = pvb->pNext;
|
||
}
|
||
|
||
return iWords;
|
||
}
|
||
|
||
|
||
public:
|
||
|
||
virtual HRESULT ReadTok(TextScanner &mfText) {
|
||
OK(mfText.Expect("Ver;"));
|
||
return ReadTokVersionBlocks(mfText, &pvb, 0, &cBlocks);
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT WriteTok(NewFile &nfText) const {
|
||
OK(nfText.WriteS("Ver;"));
|
||
OK(nfText.WriteHex(cBlocks,4));
|
||
return WriteTokVersionBlocks(nfText, pvb);
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT ReadBin(Scanner &mfBinary, DWORD dwLen) {
|
||
return ReadBinVersionBlocks(mfBinary, dwLen, &pvb, 0, &cBlocks);
|
||
}
|
||
|
||
|
||
|
||
virtual size_t cbBin() const {
|
||
|
||
const VersionBlock *pvbTop;
|
||
size_t cb;
|
||
|
||
cb = 0;
|
||
pvbTop = pvb;
|
||
|
||
while (pvbTop) {
|
||
cb += cbBinVersionBlocks(pvbTop);
|
||
pvbTop = pvbTop->pNext;
|
||
}
|
||
return cb;
|
||
}
|
||
|
||
|
||
|
||
virtual HRESULT CopyBin (BYTE **ppb) const {
|
||
return CopyBinVersionBlocks(ppb, pvb);
|
||
}
|
||
|
||
int GetItems() const {
|
||
return GetItemsVersionBlocks(pvb);
|
||
}
|
||
|
||
int GetWords() const {
|
||
return GetWordsVersionBlocks(pvb);
|
||
}
|
||
|
||
|
||
VersionBlock *FindStringFileInfo(WCHAR* pwcStr) const {
|
||
VersionBlock *pvbRider;
|
||
|
||
if ( pvb
|
||
&& pvb->pSub
|
||
&& pvb->pSub->pSub
|
||
&& pvb->pSub->pSub->pSub) {
|
||
|
||
pvbRider = pvb->pSub->pSub->pSub;
|
||
while ( pvbRider
|
||
&& wcscmp(pvbRider->rsKey.GetString(), pwcStr) != 0) {
|
||
pvbRider = pvbRider->pNext;
|
||
}
|
||
return pvbRider;
|
||
} else {
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
|
||
ResourceString* GetStringFileInfo(WCHAR *pwcStr) {
|
||
|
||
VersionBlock *pvbStringFileInfo;
|
||
|
||
pvbStringFileInfo = FindStringFileInfo(pwcStr);
|
||
|
||
if (pvbStringFileInfo) {
|
||
return &pvbStringFileInfo->rsValue;
|
||
} else {
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
|
||
void SetStringFileInfo(WCHAR *pwcStr, ResourceString *prs) {
|
||
|
||
VersionBlock *pvbStringFileInfo;
|
||
|
||
pvbStringFileInfo = FindStringFileInfo(pwcStr);
|
||
|
||
if (pvbStringFileInfo) {
|
||
pvbStringFileInfo->rsValue = *prs;
|
||
}
|
||
}
|
||
|
||
ResourceBinary* GetBinaryInfo() const {
|
||
if (pvb) {
|
||
return &pvb->rbValue;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void SetBinaryInfo(const ResourceBinary *prb) {
|
||
if (pvb) {
|
||
pvb->rbValue = *prb;
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// Statistic collection
|
||
//
|
||
//
|
||
|
||
|
||
struct ResourceStats {
|
||
int cResources; // Number of resources with this resource type
|
||
int cItems; // Number of items with this resource type
|
||
int cWords; // Number of words in strings in this resource type
|
||
int cBytes; // Number of bytes used by resources of this type
|
||
};
|
||
|
||
typedef map < ResourceVariant, ResourceStats, less<ResourceVariant> > MappedResourceStats;
|
||
|
||
MappedResourceStats ResourceStatsMap;
|
||
|
||
|
||
|
||
//// Define our own LangId class so that primary languages sort together.
|
||
//
|
||
//
|
||
|
||
|
||
class LangId {
|
||
|
||
public:
|
||
DWORD dwLang;
|
||
|
||
LangId(DWORD dwL) {dwLang = dwL;};
|
||
|
||
bool operator< (LangId li) const {
|
||
|
||
if (PRIMARYLANGID(dwLang) != PRIMARYLANGID(li.dwLang)) {
|
||
|
||
return PRIMARYLANGID(dwLang) < PRIMARYLANGID(li.dwLang) ? true : false;
|
||
|
||
} else {
|
||
|
||
return SUBLANGID(dwLang) < SUBLANGID(li.dwLang) ? true : false;
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
typedef map < LangId, ResourceStats, less<LangId> > MappedLanguageStats;
|
||
|
||
MappedLanguageStats LanguageStatsMap;
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// UpdateStats
|
||
//
|
||
//
|
||
|
||
|
||
const ResourceStats ZeroStats = {0};
|
||
|
||
|
||
HRESULT UpdateStats(
|
||
const ResourceKey &rk,
|
||
int cItems,
|
||
int cWords,
|
||
int cBytes) {
|
||
|
||
|
||
if (ResourceStatsMap.count(*rk.prvId[0]) == 0) {
|
||
ResourceStatsMap[*rk.prvId[0]] = ZeroStats;
|
||
}
|
||
|
||
if (LanguageStatsMap.count(rk.prvId[2]->GetW()) == 0) {
|
||
LanguageStatsMap[rk.prvId[2]->GetW()] = ZeroStats;
|
||
}
|
||
|
||
ResourceStatsMap[*rk.prvId[0]].cResources += 1;
|
||
ResourceStatsMap[*rk.prvId[0]].cItems += cItems;
|
||
ResourceStatsMap[*rk.prvId[0]].cWords += cWords;
|
||
ResourceStatsMap[*rk.prvId[0]].cBytes += cBytes;
|
||
|
||
LanguageStatsMap[rk.prvId[2]->GetW()].cResources += 1;
|
||
LanguageStatsMap[rk.prvId[2]->GetW()].cItems += cItems;
|
||
LanguageStatsMap[rk.prvId[2]->GetW()].cWords += cWords;
|
||
LanguageStatsMap[rk.prvId[2]->GetW()].cBytes += cBytes;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// IsResourceWanted
|
||
//
|
||
// Returns whether a given resource key was requested on the command line
|
||
|
||
|
||
BOOL IsResourceWanted(const ResourceKey &rk) {
|
||
|
||
|
||
if (rk.prvId[0]->GetfString()) {
|
||
|
||
return g_dwProcess & PROCESSOTH;
|
||
|
||
} else {
|
||
|
||
switch (rk.prvId[0]->GetW()) {
|
||
|
||
case 1: return g_dwProcess & PROCESSCUR;
|
||
case 2: return g_dwProcess & PROCESSBMP;
|
||
case 3: return g_dwProcess & PROCESSICO;
|
||
case 4: return g_dwProcess & PROCESSMNU;
|
||
case 5: return g_dwProcess & PROCESSDLG;
|
||
case 6: return g_dwProcess & PROCESSSTR;
|
||
case 7: return g_dwProcess & PROCESSFDR;
|
||
case 8: return g_dwProcess & PROCESSFNT;
|
||
case 9: return g_dwProcess & PROCESSACC;
|
||
case 10: return g_dwProcess & PROCESSRCD;
|
||
case 11: return g_dwProcess & PROCESSMSG;
|
||
case 16: return g_dwProcess & PROCESSVER;
|
||
case 240:
|
||
case 1024:
|
||
case 23:
|
||
case 2110: return g_dwProcess & PROCESSBIN;
|
||
case 2200: return g_dwProcess & PROCESSINF;
|
||
default: return g_dwProcess & PROCESSOTH;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// NewResource
|
||
//
|
||
// Returns a pointer to a newly allocated subclass of Resource
|
||
// suitable for the given resource type.
|
||
|
||
|
||
Resource *NewResource(const ResourceVariant &rv) {
|
||
|
||
if (rv.GetfString()) {
|
||
|
||
return new ResourceBinary;
|
||
|
||
} else {
|
||
|
||
switch (rv.GetW()) {
|
||
|
||
case 1: return new ResourceBinary;
|
||
case 2: return new ResourceBinary;
|
||
case 3: return new ResourceBinary;
|
||
case 4: return new Menu32;
|
||
case 5: return new Dialog32;
|
||
case 6: return new String32;
|
||
case 7: return new ResourceBinary;
|
||
case 8: return new ResourceBinary;
|
||
case 9: return new ResourceBinary;
|
||
case 10: return new ResourceBinary;
|
||
case 11: return new ResourceBinary;
|
||
case 16: return new VersionInfo;
|
||
case 240:
|
||
case 1024:
|
||
case 23:
|
||
case 2110: return new ResourceBinary;
|
||
case 2200: return new ResourceBinary;
|
||
|
||
default: return new ResourceBinary;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// Rsrc internal resource directory
|
||
//
|
||
// Rsrc stores resources in an STL 'map' structure.
|
||
|
||
|
||
|
||
|
||
class ResourceValue {
|
||
|
||
public:
|
||
|
||
const BYTE *pb; // Pointer into mapped file
|
||
DWORD cb; // Count of bytes in the value
|
||
Resource *pResource;
|
||
DWORD dwCodePage; // Codepage from Win32 resource index - not very useful!
|
||
|
||
ResourceValue() {pb = NULL; pResource = NULL; cb=0; dwCodePage=0;}
|
||
|
||
/*
|
||
~ResourceValue() {}; // Don't destroy content on destruction
|
||
|
||
ResourceValue& operator= (const ResourceValue &rv) {
|
||
pb = rv.pb;
|
||
cb = rv.cb;
|
||
pResource = rv.pResource;
|
||
dwCodePage = rv.dwCodePage;
|
||
return *this;
|
||
}
|
||
|
||
ResourceValue(const ResourceValue &rv) {
|
||
*this = rv;
|
||
}
|
||
*/
|
||
|
||
|
||
//// CreateImage
|
||
//
|
||
// Convert interpreted resource to binary image.
|
||
// Used to prepare resources read from tokens for
|
||
// comparison and update.
|
||
|
||
HRESULT CreateImage() {
|
||
|
||
BYTE *pbBuf;
|
||
|
||
ASSERT(pb == NULL);
|
||
ASSERT(pResource != NULL);
|
||
|
||
cb = pResource->cbBin();
|
||
pbBuf = new BYTE [cb];
|
||
ASSERT(pbBuf != NULL);
|
||
|
||
pb = pbBuf;
|
||
OK(pResource->CopyBin(&pbBuf));
|
||
|
||
ASSERT(pbBuf - pb == cb); // This may be too strong? It has not failed yet!
|
||
ASSERT(pbBuf - pb <= cb); // This must be true - otherwise we wrote past the end of the buffer
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// InterpretImage
|
||
//
|
||
// Convert binary image to interpreted resource.
|
||
// Used to prepare resources read from executable for
|
||
// writing as tokens.
|
||
|
||
HRESULT InterpretImage(const ResourceKey &rk) {
|
||
|
||
ASSERT(pb != NULL);
|
||
ASSERT(pResource == NULL);
|
||
|
||
ASSERT(rk.iDepth == 3);
|
||
ASSERT(!rk.prvId[2]->GetfString());
|
||
|
||
|
||
if (g_dwOptions & OPTHEXDUMP) {
|
||
|
||
pResource = new ResourceHexDump;
|
||
|
||
} else {
|
||
|
||
// This is a resource extraction to tokens so interpret content
|
||
|
||
pResource = NewResource(*rk.prvId[0]);
|
||
}
|
||
|
||
ASSERT(pResource != NULL);
|
||
|
||
OK(pResource->ReadBin(Scanner(pb, cb), cb));
|
||
|
||
pb = NULL;
|
||
cb = 0;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//// Checksum
|
||
//
|
||
// Returns DWORD checksum of binary content of resource
|
||
|
||
DWORD Checksum() {
|
||
|
||
DWORD dw;
|
||
DWORD *pdw;
|
||
int i,l;
|
||
|
||
ASSERT(pb != NULL);
|
||
|
||
l = cb >> 2; // Length in whole DWORDS
|
||
pdw = (DWORD*)pb;
|
||
dw = 0;
|
||
|
||
for (i=0; i<l; i++) {
|
||
|
||
dw ^= pdw[i];
|
||
}
|
||
|
||
l = cb - (l << 2); // Remaining length in bytes
|
||
|
||
if (l>2) dw ^= pb[cb-3] << 16;
|
||
if (l>1) dw ^= pb[cb-2] << 8;
|
||
if (l>0) dw ^= pb[cb-1];
|
||
|
||
return dw;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
class ResourceMap : public map < ResourceKey, ResourceValue*, less<ResourceKey> > {
|
||
|
||
|
||
public:
|
||
|
||
//// AddResource
|
||
//
|
||
//
|
||
|
||
|
||
HRESULT AddResource(ResourceKey &rk, const BYTE *pb, DWORD cb, DWORD dwCodePage) {
|
||
|
||
ResourceValue *prv;
|
||
|
||
|
||
// Build a resource structure
|
||
|
||
prv = new ResourceValue;
|
||
|
||
prv->pb = pb;
|
||
prv->cb = cb;
|
||
prv->dwCodePage = dwCodePage;
|
||
prv->pResource = NULL;
|
||
|
||
|
||
// Process add options
|
||
|
||
if (IsResourceWanted(rk)) {
|
||
|
||
// Insert resource details into STL map
|
||
|
||
if (this->count(rk) != 0) {
|
||
|
||
fprintf(stderr, "%s(", g_szExecutable);
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, "): error RSRC500: Corrupt executable - resource appears more than once\n");
|
||
g_fError = TRUE;
|
||
return E_FAIL;
|
||
}
|
||
|
||
(*this)[rk] = prv;
|
||
|
||
} else {
|
||
|
||
g_cResourcesIgnored++;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
//// CopyResources
|
||
//
|
||
// Takes a copy so the original mapped file can be closed
|
||
|
||
|
||
HRESULT CopyResources() {
|
||
|
||
iterator rmi;
|
||
BYTE *pb;
|
||
|
||
for (rmi = begin(); rmi != end(); rmi++) {
|
||
|
||
pb = new BYTE[rmi->second->cb];
|
||
ASSERT(pb != NULL);
|
||
|
||
memcpy(pb, rmi->second->pb, rmi->second->cb);
|
||
|
||
rmi->second->pb = pb;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
//// WriteTokens
|
||
//
|
||
// Writes the content of the map as a token file.
|
||
//
|
||
// If an unlocalised map is provided, bit for bit identical
|
||
// resources are written as a reference to the unlocalised
|
||
// version language, rather than in full.
|
||
|
||
|
||
HRESULT WriteTokens(NewFile &nfText, ResourceMap *prmUnlocalised) {
|
||
|
||
iterator rmi;
|
||
iterator rmiUnlocalised;
|
||
ResourceKey rkUnlocalised;
|
||
|
||
for (rmi = begin(); rmi != end(); rmi++) {
|
||
|
||
g_cResourcesExtracted++;
|
||
|
||
// Write resource key and codepage
|
||
|
||
OK(rmi->first.WriteTok(&nfText));
|
||
OK(nfText.WriteS(";"));
|
||
OK(nfText.WriteHex(rmi->second->dwCodePage, 8));
|
||
|
||
|
||
if (prmUnlocalised) {
|
||
|
||
// Add unlocalised checksum and language
|
||
|
||
rkUnlocalised = rmi->first;
|
||
rkUnlocalised.SetLanguage(g_liUnlocalized);
|
||
rmiUnlocalised = prmUnlocalised->find(rkUnlocalised);
|
||
|
||
if (rmiUnlocalised == prmUnlocalised->end()) {
|
||
|
||
fprintf(stderr, "%s(", g_szResources);
|
||
rmi->first.fprint(stderr);
|
||
fprintf(stderr, "): warning RSRC100: Localised resource has no corresponding unlocalised resource in %s\n", g_szUnloc);
|
||
g_fWarn = TRUE;
|
||
|
||
} else {
|
||
|
||
// Put out details of the unlocalised resource
|
||
|
||
OK(nfText.WriteS(","));
|
||
OK(nfText.WriteHex(rmiUnlocalised->second->Checksum(), 8));
|
||
OK(nfText.WriteS(","));
|
||
OK(nfText.WriteHex(g_liUnlocalized, 4));
|
||
}
|
||
}
|
||
|
||
OK(nfText.WriteS(";"));
|
||
|
||
|
||
// Check whether resource needs to be written in full
|
||
|
||
if ( prmUnlocalised
|
||
&& rmiUnlocalised != prmUnlocalised->end()
|
||
&& rmiUnlocalised->second->cb == rmi->second->cb
|
||
&& memcmp(rmi->second->pb, rmiUnlocalised->second->pb, rmi->second->cb) == 0) {
|
||
|
||
// Bit for bit match with unlocalised executable
|
||
|
||
OK(nfText.WriteS("Unloc"));
|
||
|
||
} else {
|
||
|
||
// Doesn't match - write it in full
|
||
|
||
OK(rmi->second->InterpretImage(rmi->first));
|
||
OK(rmi->second->pResource->WriteTok(nfText));
|
||
}
|
||
|
||
OK(nfText.WriteLn());
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
//// UpdateWin32Executable
|
||
//
|
||
//
|
||
|
||
|
||
HRESULT UpdateWin32Executable(char *pExecutable) {
|
||
|
||
iterator rmi;
|
||
HANDLE hUpdate;
|
||
|
||
|
||
hUpdate = BeginUpdateResourceA(pExecutable, TRUE); // Will replace all resources
|
||
MUST(hUpdate != NULL ? S_OK : E_FAIL,
|
||
("RSRC : error RSRC600: BeginUpdateResource failed on %s\n", pExecutable));
|
||
|
||
|
||
for (rmi = begin(); rmi != end(); rmi++) {
|
||
|
||
ASSERT(rmi->first.iDepth == 3);
|
||
ASSERT(!rmi->first.prvId[2]->GetfString());
|
||
|
||
|
||
// Create binary image of resource if necessary
|
||
|
||
if (rmi->second->pb == NULL) {
|
||
OK(rmi->second->CreateImage());
|
||
}
|
||
|
||
|
||
// Use NT resource API to update resource binary image in executable
|
||
|
||
if (!UpdateResourceW(
|
||
hUpdate,
|
||
rmi->first.GetResName(0),
|
||
rmi->first.GetResName(1),
|
||
rmi->first.prvId[2]->GetW(),
|
||
(void*)rmi->second->pb,
|
||
rmi->second->cb)) {
|
||
|
||
EndUpdateResourceW(hUpdate, TRUE); // Discard all requested updates
|
||
g_fError = TRUE;
|
||
fprintf(stderr, "RSRC : error RSRC601: UpdateResourceW failed on %s\n", pExecutable);
|
||
return HRESULT_FROM_WIN32(GetLastError());
|
||
}
|
||
}
|
||
|
||
if (!EndUpdateResourceW(hUpdate, FALSE)) { // Apply all requested updates
|
||
|
||
fprintf(stderr, "RSRC : error RSRC602: EndUpdateResourceW failed on %s\n", pExecutable);
|
||
g_fError = TRUE;
|
||
return HRESULT_FROM_WIN32(GetLastError());
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
class SymbolFile {
|
||
|
||
MappedFile *m_pmfSymbolFile;
|
||
IMAGE_SEPARATE_DEBUG_HEADER *m_pDebugHeader;
|
||
|
||
public:
|
||
|
||
DWORD GetChecksum() const {return m_pDebugHeader->CheckSum;}
|
||
DWORD GetTimeDateStamp() const {return m_pDebugHeader->TimeDateStamp;}
|
||
DWORD GetImageBase() const {return m_pDebugHeader->ImageBase;}
|
||
DWORD GetSizeOfImage() const {return m_pDebugHeader->SizeOfImage;}
|
||
|
||
void SetChecksum (DWORD dwChecksum) {m_pDebugHeader->CheckSum = dwChecksum;}
|
||
void SetTimeDateStamp (DWORD dwTimeDateStamp) {m_pDebugHeader->TimeDateStamp = dwTimeDateStamp;}
|
||
void SetImageBase (DWORD dwImageBase) {m_pDebugHeader->ImageBase = dwImageBase;}
|
||
void SetSizeOfImage (DWORD dwSizeOfImage) {m_pDebugHeader->SizeOfImage = dwSizeOfImage;}
|
||
|
||
HRESULT Open(MappedFile *pmfSymbolFile) {
|
||
|
||
m_pmfSymbolFile = pmfSymbolFile;
|
||
m_pDebugHeader = (IMAGE_SEPARATE_DEBUG_HEADER*) pmfSymbolFile->GetFile();
|
||
|
||
ASSERT(m_pDebugHeader->Signature == IMAGE_SEPARATE_DEBUG_SIGNATURE);
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
class Win32Executable : public MappedFile {
|
||
|
||
IMAGE_NT_HEADERS *m_pNtHeader;
|
||
IMAGE_SECTION_HEADER *m_pSections;
|
||
int m_iSectionRsrc;
|
||
int m_iSectionRsrc1;
|
||
|
||
// For scanning
|
||
|
||
ResourceKey m_rk; // Current resource key
|
||
|
||
|
||
HRESULT MapDirectory(
|
||
ResourceMap &rm,
|
||
const BYTE *pbRsrc, // Resource block
|
||
int dwOffset, // Directory offset relative to m_pbRsrc
|
||
int iLevel) { // Directory level being scanned
|
||
|
||
|
||
IMAGE_RESOURCE_DIRECTORY *pird;
|
||
IMAGE_RESOURCE_DIRECTORY_ENTRY *pEntries;
|
||
IMAGE_RESOURCE_DATA_ENTRY *pirde;
|
||
const BYTE *pb;
|
||
int i;
|
||
|
||
pird = (IMAGE_RESOURCE_DIRECTORY*) (pbRsrc+dwOffset);
|
||
pEntries = (IMAGE_RESOURCE_DIRECTORY_ENTRY*) (pird+1);
|
||
|
||
for (i=0; i<pird->NumberOfNamedEntries + pird->NumberOfIdEntries; i++) {
|
||
|
||
// Read the ID from the directory
|
||
|
||
ASSERT(iLevel<3);
|
||
m_rk.iDepth = iLevel+1;
|
||
|
||
m_rk.prvId[iLevel] = new ResourceVariant;
|
||
ASSERT(m_rk.prvId[iLevel] != NULL);
|
||
OK(m_rk.prvId[iLevel]->ReadWin32ResDirEntry(this, pbRsrc, pEntries+i));
|
||
|
||
if (pEntries[i].DataIsDirectory) {
|
||
|
||
// This is a directory node. Recurse to scan that directory.
|
||
|
||
OK(MapDirectory(rm, pbRsrc, pEntries[i].OffsetToDirectory, iLevel+1));
|
||
|
||
} else {
|
||
|
||
// We've reached a leaf node, establish the data address and
|
||
// add the resource to the map.
|
||
|
||
pirde = (IMAGE_RESOURCE_DATA_ENTRY*) (pbRsrc + pEntries[i].OffsetToData);
|
||
|
||
// Note that even when the resource data is in .rsrc1, the
|
||
// directory entry is usually in .rsrc.
|
||
|
||
if (pirde->OffsetToData < m_pSections[m_iSectionRsrc].VirtualAddress
|
||
+ m_pSections[m_iSectionRsrc].SizeOfRawData) {
|
||
|
||
// Data is in section .rsrc
|
||
|
||
ASSERT(pirde->OffsetToData >= m_pSections[m_iSectionRsrc].VirtualAddress);
|
||
|
||
pb = GetFile()
|
||
+ m_pSections[m_iSectionRsrc].PointerToRawData
|
||
+ pirde->OffsetToData
|
||
- m_pSections[m_iSectionRsrc].VirtualAddress;
|
||
|
||
} else {
|
||
|
||
// Data is in section .rsrc1
|
||
|
||
ASSERT(pirde->OffsetToData >= m_pSections[m_iSectionRsrc1].VirtualAddress);
|
||
ASSERT(pirde->OffsetToData < m_pSections[m_iSectionRsrc1].VirtualAddress
|
||
+ m_pSections[m_iSectionRsrc1].SizeOfRawData);
|
||
|
||
pb = GetFile()
|
||
+ m_pSections[m_iSectionRsrc1].PointerToRawData
|
||
+ pirde->OffsetToData
|
||
- m_pSections[m_iSectionRsrc1].VirtualAddress;
|
||
}
|
||
|
||
|
||
OK(rm.AddResource(m_rk, pb, pirde->Size, pirde->CodePage));
|
||
}
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
public:
|
||
|
||
DWORD GetChecksum() const {return m_pNtHeader->OptionalHeader.CheckSum;}
|
||
DWORD GetTimeDateStamp() const {return m_pNtHeader->FileHeader.TimeDateStamp;}
|
||
DWORD GetImageBase() const {return m_pNtHeader->OptionalHeader.ImageBase;}
|
||
DWORD GetSizeOfImage() const {return m_pNtHeader->OptionalHeader.SizeOfImage;}
|
||
BOOL Is64BitImage() const {return m_pNtHeader->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC;}
|
||
|
||
void SetChecksum(DWORD dwChecksum) {m_pNtHeader->OptionalHeader.CheckSum=dwChecksum;}
|
||
|
||
|
||
|
||
|
||
HRESULT Open(const char *pcFileName, BOOL fWrite) {
|
||
|
||
int i;
|
||
|
||
OK(MappedFile::Open(pcFileName, fWrite));
|
||
|
||
|
||
MUST(( *(WORD*)m_pStart == IMAGE_DOS_SIGNATURE
|
||
&& *(WORD*)(m_pStart+0x18) >= 0x40) // WinVer >= 4
|
||
? S_OK : E_FAIL,
|
||
("RSRC : error RSRC501: %s is not an executable file\n", pcFileName));
|
||
|
||
m_pNtHeader = (IMAGE_NT_HEADERS*)(m_pStart + *(WORD*)(m_pStart+0x3c));
|
||
|
||
MUST((m_pNtHeader->Signature == IMAGE_NT_SIGNATURE)
|
||
? S_OK : E_FAIL,
|
||
("RSRC : error RSRC502: %s is not a Win32 executable file\n", pcFileName));
|
||
|
||
if (Is64BitImage()) {
|
||
m_pSections = (IMAGE_SECTION_HEADER*)( (BYTE *) (m_pNtHeader+1) +
|
||
(IMAGE_SIZEOF_NT_OPTIONAL64_HEADER - IMAGE_SIZEOF_NT_OPTIONAL32_HEADER));
|
||
} else {
|
||
m_pSections = (IMAGE_SECTION_HEADER*)(m_pNtHeader+1);
|
||
}
|
||
|
||
m_iSectionRsrc = -1;
|
||
m_iSectionRsrc1 = -1;
|
||
|
||
// Locate the one or two resource sections
|
||
|
||
for (i=0; i<m_pNtHeader->FileHeader.NumberOfSections; i++) {
|
||
|
||
if (strcmp((char*)m_pSections[i].Name, ".rsrc") == 0) {
|
||
|
||
m_iSectionRsrc = i;
|
||
|
||
} else if (strcmp((char*)m_pSections[i].Name, ".rsrc") == 0) {
|
||
|
||
m_iSectionRsrc1 = i;
|
||
}
|
||
}
|
||
|
||
MUST(m_iSectionRsrc >= 0
|
||
? S_OK : E_FAIL,
|
||
("RSRC : error RSRC503: No resources in %s\n", pcFileName));
|
||
ASSERT(m_iSectionRsrc > -1); // Check for presence of resources
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//// MapResourceDirectory
|
||
//
|
||
// Extract the resource directory into an STL map.
|
||
|
||
|
||
HRESULT MapResourceDirectory(ResourceMap &rm) {
|
||
|
||
OK(MapDirectory(
|
||
rm,
|
||
m_pStart + m_pSections[m_iSectionRsrc].PointerToRawData,
|
||
0, 0));
|
||
|
||
if (m_iSectionRsrc1 >= 0) {
|
||
OK(MapDirectory(
|
||
rm,
|
||
m_pStart + m_pSections[m_iSectionRsrc1].PointerToRawData,
|
||
0, 0));
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// High level operation
|
||
//
|
||
// Controlling routines for the various modes of operation
|
||
|
||
|
||
|
||
ResourceMap rmExecutable; // Read and/or update
|
||
ResourceMap rmUnlocalised; // '-u' option - unlocalised resources for comparison
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ApplyResource
|
||
//
|
||
// Applies a given key and value to the executable resource map.
|
||
//
|
||
// Tokens are merged with those already loaded from the executable
|
||
// according to the update mode (append or replace).
|
||
|
||
|
||
HRESULT ApplyResource(ResourceKey &rk, ResourceValue *prv) {
|
||
|
||
ResourceKey rkUnloc;
|
||
VersionInfo *pviLoc;
|
||
VersionInfo *pviUnloc;
|
||
ResourceMap::iterator rmiUnloc;
|
||
|
||
|
||
// Establish equivalent unlocalised key
|
||
|
||
rkUnloc = rk;
|
||
rkUnloc.SetLanguage(g_liUnlocalized);
|
||
|
||
|
||
// First ensure that we keep the unlocalised version info, if we can
|
||
|
||
if ( !(g_dwOptions & OPTVERSION)
|
||
&& !rk.prvId[0]->GetfString()
|
||
&& rk.prvId[0]->GetW() == 16 // VersionInfo
|
||
&& (rmiUnloc=rmExecutable.find(rkUnloc)) != NULL
|
||
&& rmiUnloc != rmExecutable.end()) {
|
||
|
||
// Special case - keep unlocalised file and product versions
|
||
|
||
if (rmiUnloc->second->pResource == NULL) {
|
||
rmiUnloc->second->InterpretImage(rmiUnloc->first);
|
||
}
|
||
|
||
pviLoc = static_cast<VersionInfo*>(prv->pResource);
|
||
pviUnloc = static_cast<VersionInfo*>(rmiUnloc->second->pResource);
|
||
if (pviLoc && pviUnloc) {
|
||
pviLoc->SetStringFileInfo(L"FileVersion", pviUnloc->GetStringFileInfo(L"FileVersion"));
|
||
pviLoc->SetStringFileInfo(L"ProductVersion", pviUnloc->GetStringFileInfo(L"ProductVersion"));
|
||
pviLoc->SetBinaryInfo(pviUnloc->GetBinaryInfo());
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
if (rk.prvId[2]->GetW() == g_liUnlocalized) {
|
||
|
||
// New token is not localized
|
||
|
||
fprintf(stderr, "%s(", g_szResources);
|
||
rk.fprint(stderr);
|
||
|
||
if (rmExecutable.count(rk) == 0) {
|
||
|
||
fprintf(stderr, "): warning RSRC110: Unlocalised resource from token file appended to executable\n");
|
||
g_fWarn = TRUE;
|
||
g_cResourcesAppended++;
|
||
|
||
} else {
|
||
|
||
fprintf(stderr, "): warning RSRC111: Unlocalised resource from token file replaced unlocalised resource in executable\n");
|
||
g_fWarn = TRUE;
|
||
g_cResourcesUpdated++;
|
||
}
|
||
|
||
} else if (rmExecutable.count(rk) > 0) {
|
||
|
||
// New token already exists in executable
|
||
|
||
fprintf(stderr, "%s(", g_szResources);
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, "): warning RSRC112: Localised resource from token file replaced localised resource already present in executable\n");
|
||
g_fWarn = TRUE;
|
||
g_cResourcesUpdated++;
|
||
|
||
} else if (g_dwOptions & OPTREPLACE) {
|
||
|
||
// Replace operation
|
||
//
|
||
// Replace unlocalised resource with localised translation
|
||
|
||
if (rmExecutable.count(rkUnloc) == 0) {
|
||
|
||
fprintf(stderr, "%s(", g_szResources);
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, "): warning RSRC113: Localised resource from token file appended to executable - there was no matching unlocalised resource\n");
|
||
g_fWarn = TRUE;
|
||
g_cResourcesAppended++;
|
||
|
||
} else {
|
||
|
||
// Normal operation: remove unlocalised resource from executable
|
||
|
||
rmExecutable.erase(rkUnloc);
|
||
|
||
g_cResourcesTranslated++;
|
||
}
|
||
|
||
} else {
|
||
|
||
// Append operation
|
||
|
||
g_cResourcesAppended++;
|
||
}
|
||
|
||
|
||
rmExecutable[rk] = prv;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// ReadTokens
|
||
//
|
||
// Scans the token file.
|
||
//
|
||
// Selected resources are passed to ApplyResource
|
||
|
||
|
||
HRESULT ReadTokens(TextScanner &mfText) {
|
||
|
||
ResourceKey rk;
|
||
ResourceValue *prv;
|
||
ResourceKey rkUnlocalised;
|
||
DWORD dwCodePage;
|
||
DWORD dwUnlocChecksum;
|
||
ResourceMap::iterator rmiUnlocalised;
|
||
DWORD liUnlocalised; // Unlocalised language referenced by token
|
||
|
||
|
||
while (mfText.GetRead() < mfText.GetLimit()) {
|
||
|
||
OK(rk.ReadTok(&mfText)); // Read resource key
|
||
OK(mfText.Expect(";"));
|
||
|
||
|
||
if ( ( g_LangId != 0xffff
|
||
&& rk.prvId[2]->GetW() != g_LangId)
|
||
|| !IsResourceWanted(rk)) {
|
||
|
||
|
||
// Ignore this token
|
||
|
||
|
||
g_cResourcesIgnored++;
|
||
|
||
fprintf(stderr, "%s(", g_szResources);
|
||
rk.fprint(stderr);
|
||
|
||
if (g_LangId != 0xffff && rk.prvId[2]->GetW() != g_LangId) {
|
||
|
||
fprintf(stderr, "): warning RSRC120: Token file resource does not match specified language - ignored\n");
|
||
g_fWarn = TRUE;
|
||
|
||
} else {
|
||
|
||
fprintf(stderr, "): warning RSRC121: Token file resource is not a requested resource type - ignored\n");
|
||
g_fWarn = TRUE;
|
||
}
|
||
|
||
// Skip unwanted resource
|
||
|
||
OK(mfText.SkipLn());
|
||
while (*(char*)mfText.GetRead() == ' ') {
|
||
OK(mfText.SkipLn());
|
||
}
|
||
|
||
|
||
} else {
|
||
|
||
rmiUnlocalised = NULL;
|
||
|
||
OK(mfText.ReadHex(&dwCodePage));
|
||
|
||
if (*(char*)mfText.GetRead() == ',') {
|
||
|
||
// There is unlocalised resource information available
|
||
|
||
OK(mfText.Expect(","));
|
||
OK(mfText.ReadHex(&dwUnlocChecksum));
|
||
OK(mfText.Expect(","));
|
||
OK(mfText.ReadHex(&liUnlocalised));
|
||
|
||
// Check whether the unlocalised resource still exists in the
|
||
// current executable, and has the same checksum,
|
||
|
||
|
||
rkUnlocalised = rk;
|
||
rkUnlocalised.SetLanguage(liUnlocalised);
|
||
rmiUnlocalised = rmExecutable.find(rkUnlocalised);
|
||
|
||
if ( rmiUnlocalised != rmExecutable.end()
|
||
&& dwUnlocChecksum != rmiUnlocalised->second->Checksum()) {
|
||
|
||
fprintf(stderr, "%s: warning RSRC122: executable unlocalised resource checksum does not match checksum recorded in token file for resource ", mfText.GetTextPos());
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, "\n");
|
||
g_fWarn = TRUE;
|
||
}
|
||
}
|
||
|
||
OK(mfText.Expect(";"));
|
||
|
||
if (*(char*)mfText.GetRead() == 'U') {
|
||
|
||
// No resource content provided in token file
|
||
// Use unlocalised resource from executable
|
||
|
||
if (rmiUnlocalised == NULL) {
|
||
|
||
fprintf(stderr, "%s: error RSRC230: 'Unloc' token is missing unlocalised resource information for ", mfText.GetTextPos());
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, "\n");
|
||
g_fError = TRUE;
|
||
return E_FAIL;
|
||
}
|
||
|
||
OK(mfText.Expect("Unloc"));
|
||
OK(mfText.ExpectLn(""));
|
||
|
||
if (rmiUnlocalised == rmExecutable.end()) {
|
||
|
||
fprintf(stderr, "%s: warning RSRC124: missing executable unlocalised resource for ", mfText.GetTextPos());
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, " - localisation skipped\n");
|
||
g_fWarn = TRUE;
|
||
|
||
} else {
|
||
|
||
MUST(ApplyResource(rk, rmiUnlocalised->second), ("%s: error RSRC231: Failed to apply unloc token\n", mfText.GetTextPos()));
|
||
}
|
||
|
||
} else {
|
||
|
||
// Resource content is provided in token file
|
||
|
||
if (rmiUnlocalised == rmExecutable.end()) {
|
||
|
||
fprintf(stderr, "%s: warning RSRC125: executable contains no unlocalised resource corresponding to resource ", mfText.GetTextPos());
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, "\n");
|
||
g_fWarn = TRUE;
|
||
}
|
||
|
||
|
||
prv = new ResourceValue;
|
||
ASSERT(prv != NULL);
|
||
|
||
prv->dwCodePage = dwCodePage;
|
||
prv->pb = NULL;
|
||
prv->cb = 0;
|
||
|
||
|
||
switch (*(char*)mfText.GetRead()) {
|
||
|
||
case 'H': prv->pResource = new ResourceBinary; break;
|
||
case 'D': prv->pResource = new Dialog32; break;
|
||
case 'M': prv->pResource = new Menu32; break;
|
||
case 'S': prv->pResource = new String32; break;
|
||
case 'V': prv->pResource = new VersionInfo; break;
|
||
|
||
default:
|
||
fprintf(stderr, "%s: error RSRC310: Unrecognised resource type for resource ", mfText.GetTextPos());
|
||
rk.fprint(stderr);
|
||
fprintf(stderr, "\n");
|
||
g_fError = TRUE;
|
||
return E_FAIL;
|
||
}
|
||
|
||
ASSERT(prv->pResource != NULL);
|
||
|
||
// Parse selected resource
|
||
|
||
OK(prv->pResource->ReadTok(mfText));
|
||
OK(mfText.ExpectLn(NULL));
|
||
|
||
// Save parsed resource in STL map
|
||
|
||
MUST(ApplyResource(rk, prv), ("%s: error RSRC232: Failed to apply token\n", mfText.GetTextPos()));
|
||
}
|
||
}
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// Stats
|
||
//
|
||
//
|
||
|
||
|
||
HRESULT Analyse(char *pExecutable) {
|
||
|
||
Win32Executable w32x;
|
||
NewFile nfText;
|
||
ResourceMap::iterator rmi;
|
||
MappedResourceStats::iterator mrsi;
|
||
MappedLanguageStats::iterator mlsi;
|
||
char key[100];
|
||
int i;
|
||
const WCHAR *pwc;
|
||
BOOL fLocalizable;
|
||
|
||
|
||
MUST(w32x.Open(pExecutable, FALSE),
|
||
("RSRC : error RSRC510: Cannot open executable file %s\n", pExecutable));
|
||
|
||
MUST(w32x.MapResourceDirectory(rmExecutable),
|
||
("RSRC : error RSRC511: cannot find resource directory in %s\n, pExecutable"));
|
||
|
||
|
||
// Scan through the resources updating the stats
|
||
|
||
fLocalizable = FALSE;
|
||
|
||
for (rmi = rmExecutable.begin(); rmi != rmExecutable.end(); rmi++) {
|
||
|
||
if ( rmi->first.prvId[0]->GetfString()
|
||
|| rmi->first.prvId[0]->GetW() != 16) {
|
||
fLocalizable = TRUE;
|
||
}
|
||
|
||
OK(rmi->second->InterpretImage(rmi->first));
|
||
|
||
UpdateStats(rmi->first,
|
||
rmi->second->pResource->GetItems(),
|
||
rmi->second->pResource->GetWords(),
|
||
rmi->second->pResource->cbBin());
|
||
}
|
||
|
||
|
||
if (!(g_dwOptions & OPTQUIET)) {
|
||
fprintf(stdout, "\n Resource type Count Items Words Bytes\n");
|
||
fprintf(stdout, " ------------ ------ ------ ------ --------\n");
|
||
|
||
for (mrsi = ResourceStatsMap.begin(); mrsi != ResourceStatsMap.end(); mrsi++) {
|
||
|
||
if (mrsi->first.GetfString()) {
|
||
|
||
key[0] = '\"';
|
||
i=0;
|
||
pwc = mrsi->first.GetString();
|
||
while (i < min(10, mrsi->first.GetLength())) {
|
||
|
||
key[i+1] = (char) pwc[i];
|
||
i++;
|
||
}
|
||
|
||
key[i+1] = '\"';
|
||
key[i+2] = 0;
|
||
|
||
fprintf(stdout, " %-12.12s ", key);
|
||
|
||
} else {
|
||
|
||
switch (mrsi->first.GetW()) {
|
||
case 1: fprintf(stdout, " 1 (Cursor) "); break;
|
||
case 2: fprintf(stdout, " 2 (Bitmap) "); break;
|
||
case 3: fprintf(stdout, " 3 (Icon) "); break;
|
||
case 4: fprintf(stdout, " 4 (Menu) "); break;
|
||
case 5: fprintf(stdout, " 5 (Dialog) "); break;
|
||
case 6: fprintf(stdout, " 6 (String) "); break;
|
||
case 7: fprintf(stdout, " 7 (Fnt dir) "); break;
|
||
case 8: fprintf(stdout, " 8 (Font) "); break;
|
||
case 9: fprintf(stdout, " 9 (Accel) "); break;
|
||
case 10: fprintf(stdout, " a (RCDATA) "); break;
|
||
case 11: fprintf(stdout, " b (Msgtbl) "); break;
|
||
case 16: fprintf(stdout, " 10 (Version) "); break;
|
||
default: fprintf(stdout, " %-12x ", mrsi->first.GetW());
|
||
}
|
||
}
|
||
|
||
fprintf(stdout, "%6d ", mrsi->second.cResources);
|
||
|
||
if (mrsi->second.cItems > 0) {
|
||
fprintf(stdout, "%6d ", mrsi->second.cItems);
|
||
} else {
|
||
fprintf(stdout, " ");
|
||
}
|
||
if (mrsi->second.cWords > 0) {
|
||
fprintf(stdout, "%6d ", mrsi->second.cWords);
|
||
} else {
|
||
fprintf(stdout, " ");
|
||
}
|
||
fprintf(stdout, "%8d\n", mrsi->second.cBytes);
|
||
}
|
||
|
||
|
||
fprintf(stdout, "\n Language Resources Items Words Bytes\n");
|
||
fprintf(stdout, " -------- --------- ------ ------ --------\n");
|
||
|
||
for (mlsi = LanguageStatsMap.begin(); mlsi != LanguageStatsMap.end(); mlsi++) {
|
||
|
||
fprintf(stdout, " %8x %9d ",
|
||
mlsi->first, mlsi->second.cResources);
|
||
|
||
if (mlsi->second.cItems > 0) {
|
||
fprintf(stdout, "%6d ", mlsi->second.cItems);
|
||
} else {
|
||
fprintf(stdout, " ");
|
||
}
|
||
|
||
if (mlsi->second.cWords > 0) {
|
||
fprintf(stdout, "%6d ", mlsi->second.cWords);
|
||
} else {
|
||
fprintf(stdout, " ");
|
||
}
|
||
|
||
fprintf(stdout, "%8d\n", mlsi->second.cBytes);
|
||
}
|
||
|
||
fprintf(stdout, "\n");
|
||
}
|
||
|
||
|
||
if (!fLocalizable) {
|
||
fprintf(stderr, "RSRC : warning RSRC170: No localizable resources in %s\n", pExecutable);
|
||
g_fWarn = TRUE;
|
||
}
|
||
|
||
|
||
SHOULD(w32x.Close(), ("RSRC : warning RSRC171: could not close executable\n"));
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
HRESULT ExtractResources(char *pExecutable, char *pResources) {
|
||
|
||
Win32Executable w32x;
|
||
Win32Executable w32xUnloc;
|
||
NewFile nfText;
|
||
char str[100];
|
||
DWORD dw;
|
||
|
||
|
||
MUST(w32x.Open(g_szExecutable, FALSE),
|
||
("RSRC : error RSRC510: Cannot open executable file %s\n", g_szExecutable));
|
||
|
||
MUST(nfText.OpenWrite(g_szResources),
|
||
("RSRC : error RSRC512: Cannot create resource token file %s\n", g_szResources));
|
||
|
||
// Write header
|
||
|
||
if (!(g_dwOptions & OPTHEXDUMP)) {
|
||
OK(nfText.WriteS("\xef\xbb\xbf\r\n")); // UTF-8 mark for notepad, richedit etc.
|
||
}
|
||
OK(nfText.WriteS("### "));
|
||
OK(nfText.WriteS(g_szResources));
|
||
OK(nfText.WriteS("\r\n#\r\n# Extracted: "));
|
||
GetDateFormatA(
|
||
MAKELCID(LANG_ENGLISH, SORT_DEFAULT),
|
||
0, NULL,
|
||
"yyyy/MM/dd ",
|
||
str, sizeof(str));
|
||
OK(nfText.WriteS(str));
|
||
GetTimeFormatA(
|
||
MAKELCID(LANG_ENGLISH, SORT_DEFAULT),
|
||
0, NULL,
|
||
"HH:mm:ss\'\r\n# By: \'",
|
||
str, sizeof(str));
|
||
OK(nfText.WriteS(str));
|
||
dw = sizeof(str);
|
||
GetComputerNameA(str, &dw);
|
||
OK(nfText.WriteS(str));
|
||
OK(nfText.WriteS("\r\n# Executable: "));
|
||
OK(nfText.WriteS(g_szExecutable));
|
||
|
||
if (g_LangId != 0xffff) {
|
||
OK(nfText.WriteS("\r\n# Language: "));
|
||
OK(nfText.WriteHex(g_LangId, 3));
|
||
}
|
||
|
||
if (g_dwProcess != PROCESSALL) {
|
||
OK(nfText.WriteS("\r\n# Res types: "));
|
||
OK(nfText.WriteS(g_szTypes));
|
||
}
|
||
|
||
OK(nfText.WriteS("\r\n\r\n"));
|
||
|
||
|
||
MUST(w32x.MapResourceDirectory(rmExecutable),
|
||
("RSRC : error RSRC511: cannot find resource directory in %s\n, g_szExecutable"));
|
||
|
||
|
||
if (g_dwOptions & OPTUNLOC) {
|
||
|
||
// Write tokens that differ from specified unlocalised executable
|
||
|
||
MUST(w32xUnloc.Open(g_szUnloc, FALSE),
|
||
("RSRC : error RSRC513: Cannot open unlocalised executable file %s\n", g_szUnloc));
|
||
|
||
MUST(w32xUnloc.MapResourceDirectory(rmUnlocalised),
|
||
("RSRC : error RSRC514: cannot find resource directory in unlocalised executable %s\n, g_szUnloc"));
|
||
|
||
MUST(rmExecutable.WriteTokens(nfText, &rmUnlocalised),
|
||
("RSRC : error RSRC515: cannot write delta token file %s\n, g_szResources"));
|
||
|
||
w32xUnloc.Close();
|
||
|
||
} else {
|
||
|
||
MUST(rmExecutable.WriteTokens(nfText, NULL),
|
||
("RSRC : error RSRC516: cannot write stand alone token file %s\n, g_szResources"));
|
||
}
|
||
|
||
|
||
if (!(g_dwOptions & OPTQUIET)) {
|
||
fprintf(stdout, "\n%d resource(s) %s.\n", g_cResourcesExtracted, g_dwOptions & OPTHEXDUMP ? "dumped" : "tokenized");
|
||
|
||
if (g_cResourcesIgnored) {
|
||
fprintf(stdout, "%d resource(s) ignored.\n", g_cResourcesIgnored);
|
||
}
|
||
}
|
||
|
||
OK(w32x.Close());
|
||
OK(nfText.Close());
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//// UpdateResources
|
||
//
|
||
// Update resources in executable with tokens from given text
|
||
//
|
||
// Processing
|
||
//
|
||
// 1. Existing resources are loaded into the map as ResourceBinaries.
|
||
// 2. Resources are merged in from the token file according to
|
||
// command line selected processing options
|
||
// 3. The NT UpdateResource API set is used to replace all the resources
|
||
// in the executable with the merged resources in the map.
|
||
|
||
|
||
HRESULT UpdateResources(char *pExecutable, char *pResources, char* pSymbols) {
|
||
|
||
Win32Executable w32x;
|
||
SymbolFile symf;
|
||
MappedFile mfText;
|
||
MappedFile mfSymbols;
|
||
DWORD dwCheckSum;
|
||
|
||
MUST(w32x.Open(pExecutable, FALSE),
|
||
("RSRC : error RSRC510: Cannot open executable file %s\n", pExecutable));
|
||
|
||
MUST(mfText.Open(pResources, FALSE),
|
||
("RSRC : error RSRC520: Cannot open resource token file %s\n", pResources));
|
||
|
||
MUST(mfText.Expect("\xef\xbb\xbf"),
|
||
("RSRC : error RSRC521: UTF8 BOM missing from token file\n")); // UTF-8 mark for notepad, richedit etc.
|
||
|
||
OK(mfText.ExpectLn("")); // Skip over header comments
|
||
|
||
if (g_dwOptions & OPTSYMBOLS) {
|
||
if ( SUCCEEDED(mfSymbols.Open(pSymbols, TRUE))
|
||
&& SUCCEEDED(symf.Open(&mfSymbols))) {
|
||
|
||
if ( symf.GetChecksum() != w32x.GetChecksum()
|
||
|| symf.GetImageBase() != w32x.GetImageBase()) {
|
||
|
||
time_t tsTime = symf.GetTimeDateStamp();
|
||
time_t teTime = w32x.GetTimeDateStamp();
|
||
char ssTime[30]; strcpy(ssTime, ctime(&tsTime)); ssTime[19] = 0;
|
||
char seTime[30]; strcpy(seTime, ctime(&teTime)); seTime[19] = 0;
|
||
|
||
fprintf(stderr, "\n Symbol mismatch: Executable Symbol file\n");
|
||
fprintf(stderr, " ImageBase: %8x %8x\n", w32x.GetImageBase(), symf.GetImageBase());
|
||
fprintf(stderr, " Checksum: %8x %8x\n", w32x.GetChecksum(), symf.GetChecksum());
|
||
fprintf(stderr, " Timestamp: %-15.15s %-15.15s\n\n", ssTime+4, seTime+4);
|
||
|
||
fprintf(stderr, "RSRC : warning RSRC160: Symbol file does not match exectable\n");
|
||
g_fWarn = TRUE;
|
||
}
|
||
|
||
} else {
|
||
|
||
fprintf(stderr, "RSRC : warning RSRC161: Symbol file not processed\n");
|
||
g_fWarn = TRUE;
|
||
g_dwOptions &= ~OPTSYMBOLS;
|
||
}
|
||
|
||
}
|
||
|
||
// Load existing resources
|
||
|
||
MUST(w32x.MapResourceDirectory(rmExecutable),
|
||
("RSRC : error RSRC530: Cannot read executable resources from %s\n", pExecutable));
|
||
|
||
OK(rmExecutable.CopyResources()); // Take local copy before closing the mapped file
|
||
|
||
OK(w32x.Close());
|
||
|
||
|
||
// Merge in resources from token file
|
||
|
||
MUST(ReadTokens(mfText), ("RSRC : error RSRC531: Failed reading update tokens\n"));
|
||
|
||
OK(rmExecutable.UpdateWin32Executable(pExecutable));
|
||
|
||
|
||
|
||
// Update was succesful, Recalculate checksum
|
||
|
||
SHOULD(w32x.Open(pExecutable, TRUE),
|
||
("RSRC : warning RSRC162: Could not reopen executable %s to update checksum\n", pExecutable));
|
||
|
||
dwCheckSum = w32x.CalcChecksum();
|
||
|
||
w32x.SetChecksum(dwCheckSum);
|
||
|
||
if (g_dwOptions & OPTSYMBOLS) {
|
||
symf.SetChecksum(dwCheckSum);
|
||
symf.SetTimeDateStamp(w32x.GetTimeDateStamp());
|
||
symf.SetSizeOfImage(w32x.GetSizeOfImage());
|
||
SHOULD(mfSymbols.Close(), ("RSRC : warning RSRC163: Failed to write updated symbol checksum\n"));
|
||
}
|
||
|
||
w32x.Close();
|
||
|
||
|
||
if (!(g_dwOptions & OPTQUIET)) {
|
||
|
||
fprintf(stdout, "\n");
|
||
|
||
if (g_cResourcesTranslated) {
|
||
fprintf(stdout, "%d resource(s) translated.\n", g_cResourcesTranslated);
|
||
}
|
||
|
||
if (g_cResourcesAppended) {
|
||
fprintf(stdout, "%d resource(s) appended.\n", g_cResourcesAppended);
|
||
}
|
||
|
||
if (g_cResourcesUpdated) {
|
||
fprintf(stdout, "%d resource(s) updated.\n", g_cResourcesUpdated);
|
||
}
|
||
|
||
if (g_cResourcesIgnored) {
|
||
fprintf(stdout, "%d resource(s) ignored.\n", g_cResourcesIgnored);
|
||
}
|
||
}
|
||
|
||
mfText.Close();
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//// Parameter parsing
|
||
//
|
||
//
|
||
|
||
|
||
char g_cSwitch = '-'; // Switch character is recorded the first time one is seen
|
||
|
||
|
||
void SkipWhitespace(char** p, char* pE) {
|
||
while ((*p<pE) && ((**p==' ')||(**p==9))) (*p)++;
|
||
}
|
||
|
||
|
||
void ParseToken(char** p, char* pE, char* s, int l) {
|
||
|
||
// Parse up to whitespace into string s
|
||
// Guarantee zero terminator and modify no more than l chars
|
||
// Return with p beyond whitespace
|
||
|
||
|
||
if (*p < pE && **p == '\"') {
|
||
|
||
// Quoted parameter
|
||
|
||
(*p)++; // Skip over leading quote
|
||
|
||
while (l>0 && *p<pE && **p!='\"') {
|
||
*s=**p; s++; (*p)++; l--;
|
||
}
|
||
|
||
// Skip any part of token that didn't fit s
|
||
|
||
while (*p<pE && **p!='\"') { // Skip up to terminating quote
|
||
(*p)++;
|
||
}
|
||
|
||
if (*p<pE) { // Skip over terminating quote
|
||
(*p)++;
|
||
}
|
||
|
||
} else {
|
||
|
||
// Unquoted parameter
|
||
|
||
|
||
while ((l>0) && (*p<pE) && (**p>' ')) {
|
||
*s=**p; s++; (*p)++;
|
||
l--;
|
||
}
|
||
|
||
// Skip any part of token that didn't fit into s
|
||
while ((*p<pE) && (**p>' ')) (*p)++;
|
||
}
|
||
|
||
|
||
if (l>0)
|
||
*s++ = 0;
|
||
else
|
||
*(s-1) = 0;
|
||
|
||
SkipWhitespace(p, pE);
|
||
}
|
||
|
||
|
||
void ParseName(char** p, char* pE, char* s, int l) {
|
||
|
||
// Uses ParseToken to parse a name such as a filename.
|
||
// If the name starts with '/' or '-' it is assumed to be
|
||
// an option rather than a filename and ParseName returns
|
||
// a zero length string.
|
||
|
||
if (*p<pE && **p==g_cSwitch) {
|
||
|
||
// This is an option and should not be treated as a name argument
|
||
|
||
s[0] = 0;
|
||
|
||
} else {
|
||
|
||
ParseToken(p, pE, s, l);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
void DisplayUsage() {
|
||
fprintf(stdout, "Usage: rsrc -h\n");
|
||
fprintf(stdout, " or: rsrc executable [-l LangId] [-i include-opts] [-q]\n");
|
||
fprintf(stdout, " [ [-t|-d] [text-output] [-c unloc]\n");
|
||
fprintf(stdout, " | [-a|-r] [text-input] [-s symbols] ]\n");
|
||
}
|
||
|
||
void DisplayArgs() {
|
||
fprintf(stdout, "\nArguments\n\n");
|
||
fprintf(stdout, " -h Help\n");
|
||
fprintf(stdout, " -q Quiet (default is to show resource stats)\n");
|
||
fprintf(stdout, " -t tokens Write resources in checkin format to token file\n");
|
||
fprintf(stdout, " -c unloc Unlocalised executable for comparison\n");
|
||
fprintf(stdout, " -d tokens Write resources in hex dump format to token file\n");
|
||
fprintf(stdout, " -a tokens Append resources from token file to executable (multi-language update)\n");
|
||
fprintf(stdout, " -r tokens Replace executable resources from token file (single language update)\n");
|
||
fprintf(stdout, " -s symbol Symbol file whose checksum is to track the executable checksum\n");
|
||
fprintf(stdout, " -l lang Restrict processing to language specified in hex\n");
|
||
fprintf(stdout, " -u unlocl Unlocalised langauge, default 409\n");
|
||
fprintf(stdout, " -i opts Include only resource types specified:\n\n");
|
||
fprintf(stdout, " c - Cursors t - Fonts\n");
|
||
fprintf(stdout, " b - Bitmaps a - Accelerators\n");
|
||
fprintf(stdout, " i - Icons r - RCDATAs\n");
|
||
fprintf(stdout, " m - Menus g - Message tables\n");
|
||
fprintf(stdout, " d - Dialogs v - Versions info\n");
|
||
fprintf(stdout, " s - Strings x - Binary data\n");
|
||
fprintf(stdout, " f - Font directories n - INFs\n");
|
||
fprintf(stdout, " o - all others a - All (default)\n\n");
|
||
fprintf(stdout, " Examples\n\n");
|
||
fprintf(stdout, " rsrc notepad.exe - Show resource stats for notepad.exe\n");
|
||
fprintf(stdout, " rsrc notepad.exe -t - Extract tokens to notepad.exe.rsrc\n");
|
||
fprintf(stdout, " rsrc notepad.exe -r -l 401 - Translate from US using Arabic tokens in notepad.exe.rsrc\n");
|
||
fprintf(stdout, " rsrc notepad.exe -d dmp -i im - Hexdump of Icons and Menus to dmp\n\n");
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
HRESULT ProcessParameters() {
|
||
|
||
char *p; // Current command line character
|
||
char *pE; // End of command line
|
||
char *pcStop;
|
||
|
||
char token [MAXPATH];
|
||
char arg [MAXPATH];
|
||
char symbols [MAXPATH] = "";
|
||
|
||
int i,j;
|
||
int cFiles;
|
||
DWORD cRes;
|
||
BOOL fArgError;
|
||
|
||
p = GetCommandLine();
|
||
pE = p+strlen((char *)p);
|
||
|
||
|
||
g_dwOptions = 0;
|
||
g_dwProcess = 0;
|
||
cFiles = 0;
|
||
fArgError = FALSE;
|
||
g_szResources[0] = 0;
|
||
|
||
|
||
// Skip command name
|
||
ParseToken(&p, pE, token, sizeof(token));
|
||
|
||
while (p<pE) {
|
||
ParseToken(&p, pE, token, sizeof(token));
|
||
|
||
if ( token[0] == '-'
|
||
|| token[0] == '/') {
|
||
|
||
// Process command option(s)
|
||
|
||
i = 1;
|
||
g_cSwitch = token[0]; // Argument may start with the other switch character
|
||
CharLower((char*)token);
|
||
while (token[i]) {
|
||
switch (token[i]) {
|
||
case '?':
|
||
case 'h': g_dwOptions |= OPTHELP; break;
|
||
case 'v': g_dwOptions |= OPTVERSION; break;
|
||
case 'q': g_dwOptions |= OPTQUIET; break;
|
||
|
||
case 't': g_dwOptions |= OPTEXTRACT; ParseName(&p, pE, g_szResources, sizeof(g_szResources)); break;
|
||
case 'c': g_dwOptions |= OPTUNLOC; ParseName(&p, pE, g_szUnloc, sizeof(g_szUnloc)); break;
|
||
case 'd': g_dwOptions |= OPTHEXDUMP; ParseName(&p, pE, g_szResources, sizeof(g_szResources)); break;
|
||
case 'a': g_dwOptions |= OPTAPPEND; ParseName(&p, pE, g_szResources, sizeof(g_szResources)); break;
|
||
case 'r': g_dwOptions |= OPTREPLACE; ParseName(&p, pE, g_szResources, sizeof(g_szResources)); break;
|
||
case 's': g_dwOptions |= OPTSYMBOLS; ParseName(&p, pE, symbols, sizeof(g_szResources)); break;
|
||
|
||
case 'l':
|
||
ParseToken(&p, pE, arg, sizeof(arg));
|
||
g_LangId = strtol(arg, &pcStop, 16);
|
||
if (*pcStop != 0) {
|
||
fprintf(stderr, "Localized language id contains invalid hex digit '%c'.\n", *pcStop);
|
||
fArgError = TRUE;
|
||
}
|
||
break;
|
||
|
||
case 'u':
|
||
ParseToken(&p, pE, arg, sizeof(arg));
|
||
g_liUnlocalized = strtol(arg, &pcStop, 16);
|
||
if (*pcStop != 0) {
|
||
fprintf(stderr, "Unlocalized language id contains invalid hex digit '%c'.\n", *pcStop);
|
||
fArgError = TRUE;
|
||
}
|
||
break;
|
||
|
||
case 'i':
|
||
ParseToken(&p, pE, g_szTypes, sizeof(g_szTypes));
|
||
g_dwProcess = 0;
|
||
j = 0;
|
||
while (g_szTypes[j]) {
|
||
switch (g_szTypes[j]) {
|
||
case 'c': g_dwProcess |= PROCESSCUR; break;
|
||
case 'b': g_dwProcess |= PROCESSBMP; break;
|
||
case 'i': g_dwProcess |= PROCESSICO; break;
|
||
case 'm': g_dwProcess |= PROCESSMNU; break;
|
||
case 'd': g_dwProcess |= PROCESSDLG; break;
|
||
case 's': g_dwProcess |= PROCESSSTR; break;
|
||
case 'f': g_dwProcess |= PROCESSFDR; break;
|
||
case 't': g_dwProcess |= PROCESSFNT; break;
|
||
case 'a': g_dwProcess |= PROCESSACC; break;
|
||
case 'r': g_dwProcess |= PROCESSRCD; break;
|
||
case 'g': g_dwProcess |= PROCESSMSG; break;
|
||
case 'v': g_dwProcess |= PROCESSVER; break;
|
||
case 'x': g_dwProcess |= PROCESSBIN; break;
|
||
case 'n': g_dwProcess |= PROCESSINF; break;
|
||
case 'o': g_dwProcess |= PROCESSOTH; break;
|
||
case 'A': g_dwProcess |= PROCESSALL; break;
|
||
default:
|
||
fprintf(stderr, "Unrecognised resource type '%c'.\n", g_szTypes[j]);
|
||
fArgError = TRUE;
|
||
}
|
||
j++;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
fprintf(stderr, "Unrecognised argument '%c'.\n", token[i]);
|
||
fArgError = TRUE;
|
||
break;
|
||
}
|
||
i++;
|
||
}
|
||
|
||
} else {
|
||
|
||
// Process filename
|
||
|
||
switch (cFiles) {
|
||
case 0: strcpy(g_szExecutable, token); break;
|
||
}
|
||
cFiles++;
|
||
}
|
||
}
|
||
|
||
|
||
if (g_dwOptions & OPTHELP) {
|
||
|
||
fprintf(stderr, "\nRsrc - Manage Win32 executable resources.\n\n");
|
||
DisplayUsage();
|
||
DisplayArgs();
|
||
return S_OK;
|
||
|
||
}
|
||
|
||
|
||
|
||
// Validate option combinations
|
||
|
||
if (g_dwOptions & OPTEXTRACT) {
|
||
|
||
if (g_dwOptions & (OPTHEXDUMP | OPTAPPEND | OPTREPLACE | OPTSYMBOLS)) {
|
||
|
||
fprintf(stderr, "RSRC : error RSRC400: -t (tokenise) option excludes -d, -a, -r, and -s\n");
|
||
fArgError = TRUE;
|
||
}
|
||
|
||
} else if (g_dwOptions & OPTHEXDUMP) {
|
||
|
||
if (g_dwOptions & (OPTEXTRACT | OPTUNLOC | OPTAPPEND | OPTREPLACE | OPTSYMBOLS)) {
|
||
|
||
fprintf(stderr, "RSRC : error RSRC401: -d (dump) option excludes -t, -u, -a, -r, and -s\n");
|
||
fArgError = TRUE;
|
||
}
|
||
|
||
} else if (g_dwOptions & OPTAPPEND) {
|
||
|
||
if (g_dwOptions & (OPTEXTRACT | OPTHEXDUMP | OPTUNLOC | OPTREPLACE)) {
|
||
|
||
fprintf(stderr, "RSRC : error RSRC402: -a (append) option excludes -t, -d, -u, and -r\n");
|
||
fArgError = TRUE;
|
||
}
|
||
|
||
} else if (g_dwOptions & OPTREPLACE) {
|
||
|
||
if (g_dwOptions & (OPTEXTRACT | OPTHEXDUMP | OPTUNLOC | OPTAPPEND)) {
|
||
|
||
fprintf(stderr, "RSRC : error RSRC403: -r (replace) option excludes -t, -d, -u, and -a\n");
|
||
fArgError = TRUE;
|
||
}
|
||
|
||
if (g_LangId == 0xFFFF) {
|
||
|
||
fprintf(stderr, "RSRC : error RSRC404: -r (replace) option requires -l (LangId)\n");
|
||
fArgError = TRUE;
|
||
}
|
||
|
||
} else {
|
||
|
||
if (g_dwOptions & (OPTSYMBOLS)) {
|
||
|
||
fprintf(stderr, "RSRC : error RSRC405: Analysis excludes -s\n");
|
||
fArgError = TRUE;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
if (fArgError) {
|
||
|
||
DisplayUsage();
|
||
DisplayArgs();
|
||
return E_INVALIDARG;
|
||
|
||
} else if (cFiles != 1) {
|
||
|
||
fprintf(stderr, "\nRsrc : error RSRC406: must specify at least an executable file name.\n\n");
|
||
DisplayUsage();
|
||
return E_INVALIDARG;
|
||
|
||
} else {
|
||
|
||
// We have valid parameters
|
||
|
||
if (g_dwProcess == 0) {
|
||
g_dwProcess = PROCESSALL;
|
||
}
|
||
|
||
if (!(g_dwOptions & OPTQUIET)) {
|
||
fprintf(stdout, "\nRsrc - Manage executable resources.\n\n");
|
||
fprintf(stdout, " Executable file: %s\n", g_szExecutable);
|
||
|
||
if (g_szResources[0]) {
|
||
fprintf(stdout, " Resource file: %s\n", g_szResources);
|
||
}
|
||
|
||
if (symbols[0]) {
|
||
fprintf(stdout, " Symbol file: %s\n", symbols);
|
||
}
|
||
|
||
if (g_LangId != 0xffff) {
|
||
char szLang[50] = "";
|
||
char szCountry[50] = "";
|
||
GetLocaleInfoA(g_LangId, LOCALE_SENGLANGUAGE, szLang, sizeof(szLang));
|
||
GetLocaleInfoA(g_LangId, LOCALE_SENGCOUNTRY, szCountry, sizeof(szCountry));
|
||
fprintf(stdout, " Language: %x (%s - %s)\n", g_LangId, szLang, szCountry);
|
||
}
|
||
|
||
if (g_dwProcess != PROCESSALL) {
|
||
fprintf(stdout, " Include only: %s\n", g_szTypes);
|
||
}
|
||
}
|
||
|
||
cRes = 0;
|
||
|
||
|
||
// Handle default token file name
|
||
|
||
if (g_szResources[0] == 0) {
|
||
strcpy(g_szResources, g_szExecutable);
|
||
strcat(g_szResources, ".rsrc");
|
||
}
|
||
|
||
|
||
if (g_dwOptions & (OPTAPPEND | OPTREPLACE)) {
|
||
|
||
// Update an executable from tokens
|
||
|
||
MUST(UpdateResources(g_szExecutable, g_szResources, symbols), ("RSRC : error RSRC420: Update failed.\n"));
|
||
|
||
} else if (g_dwOptions & (OPTEXTRACT | OPTHEXDUMP)) {
|
||
|
||
// Generate tokens from an executable
|
||
|
||
MUST(ExtractResources(g_szExecutable, g_szResources), ("RSRC : error RSRC421: Token extraction failed.\n"));
|
||
|
||
} else {
|
||
|
||
// Analyse an executable
|
||
|
||
MUST(Analyse(g_szExecutable), ("RSRC : error RSRC422: Analysis failed.\n"));
|
||
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
int _cdecl main(void) {
|
||
|
||
if (SUCCEEDED(ProcessParameters())) {
|
||
|
||
if (!g_fWarn) {
|
||
|
||
return 0; // No problems
|
||
|
||
} else {
|
||
|
||
return 1; // Warning(s) but no error(s)
|
||
}
|
||
|
||
} else {
|
||
|
||
return 2; // Error(s)
|
||
|
||
}
|
||
}
|
||
|
||
|