ciderpress/reformat/NiftyList.cpp
Andy McFadden c78017b1d2 More source code shuffling
Moved comments and return types, switched to uint types, added
"override" keyword.
2014-11-25 14:34:14 -08:00

372 lines
9.8 KiB
C++

/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* NiftyList database functions.
*
* The NList.Data file is divided into several sections, separated by lines
* that start with a '*'. They are:
*
* ProDOS 8 MLI calls (prefaced with some comments)
* ProDOS 16 / GS/OS
* System tools (incl. GSBug goodies)
* User tools
* E1xxxx vectors
* E0xxxx vectors
* Softswitches and F8 ROM routines (plus Davex stuff at Bxxx)
* 01xxxx vectors
* Nifty List service calls
* Resource type names
* Error codes (GS/OS and toolbox)
* HyperCardIIgs callbacks
* Request codes (for Finder extensions?)
*
* All lines have the general form:
* NNNN Text ...
* where "NNNN" is a 4-digit hexadecimal value.
*
* All sections are in some sort of sort order, though it differs for toolbox
* calls which are byte-reversed. Generally speaking, do not expect the input
* to be sorted already. The original EOL char is 0x0d, but the file may be
* converted for convenience in Windows, so supporting arbitrary EOLs is
* useful.
*/
#include "StdAfx.h"
#include "Reformat.h"
/*static*/ NiftyList::DataSet NiftyList::fP8MLI = { 0 };
/*static*/ NiftyList::DataSet NiftyList::fGSOS = { 0 };
/*static*/ NiftyList::DataSet NiftyList::fSystemTools = { 0 };
/*static*/ NiftyList::DataSet NiftyList::fE1Vectors = { 0 };
/*static*/ NiftyList::DataSet NiftyList::fE0Vectors = { 0 };
/*static*/ NiftyList::DataSet NiftyList::f00Addrs = { 0 };
/*static*/ NiftyList::DataSet NiftyList::f01Vectors = { 0 };
/*static*/ char* NiftyList::fFileData = NULL;
/*static*/ bool NiftyList::fDataReady = false;
/*
* Load the NiftyList data file.
*/
/*static*/ bool NiftyList::AppInit(const WCHAR* fileName)
{
FILE* fp = NULL;
long fileLen;
char* pData;
bool result = false;
/*
* Open the NList.Data file and load the contents into memory.
*/
fp = _wfopen(fileName, L"rb");
if (fp == NULL) {
LOGI("NL Unable to open '%ls'", fileName);
goto bail;
} else {
LOGI("NL Reading '%ls'", fileName);
}
if (fseek(fp, 0, SEEK_END) < 0) {
LOGI("Seek failed");
goto bail;
}
fileLen = ftell(fp);
rewind(fp);
fFileData = new char[fileLen];
if (fFileData == NULL) {
LOGI("Failed allocating %d bytes", fileLen);
goto bail;
}
if (fread(fFileData, fileLen, 1, fp) != 1) {
LOGI("Failed reading NList.Data (%d bytes)", fileLen);
goto bail;
}
/*
* Scan the data.
*/
pData = fFileData;
if (!ReadSection(&pData, &fileLen, &fP8MLI, kModeNormal))
goto bail;
if (!ReadSection(&pData, &fileLen, &fGSOS, kModeNormal))
goto bail;
if (!ReadSection(&pData, &fileLen, &fSystemTools, kModeNormal))
goto bail;
if (!ReadSection(&pData, &fileLen, NULL, kModeSkip)) // user tools
goto bail;
if (!ReadSection(&pData, &fileLen, &fE1Vectors, kModeNormal))
goto bail;
if (!ReadSection(&pData, &fileLen, &fE0Vectors, kModeNormal))
goto bail;
if (!ReadSection(&pData, &fileLen, &f00Addrs, kModeNormal))
goto bail;
if (!ReadSection(&pData, &fileLen, &f01Vectors, kModeNormal))
goto bail;
//DumpSection(fP8MLI);
//DumpSection(fGSOS);
fDataReady = true;
result = true;
LOGI("NL NiftyList data loaded");
bail:
if (fp != NULL)
fclose(fp);
return result;
}
/*
* Discard all allocated storage.
*/
/*static*/ bool NiftyList::AppCleanup(void)
{
delete[] fP8MLI.pEntries;
delete[] fGSOS.pEntries;
delete[] fSystemTools.pEntries;
delete[] fE1Vectors.pEntries;
delete[] fE0Vectors.pEntries;
delete[] f00Addrs.pEntries;
delete[] f01Vectors.pEntries;
delete[] fFileData;
fDataReady = false;
return true;
}
/*
* Slurp one section from the data file. Stomps EOL markers.
*
* Leaves "*ppData" pointing at the start of the next section. "*pRemLen"
* is updated appropriately.
*/
/*static*/ bool NiftyList::ReadSection(char** ppData, long* pRemLen,
DataSet* pSet, LoadMode mode)
{
assert(ppData != NULL);
assert(pRemLen != NULL);
assert(*ppData != NULL);
assert(*pRemLen > 0);
assert(pSet != NULL || mode == kModeSkip);
assert(mode == kModeNormal || mode == kModeSkip);
char* pData = *ppData;
long remLen = *pRemLen;
int lineLen, numLines, entry;
/*
* Count up the #of entries in this section.
*/
numLines = 0;
while (1) {
lineLen = ScanLine(pData, remLen);
if (lineLen == 0) {
LOGI("Failed scanning line, remLen=%ld", remLen);
return false;
}
if (*pData == '*') {
pData += lineLen;
remLen -= lineLen;
break; // end of section reached
}
pData += lineLen;
remLen -= lineLen;
numLines++;
}
if (mode == kModeSkip) {
LOGI(" NL Skipping %d entries in section", numLines);
*ppData = pData;
*pRemLen = remLen;
return true;
} else {
LOGI(" NL Found %d entries in section", numLines);
}
/*
* Allocate storage for the lookup array.
*/
assert(pSet->numEntries == 0 && pSet->pEntries == NULL);
pSet->pEntries = new NameValue[numLines];
if (pSet->pEntries == NULL) {
LOGI("NameValue alloc failed");
return false;
}
pSet->numEntries = numLines;
/*
* Add the entries to the list.
*/
pData = *ppData;
remLen = *pRemLen;
entry = 0;
while (1) {
lineLen = ScanLine(pData, remLen);
if (lineLen == 0) {
LOGI("Failed scanning line(2), remLen=%ld", remLen);
return false;
}
if (*pData == '*') {
pData += lineLen;
remLen -= lineLen;
break; // end of section reached
}
if (lineLen < 6 || pData[4] != ' ') {
LOGI("Found garbled line '%.80hs'", pData);
return false;
}
if (pData[lineLen-2] == '\r' || pData[lineLen-2] == '\n')
pData[lineLen-2] = '\0';
else if (pData[lineLen-1] == '\r' || pData[lineLen-1] == '\n')
pData[lineLen-1] = '\0';
else {
LOGI("No EOL found on '%.80hs' (%d)", pData, lineLen);
}
assert(entry < numLines);
pSet->pEntries[entry].name = pData +5;
pSet->pEntries[entry].value = ConvHexFour(pData);
entry++;
pData += lineLen;
remLen -= lineLen;
}
assert(entry == numLines);
*ppData = pData;
*pRemLen = remLen;
/*
* Sort the array. In most cases it will already be in sorted order,
* which is a worst-case for qsort, but the only really big section
* (toolbox calls) is byte-swapped and sorts just fine with qsort.
*/
qsort(pSet->pEntries, numLines, sizeof(NameValue), SortNameValue);
return true;
}
/*
* Scan a line of text. Return the #of chars, including the EOL bytes.
*
* Returns 0 if there's no data, which can only happen if "remLen" is zero
* (i.e. we hit EOF).
*/
/*static*/ int NiftyList::ScanLine(const char* pData, long remLen)
{
bool atEOL = false;
int lineLen = 0;
while (remLen--) {
if (*pData == '\r' || *pData == '\n')
atEOL = true;
else if (atEOL)
break;
pData++;
lineLen++;
}
return lineLen;
}
/*
* qsort() sort function.
*/
/*static*/ int NiftyList::SortNameValue(const void* v1, const void* v2)
{
const NameValue* pnv1 = (const NameValue*) v1;
const NameValue* pnv2 = (const NameValue*) v2;
if (pnv1->value > pnv2->value)
return 1;
else if (pnv1->value < pnv2->value)
return -1;
else {
DebugBreak(); // should never be equal in well-formed file
return 0;
}
}
/*
* Hex digit converter.
*/
static inline int HexValue(char ch)
{
if (ch >= '0' && ch <= '9')
return ch - '0';
if (ch >= 'A' && ch <= 'F')
return ch - 'A' +10;
if (ch >= 'a' && ch <= 'f')
return ch - 'a' +10;
DebugBreak(); // shouldn't happen on well-formed file
return -1;
}
/*
* Convert a 4-char hexadecimal value to an unsigned 16-bit value.
*/
/*static*/ uint16_t NiftyList::ConvHexFour(const char* data)
{
return HexValue(data[0]) << 12 |
HexValue(data[1]) << 8 |
HexValue(data[2]) << 4 |
HexValue(data[3]);
}
/*
* Dump the contents of a section.
*/
/*static*/ void NiftyList::DumpSection(const DataSet& dataSet)
{
long ent;
LOGD("Dumping section (count=%ld)", dataSet.numEntries);
for (ent = 0; ent < dataSet.numEntries; ent++) {
LOGD("%4d: %04x '%hs'",
ent, dataSet.pEntries[ent].value, dataSet.pEntries[ent].name);
}
}
/*
* Look up a value in the specified table. Returns the name, or NULL if
* not found.
*
* This uses a binary search, so the entries must be in sorted order.
*/
/*static*/ const char* NiftyList::Lookup(const DataSet& dataSet, uint16_t key)
{
if (!fDataReady) {
return NULL;
}
assert(dataSet.numEntries > 0);
int high = dataSet.numEntries-1;
int low = 0;
int mid;
while (low <= high) {
mid = (high + low)/2;
uint16_t midVal = dataSet.pEntries[mid].value;
if (key > midVal)
low = mid +1;
else if (key < midVal)
high = mid -1;
else
return dataSet.pEntries[mid].name;
}
return NULL;
}