Apple-2-Tools
/
ciderpress
mirror of https://github.com/fadden/ciderpress.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
ciderpress/reformat/ResourceFork.cpp

258 lines
8.6 KiB
C++
Raw Normal View History

initial import
2007-03-27 17:47:10 +00:00
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Generic resource fork handling.
*/
#include "StdAfx.h"
#include "ResourceFork.h"
/*
* Apple IIgs resource definitions.
*
* The most up-to-date list appears to be the System 6.0.1
* NList.Data from NiftyList, which included some items that were
* blanks in the Apple docs.
*/
Large set of changes to restore CiderPress build. CiderPress and MDC now compile, and execute far enough to open their respective "about" boxes, but I doubt they'll do much more than that. * Switch from MBCS to UNICODE APIs Microsoft switched to UTF-16 (by way of UCS-2) a long time ago, and the support for MBCS seems to be getting phased out. So it's time to switch to wide strings. This is a bit awkward for CiderPress because it works with disk and file archives with 8-bit filenames, and I want NufxLib and DiskImgLib to continue to work on Linux (which has largely taken the UTF-8 approach to Unicode). The libraries will continue to work with 8-bit filenames, with CiderPress/MDC doing the conversion at the appropriate point. There were a couple of places where strings from a structure handed back by one of the libraries were used directly in the UI, or vice-versa, which is a problem because we have nowhere to store the result of the conversion. These currently have fixed place-holder "xyzzy" strings. All UI strings are now wide. Various format strings now use "%ls" and "%hs" to explicitly specify wide and narrow. This doesn't play well with gcc, so only the Windows-specific parts use those. * Various updates to vcxproj files The project-file conversion had some cruft that is now largely gone. The build now has a common output directory for the EXEs and libraries, avoiding the old post-build copy steps. * Added zlib 1.2.8 and nufxlib 2.2.2 source snapshots The old "prebuilts" directory is now gone. The libraries are now built as part of building the apps. I added a minimal set of files for zlib, and a full set for nufxlib. The Linux-specific nufxlib goodies are included for the benefit of the Linux utilities, which are currently broken (don't build). * Replace symbols used for include guards Symbols with a leading "__" are reserved.
2014-11-10 23:32:55 +00:00
static const char* kUnknownSysRsrc = "(system resource)";
initial import
2007-03-27 17:47:10 +00:00
static const char* kRsrc8000[0x30] = {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
// 0x8000 through 0x802f
kUnknownSysRsrc, "rIcon",
"rPicture", "rControlList",
"rControlTemplate", "rC1InputString",
"rPString", "rStringList",
"rMenuBar", "rMenu",
"rMenuItem", "rTextForLETextBox2",
"rCtlDefProc", "rCtlColorTbl",
"rWindParam1", "rWindParam2",
"rWindColor", "rTextBlock",
"rStyleBlock", "rToolStartup",
"rResName", "rAlertString",
"rText", "rCodeResource",
"rCDEVCode", "rCDEVFlags",
"rTwoRects", "rFileType",
"rListRef", "rCString",
"rXCMD", "rXFCN",
"rErrorString", "rKTransTable",
"rWString", "rC1OutputString",
"rSoundSample", "rTERuler",
"rFSequence", "rCursor",
"rItemStruct", "rVersion",
"rComment", "rBundle",
"rFinderPath", "rPaletteWindow",
"rTaggedStrings", "rPatternList",
initial import
2007-03-27 17:47:10 +00:00
};
static const char* kRsrcC000[0x04] = {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
// 0xc000 through 0xc003
kUnknownSysRsrc, "rRectList",
"rPrintRecord", "rFont",
initial import
2007-03-27 17:47:10 +00:00
};
/*
* We handle all files, but only the resource fork.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatResourceFork::Examine(ReformatHolder* pHolder)
initial import
2007-03-27 17:47:10 +00:00
{
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
pHolder->SetApplic(ReformatHolder::kReformatResourceFork,
ReformatHolder::kApplicNot,
ReformatHolder::kApplicMaybe, ReformatHolder::kApplicNot);
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Split a resource fork into its individual resources, and display them.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
int ReformatResourceFork::Process(const ReformatHolder* pHolder,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
initial import
2007-03-27 17:47:10 +00:00
{
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* srcBuf = pHolder->GetSourceBuf(part);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long srcLen = pHolder->GetSourceLen(part);
fUseRTF = false;
long rFileVersion, rFileToMap, rFileMapSize;
bool littleEndian;
bool result;
result = ReadHeader(srcBuf, srcLen, &rFileVersion, &rFileToMap,
&rFileMapSize, &littleEndian);
Fix display of invalid resource forks We were dumping various fields, but if the resource fork was too short we were actually dumping uninitialized data. Also, bumped version to 4.0.2-a1.
2015-12-27 01:03:36 +00:00
if (!result) {
BufPrintf("Does not appear to be a valid resource fork.\r\n");
goto done;
}
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
BufPrintf("Resource fork header (%s):\r\n",
littleEndian ? "Apple IIgs little-endian" : "Macintosh big-endian");
BufPrintf(" rFileVersion = %d\r\n", rFileVersion);
BufPrintf(" rFileToMap = 0x%08lx\r\n", rFileToMap);
BufPrintf(" rFileMapSize = %ld\r\n", rFileMapSize);
BufPrintf(" rFileMemo:\r\n");
BufHexDump(srcBuf+12, 128);
BufPrintf("\r\n");
if (rFileVersion != 0) {
BufPrintf("Not an Apple IIgs resource fork (probably Macintosh).\r\n");
goto done;
}
/* move to start of resource map */
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* mapPtr;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long mapToIndex, mapIndexSize, mapIndexUsed;
mapPtr = srcBuf + rFileToMap;
mapToIndex = Get16(mapPtr + 0x0e, littleEndian);
mapIndexSize = Get32(mapPtr + 0x14, littleEndian);
mapIndexUsed = Get32(mapPtr + 0x18, littleEndian);
BufPrintf("Resource map:\r\n");
BufPrintf(" mapToIndex = 0x%04x (file offset=0x%08lx)\n",
mapToIndex, mapToIndex + rFileToMap);
BufPrintf(" mapIndexSize = %ld\r\n", mapIndexSize);
BufPrintf(" mapIndexUsed = %ld\r\n", mapIndexUsed);
BufPrintf(" mapFreeListSize = %ld\r\n", Get16(mapPtr + 0x1c, littleEndian));
BufPrintf(" mapFreeListUsed = %ld\r\n", Get16(mapPtr + 0x1e, littleEndian));
/* dump contents of resource reference records */
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* indexPtr;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
BufPrintf("\r\nResources:");
indexPtr = mapPtr + mapToIndex;
int i;
for (i = 0; i < mapIndexSize; i++) {
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint16_t resType = Get16(indexPtr + 0x00, littleEndian);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
if (resType == 0)
break; // should happen when i == mapIndexUsed
const char* typeDescr;
if (resType >= 0x8000 && resType < 0x8000 + NELEM(kRsrc8000))
typeDescr = kRsrc8000[resType - 0x8000];
else if (resType >= 0xc000 && resType < 0xc000 + NELEM(kRsrcC000))
typeDescr = kRsrcC000[resType - 0xc000];
else if (resType >= 0x0001 && resType <= 0x7fff)
Large set of changes to restore CiderPress build. CiderPress and MDC now compile, and execute far enough to open their respective "about" boxes, but I doubt they'll do much more than that. * Switch from MBCS to UNICODE APIs Microsoft switched to UTF-16 (by way of UCS-2) a long time ago, and the support for MBCS seems to be getting phased out. So it's time to switch to wide strings. This is a bit awkward for CiderPress because it works with disk and file archives with 8-bit filenames, and I want NufxLib and DiskImgLib to continue to work on Linux (which has largely taken the UTF-8 approach to Unicode). The libraries will continue to work with 8-bit filenames, with CiderPress/MDC doing the conversion at the appropriate point. There were a couple of places where strings from a structure handed back by one of the libraries were used directly in the UI, or vice-versa, which is a problem because we have nowhere to store the result of the conversion. These currently have fixed place-holder "xyzzy" strings. All UI strings are now wide. Various format strings now use "%ls" and "%hs" to explicitly specify wide and narrow. This doesn't play well with gcc, so only the Windows-specific parts use those. * Various updates to vcxproj files The project-file conversion had some cruft that is now largely gone. The build now has a common output directory for the EXEs and libraries, avoiding the old post-build copy steps. * Added zlib 1.2.8 and nufxlib 2.2.2 source snapshots The old "prebuilts" directory is now gone. The libraries are now built as part of building the apps. I added a minimal set of files for zlib, and a full set for nufxlib. The Linux-specific nufxlib goodies are included for the benefit of the Linux utilities, which are currently broken (don't build). * Replace symbols used for include guards Symbols with a leading "__" are reserved.
2014-11-10 23:32:55 +00:00
typeDescr = "(application-defined resource)";
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
else
typeDescr = kUnknownSysRsrc;
BufPrintf("\r\n Entry #%d:\r\n", i);
BufPrintf(" resType = 0x%04x - %s\r\n", resType, typeDescr);
BufPrintf(" resID = 0x%04x\r\n",
Get32(indexPtr + 0x02, littleEndian));
BufPrintf(" resOffset = 0x%04x\r\n",
Get32(indexPtr + 0x06, littleEndian));
BufPrintf(" resAttr = 0x%04x\r\n",
Get16(indexPtr + 0x0a, littleEndian));
BufPrintf(" resSize = 0x%04x\r\n",
Get32(indexPtr + 0x0c, littleEndian));
//BufPrintf(" resHandle = 0x%04x\r\n",
// Get32(indexPtr + 0x10, littleEndian));
BufHexDump(srcBuf + Get32(indexPtr + 0x06, littleEndian),
Get32(indexPtr + 0x0c, littleEndian));
indexPtr += kRsrcMapEntryLen;
}
initial import
2007-03-27 17:47:10 +00:00
done:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
SetResultBuffer(pOutput);
return 0;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Extract and verify the header of a resource fork.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
/*static*/ bool ReformatResourceFork::ReadHeader(const uint8_t* srcBuf,
long srcLen, long* pFileVersion, long* pFileToMap, long* pFileMapSize,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
bool* pLittleEndian)
initial import
2007-03-27 17:47:10 +00:00
{
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
if (srcLen < 128) {
Fix display of invalid resource forks We were dumping various fields, but if the resource fork was too short we were actually dumping uninitialized data. Also, bumped version to 4.0.2-a1.
2015-12-27 01:03:36 +00:00
LOGD("ReformatResource: invalid len %d", srcLen);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return false;
}
*pFileVersion = Get32LE(srcBuf);
if (*pFileVersion == 0)
*pLittleEndian = true;
else
*pLittleEndian = false;
*pFileVersion = Get32(srcBuf, *pLittleEndian);
*pFileToMap = Get32(srcBuf+4, *pLittleEndian);
*pFileMapSize = Get32(srcBuf+8, *pLittleEndian);
if (*pFileVersion != 0)
return false;
if (*pFileMapSize <= 0 || *pFileMapSize >= srcLen ||
*pFileToMap <= 0 || *pFileToMap >= srcLen)
{
return false;
}
return true;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* For use by other reformatters: find a specific resource.
*
* Returns "true" on success, "false" on failure.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
/*static*/ bool ReformatResourceFork::GetResource(const uint8_t* srcBuf,
long srcLen, uint16_t resourceType, uint32_t resourceID,
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t** pResource, long* pResourceLen)
initial import
2007-03-27 17:47:10 +00:00
{
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
/* read the file header */
long rFileVersion, rFileToMap, rFileMapSize;
bool littleEndian;
bool result;
result = ReadHeader(srcBuf, srcLen, &rFileVersion, &rFileToMap,
&rFileMapSize, &littleEndian);
if (!result)
return false;
/* move to start of resource map */
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* mapPtr;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long mapToIndex, mapIndexSize, mapIndexUsed;
mapPtr = srcBuf + rFileToMap;
mapToIndex = Get16(mapPtr + 0x0e, littleEndian);
mapIndexSize = Get32(mapPtr + 0x14, littleEndian);
mapIndexUsed = Get32(mapPtr + 0x18, littleEndian);
/* find the appropriate entry */
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* indexPtr = mapPtr + mapToIndex;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
int i;
for (i = 0; i < mapIndexSize; i++) {
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint16_t resType;
uint32_t resID;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
resType = Get16(indexPtr + 0x00, littleEndian);
if (resType == 0)
break; // should happen when i == mapIndexUsed
resID = Get32(indexPtr + 0x02, littleEndian);
if (resType == resourceType && resID == resourceID) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("Found resource with type=0x%04x id=0x%04x",
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
resType, resID);
*pResource = srcBuf + Get32(indexPtr + 0x06, littleEndian);
*pResourceLen = Get32(indexPtr + 0x0c, littleEndian);
if (*pResource + *pResourceLen > srcBuf+srcLen) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" Bad bounds on resource");
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
DebugBreak();
return false;
}
return true;
}
indexPtr += kRsrcMapEntryLen;
}
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("Resource not found (type=0x%04x id=0x%04x)",
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
resourceType, resourceID);
return false;
initial import
2007-03-27 17:47:10 +00:00
}