nulib2/nufxlib-0/samples/Exerciser.c
2002-10-11 20:15:50 +00:00

1361 lines
37 KiB
C

/*
* NuFX archive manipulation library
* Copyright (C) 2000-2002 by Andy McFadden, All Rights Reserved.
* This is free software; you can redistribute it and/or modify it under the
* terms of the GNU Library General Public License, see the file COPYING.LIB.
*
* NufxLib exerciser. Most library functions can be invoked directly from
* the exerciser command line.
*
* This was written in C++ to evaluate the interaction between NufxLib and
* the C++ language, i.e. to make sure that all type definitions and
* function calls can be used without giving the compiler fits. This
* file will compile as either "Exerciser.c" or "Exerciser.cpp".
*/
#include "NufxLib.h"
#include "Common.h"
#include <ctype.h>
/* not portable to other OSs, but not all that important anyway */
static const char kFssep = PATH_SEP;
/* ProDOS access permissions */
#define kUnlocked 0xe3
#define kTempFile "exer-temp"
/*
* ===========================================================================
* ExerciserState object
* ===========================================================================
*/
/*
* Exerciser state.
*
* In case it isn't immediately apparent, this was written in C++ and
* then converted back to C.
*/
typedef struct ExerciserState {
NuArchive* pArchive;
char* archivePath;
const char* archiveFile;
} ExerciserState;
ExerciserState*
ExerciserState_New(void)
{
ExerciserState* pExerState;
pExerState = (ExerciserState*) malloc(sizeof(*pExerState));
if (pExerState == nil)
return nil;
pExerState->pArchive = nil;
pExerState->archivePath = nil;
pExerState->archiveFile = nil;
return pExerState;
}
void
ExerciserState_Free(ExerciserState* pExerState)
{
if (pExerState == nil)
return;
if (pExerState->pArchive != nil) {
printf("Exerciser: aborting open archive\n");
(void) NuAbort(pExerState->pArchive);
(void) NuClose(pExerState->pArchive);
}
if (pExerState->archivePath != nil)
free(pExerState->archivePath);
free(pExerState);
}
inline NuArchive*
ExerciserState_GetNuArchive(const ExerciserState* pExerState)
{
return pExerState->pArchive;
}
inline void
ExerciserState_SetNuArchive(ExerciserState* pExerState, NuArchive* newArchive)
{
pExerState->pArchive = newArchive;
}
inline char*
ExerciserState_GetArchivePath(const ExerciserState* pExerState)
{
return pExerState->archivePath;
}
inline void
ExerciserState_SetArchivePath(ExerciserState* pExerState, char* newPath)
{
if (pExerState->archivePath != nil)
free(pExerState->archivePath);
if (newPath == nil) {
pExerState->archivePath = nil;
pExerState->archiveFile = nil;
} else {
pExerState->archivePath = strdup(newPath);
pExerState->archiveFile = strrchr(newPath, kFssep);
if (pExerState->archiveFile != nil)
pExerState->archiveFile++;
if (pExerState->archiveFile == nil || *pExerState->archiveFile == '\0')
pExerState->archiveFile = pExerState->archivePath;
}
}
inline const char*
ExerciserState_GetArchiveFile(const ExerciserState* pExerState)
{
if (pExerState->archiveFile == nil)
return "[no archive open]";
else
return pExerState->archiveFile;
}
/*
* ===========================================================================
* Utility functions
* ===========================================================================
*/
/*
* NuContents callback function. Print the contents of an individual record.
*/
NuResult
PrintEntry(NuArchive* pArchive, void* vpRecord)
{
const NuRecord* pRecord = (const NuRecord*) vpRecord;
int idx;
(void)pArchive; /* shut up, gcc */
printf("RecordIdx %ld: '%s'\n",
pRecord->recordIdx, pRecord->filename);
for (idx = 0; idx < (int) pRecord->recTotalThreads; idx++) {
const NuThread* pThread;
NuThreadID threadID;
const char* threadLabel;
pThread = NuGetThread(pRecord, idx);
assert(pThread != nil);
threadID = NuGetThreadID(pThread);
switch (NuThreadIDGetClass(threadID)) {
case kNuThreadClassMessage:
threadLabel = "message class";
break;
case kNuThreadClassControl:
threadLabel = "control class";
break;
case kNuThreadClassData:
threadLabel = "data class";
break;
case kNuThreadClassFilename:
threadLabel = "filename class";
break;
default:
threadLabel = "(unknown class)";
break;
}
switch (threadID) {
case kNuThreadIDComment:
threadLabel = "comment";
break;
case kNuThreadIDIcon:
threadLabel = "icon";
break;
case kNuThreadIDMkdir:
threadLabel = "mkdir";
break;
case kNuThreadIDDataFork:
threadLabel = "data fork";
break;
case kNuThreadIDDiskImage:
threadLabel = "disk image";
break;
case kNuThreadIDRsrcFork:
threadLabel = "rsrc fork";
break;
case kNuThreadIDFilename:
threadLabel = "filename";
break;
default:
break;
}
printf(" ThreadIdx %ld - 0x%08lx (%s)\n", pThread->threadIdx,
threadID, threadLabel);
}
return kNuOK;
}
#define kNiceLineLen 256
/*
* Get a line of input, stripping the '\n' off the end.
*/
static NuError
GetLine(const char* prompt, char* buffer, int bufferSize)
{
printf("%s> ", prompt);
fflush(stdout);
if (fgets(buffer, bufferSize, stdin) == nil)
return kNuErrGeneric;
if (buffer[strlen(buffer)-1] == '\n')
buffer[strlen(buffer)-1] = '\0';
return kNuErrNone;
}
/*
* Selection filter for mass "extract" and "delete" operations.
*/
NuResult
SelectionFilter(NuArchive* pArchive, void* vselFilt)
{
const NuSelectionProposal* selProposal = (NuSelectionProposal*) vselFilt;
char buffer[8];
printf("%s (N/y)? ", selProposal->pRecord->filename);
fflush(stdout);
if (fgets(buffer, sizeof(buffer), stdin) == nil)
return kNuAbort;
if (tolower(buffer[0]) == 'y')
return kNuOK;
else
return kNuSkip;
}
/*
* General-purpose error handler.
*/
NuResult
ErrorHandler(NuArchive* pArchive, void* vErrorStatus)
{
const NuErrorStatus* pErrorStatus = (const NuErrorStatus*) vErrorStatus;
char buffer[8];
NuResult result = kNuSkip;
printf("Exerciser: error handler op=%d err=%d sysErr=%d message='%s'\n"
"\tfilename='%s' '%c'(0x%02x)\n",
pErrorStatus->operation, pErrorStatus->err, pErrorStatus->sysErr,
pErrorStatus->message == nil ? "(nil)" : pErrorStatus->message,
pErrorStatus->pathname, pErrorStatus->filenameSeparator,
pErrorStatus->filenameSeparator);
printf("\tValid options are:");
if (pErrorStatus->canAbort)
printf(" a)bort");
if (pErrorStatus->canRetry)
printf(" r)etry");
if (pErrorStatus->canIgnore)
printf(" i)gnore");
if (pErrorStatus->canSkip)
printf(" s)kip");
if (pErrorStatus->canRename)
printf(" re)name");
if (pErrorStatus->canOverwrite)
printf(" o)verwrite");
putc('\n', stdout);
printf("Return what (a/r/i/s/e/o)? ");
fflush(stdout);
if (fgets(buffer, sizeof(buffer), stdin) == nil) {
printf("Returning kNuSkip\n");
} else switch (buffer[0]) {
case 'a': result = kNuAbort; break;
case 'r': result = kNuRetry; break;
case 'i': result = kNuIgnore; break;
case 's': result = kNuSkip; break;
case 'e': result = kNuRename; break;
case 'o': result = kNuOverwrite; break;
default:
printf("Unknown value '%c', returning kNuSkip\n", buffer[0]);
break;
}
return result;
}
/*
* ===========================================================================
* Command handlers
* ===========================================================================
*/
typedef NuError (*CommandFunc)(ExerciserState* pState, int argc,
char** argv);
static NuError HelpFunc(ExerciserState* pState, int argc, char** argv);
#if 0
static NuError
GenericFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
printf("Generic! argc=%d\n", argc);
return kNuErrNone;
}
#endif
/*
* Do nothing. Useful when the user just hits <return> on a blank line.
*/
static NuError
NothingFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
return kNuErrNone;
}
/*
* q - quit
*
* Do nothing. This is used as a trigger for quitting the program. In
* practice, we catch this earlier, and won't actually call here.
*/
static NuError
QuitFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(0);
return kNuErrNone;
}
/*
* ab - abort current changes
*/
static NuError
AbortFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
return NuAbort(ExerciserState_GetNuArchive(pState));
}
/*
* af - add file to archive
*/
static NuError
AddFileFunc(ExerciserState* pState, int argc, char** argv)
{
NuFileDetails nuFileDetails;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
memset(&nuFileDetails, 0, sizeof(nuFileDetails));
nuFileDetails.threadID = kNuThreadIDDataFork;
nuFileDetails.storageName = argv[1];
nuFileDetails.fileSysID = kNuFileSysUnknown;
nuFileDetails.fileSysInfo = (short) kFssep;
nuFileDetails.access = kUnlocked;
/* fileType, extraType, storageType, dates */
return NuAddFile(ExerciserState_GetNuArchive(pState), argv[1],
&nuFileDetails, false, nil);
}
/*
* ar - add an empty record
*/
static NuError
AddRecordFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuRecordIdx recordIdx;
NuFileDetails nuFileDetails;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
memset(&nuFileDetails, 0, sizeof(nuFileDetails));
nuFileDetails.threadID = 0; /* irrelevant */
nuFileDetails.storageName = argv[1];
nuFileDetails.fileSysID = kNuFileSysUnknown;
nuFileDetails.fileSysInfo = (short) kFssep;
nuFileDetails.access = kUnlocked;
/* fileType, extraType, storageType, dates */
err = NuAddRecord(ExerciserState_GetNuArchive(pState),
&nuFileDetails, &recordIdx);
if (err == kNuErrNone)
printf("Exerciser: success, new recordIdx=%ld\n", recordIdx);
return err;
}
/*
* at - add thread to record
*/
static NuError
AddThreadFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuDataSource* pDataSource = nil;
char* lineBuf = nil;
long ourLen, maxLen;
NuThreadID threadID;
NuThreadIdx threadIdx;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 3);
lineBuf = (char*)malloc(kNiceLineLen);
assert(lineBuf != nil);
threadID = strtol(argv[2], nil, 0);
if (NuThreadIDGetClass(threadID) == kNuThreadClassData) {
/* load data from a file on disk */
maxLen = 0;
err = GetLine("Enter filename", lineBuf, kNiceLineLen);
if (err != kNuErrNone)
goto bail;
if (!lineBuf[0]) {
fprintf(stderr, "Invalid filename\n");
err = kNuErrInvalidArg;
goto bail;
}
err = NuCreateDataSourceForFile(kNuThreadFormatUncompressed,
true, 0, lineBuf, false, &pDataSource);
if (err != kNuErrNone) {
fprintf(stderr,
"Exerciser: file data source create failed (err=%d)\n", err);
goto bail;
}
} else {
if (threadID == kNuThreadIDFilename || threadID == kNuThreadIDComment) {
/* select the buffer pre-size */
err = GetLine("Enter max buffer size", lineBuf, kNiceLineLen);
if (err != kNuErrNone)
goto bail;
maxLen = strtol(lineBuf, nil, 0);
if (maxLen <= 0) {
fprintf(stderr, "Bad length\n");
err = kNuErrInvalidArg;
goto bail;
}
} else {
maxLen = 0;
}
err = GetLine("Enter the thread contents", lineBuf, kNiceLineLen);
if (err != kNuErrNone)
goto bail;
ourLen = strlen(lineBuf);
/* create a data source from the buffer */
err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed,
true, maxLen, (unsigned char*)lineBuf, 0, ourLen, &pDataSource);
if (err != kNuErrNone) {
fprintf(stderr,
"Exerciser: buffer data source create failed (err=%d)\n", err);
goto bail;
}
lineBuf = nil; /* now owned by the library */
}
err = NuAddThread(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), threadID, pDataSource, &threadIdx);
if (err == kNuErrNone) {
pDataSource = nil; /* library owns it now */
printf("Exerciser: success; function returned threadIdx=%ld\n",
threadIdx);
}
bail:
NuFreeDataSource(pDataSource);
if (lineBuf != nil)
free(lineBuf);
return err;
}
/*
* cl - close archive
*/
static NuError
CloseFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
err = NuClose(ExerciserState_GetNuArchive(pState));
if (err == kNuErrNone) {
ExerciserState_SetNuArchive(pState, nil);
ExerciserState_SetArchivePath(pState, nil);
}
return err;
}
/*
* d - delete all records (selection-filtered)
*/
static NuError
DeleteFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
err = NuSetSelectionFilter(ExerciserState_GetNuArchive(pState),
SelectionFilter);
if (err != kNuErrNone)
return err;
return NuDelete(ExerciserState_GetNuArchive(pState));
}
/*
* dr - delete record
*/
static NuError
DeleteRecordFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
return NuDeleteRecord(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0));
}
/*
* dt - delete thread
*/
static NuError
DeleteThreadFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
return NuDeleteThread(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0));
}
/*
* e - extract all files (selection-filtered)
*/
static NuError
ExtractFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
err = NuSetSelectionFilter(ExerciserState_GetNuArchive(pState),
SelectionFilter);
if (err != kNuErrNone)
return err;
return NuExtract(ExerciserState_GetNuArchive(pState));
}
/*
* er - extract record
*/
static NuError
ExtractRecordFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
return NuExtractRecord(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0));
}
/*
* et - extract thread
*/
static NuError
ExtractThreadFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuDataSink* pDataSink = nil;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 3);
err = NuCreateDataSinkForFile(true, kNuConvertOff, argv[2], kFssep,
&pDataSink);
if (err != kNuErrNone) {
fprintf(stderr, "Exerciser: data sink create failed\n");
goto bail;
}
err = NuExtractThread(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), pDataSink);
/* fall through with err */
bail:
NuFreeDataSink(pDataSink);
return err;
}
/*
* fl - flush changes to archive
*/
static NuError
FlushFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
long flushStatus;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
err = NuFlush(ExerciserState_GetNuArchive(pState), &flushStatus);
if (err != kNuErrNone)
printf("Exerciser: flush failed, status flags=0x%04lx\n", flushStatus);
return err;
}
/*
* gev - get value
*
* Currently takes numeric arguments. We could be nice and accept the
* things like "IgnoreCRC" for kNuValueIgnoreCRC, but not yet.
*/
static NuError
GetValueFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuValue value;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
err = NuGetValue(ExerciserState_GetNuArchive(pState),
(NuValueID) strtol(argv[1], nil, 0), &value);
if (err == kNuErrNone)
printf(" --> %ld\n", value);
return err;
}
/*
* gmh - get master header
*/
static NuError
GetMasterHeaderFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
const NuMasterHeader* pMasterHeader;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
err = NuGetMasterHeader(ExerciserState_GetNuArchive(pState),
&pMasterHeader);
if (err == kNuErrNone) {
printf("Exerciser: success (version=%u, totalRecords=%lu, EOF=%lu)\n",
pMasterHeader->mhMasterVersion, pMasterHeader->mhTotalRecords,
pMasterHeader->mhMasterEOF);
}
return err;
}
/*
* gr - get record attributes
*/
static NuError
GetRecordFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
const NuRecord* pRecord;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
err = NuGetRecord(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), &pRecord);
if (err == kNuErrNone) {
printf("Exerciser: success, call returned:\n");
printf("\tfileSysID : %d\n", pRecord->recFileSysID);
printf("\tfileSysInfo : 0x%04x ('%c')\n", pRecord->recFileSysInfo,
NuGetSepFromSysInfo(pRecord->recFileSysInfo));
printf("\taccess : 0x%02lx\n", pRecord->recAccess);
printf("\tfileType : 0x%04lx\n", pRecord->recFileType);
printf("\textraType : 0x%04lx\n", pRecord->recExtraType);
printf("\tcreateWhen : ...\n");
printf("\tmodWhen : ...\n"); /* too lazy */
printf("\tarchiveWhen : ...\n");
}
return err;
}
/*
* grin - get record idx by name
*/
static NuError
GetRecordIdxByNameFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuRecordIdx recIdx;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
err = NuGetRecordIdxByName(ExerciserState_GetNuArchive(pState),
argv[1], &recIdx);
if (err == kNuErrNone)
printf("Exerciser: success, returned recordIdx=%ld\n", recIdx);
return err;
}
/*
* grip - get record idx by position
*/
static NuError
GetRecordIdxByPositionFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuRecordIdx recIdx;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
err = NuGetRecordIdxByPosition(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), &recIdx);
if (err == kNuErrNone)
printf("Exerciser: success, returned recordIdx=%ld\n", recIdx);
return err;
}
/*
* ocrw - open/create read-write
*/
static NuError
OpenCreateReadWriteFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuArchive* pArchive;
assert(ExerciserState_GetNuArchive(pState) == nil);
assert(argc == 2);
err = NuOpenRW(argv[1], kTempFile, kNuOpenCreat|kNuOpenExcl, &pArchive);
if (err == kNuErrNone) {
ExerciserState_SetNuArchive(pState, pArchive);
ExerciserState_SetArchivePath(pState, argv[1]);
}
return err;
}
/*
* oro - open read-only
*/
static NuError
OpenReadOnlyFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuArchive* pArchive;
assert(ExerciserState_GetNuArchive(pState) == nil);
assert(argc == 2);
err = NuOpenRO(argv[1], &pArchive);
if (err == kNuErrNone) {
ExerciserState_SetNuArchive(pState, pArchive);
ExerciserState_SetArchivePath(pState, argv[1]);
}
return err;
}
/*
* ors - open streaming read-only
*/
static NuError
OpenStreamingReadOnlyFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuArchive* pArchive;
FILE* fp = nil;
assert(ExerciserState_GetNuArchive(pState) == nil);
assert(argc == 2);
if ((fp = fopen(argv[1], kNuFileOpenReadOnly)) == nil) {
err = errno ? (NuError)errno : kNuErrGeneric;
fprintf(stderr, "Exerciser: unable to open '%s'\n", argv[1]);
} else {
err = NuStreamOpenRO(fp, &pArchive);
if (err == kNuErrNone) {
ExerciserState_SetNuArchive(pState, pArchive);
ExerciserState_SetArchivePath(pState, argv[1]);
fp = nil;
}
}
if (fp != nil)
fclose(fp);
return err;
}
/*
* orw - open read-write
*/
static NuError
OpenReadWriteFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuArchive* pArchive;
assert(ExerciserState_GetNuArchive(pState) == nil);
assert(argc == 2);
err = NuOpenRW(argv[1], kTempFile, 0, &pArchive);
if (err == kNuErrNone) {
ExerciserState_SetNuArchive(pState, pArchive);
ExerciserState_SetArchivePath(pState, argv[1]);
}
return err;
}
/*
* p - print
*/
static NuError
PrintFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
return NuContents(ExerciserState_GetNuArchive(pState), PrintEntry);
}
/*
* pd - print debug
*/
static NuError
PrintDebugFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
return NuDebugDumpArchive(ExerciserState_GetNuArchive(pState));
}
/*
* re - rename record
*/
static NuError
RenameFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 4);
return NuRename(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), argv[2], argv[3][0]);
}
/*
* sec - set error callback
*
* Use an error handler callback.
*/
static NuError
SetErrorCallbackFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
return NuSetErrorHandler(ExerciserState_GetNuArchive(pState), ErrorHandler);
}
/*
* sev - set value
*
* Currently takes numeric arguments.
*/
static NuError
SetValueFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 3);
return NuSetValue(ExerciserState_GetNuArchive(pState),
(NuValueID) strtol(argv[1], nil, 0), strtol(argv[2], nil, 0));
}
/*
* sra - set record attributes
*
* Right now I'm only allowing changes to file type and aux type. This
* could be adapted to do more easily, but the command handler has a
* rigid notion of how many arguments each function should have, so
* you'd need to list all of them every time.
*/
static NuError
SetRecordAttrFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
const NuRecord* pRecord;
NuRecordAttr recordAttr;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 4);
err = NuGetRecord(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), &pRecord);
if (err != kNuErrNone)
return err;
printf("Exerciser: NuGetRecord succeeded, calling NuSetRecordAttr\n");
NuRecordCopyAttr(&recordAttr, pRecord);
recordAttr.fileType = strtol(argv[2], nil, 0);
recordAttr.extraType = strtol(argv[3], nil, 0);
/*recordAttr.fileSysInfo = ':';*/
return NuSetRecordAttr(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), &recordAttr);
}
/*
* t - test archive
*/
static NuError
TestFunc(ExerciserState* pState, int argc, char** argv)
{
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 1);
return NuTest(ExerciserState_GetNuArchive(pState));
}
/*
* upt - update pre-sized thread
*/
static NuError
UpdatePresizedThreadFunc(ExerciserState* pState, int argc, char** argv)
{
NuError err;
NuDataSource* pDataSource = nil;
char* lineBuf = nil;
long ourLen, maxLen;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
assert(ExerciserState_GetNuArchive(pState) != nil);
assert(argc == 2);
lineBuf = (char*)malloc(kNiceLineLen);
assert(lineBuf != nil);
err = GetLine("Enter data for thread", lineBuf, kNiceLineLen);
if (err != kNuErrNone)
goto bail;
ourLen = strlen(lineBuf);
/* use "ourLen" for both buffer len and data len */
err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed,
true, ourLen, (unsigned char*)lineBuf, 0, ourLen, &pDataSource);
if (err != kNuErrNone) {
fprintf(stderr, "Exerciser: data source create failed (err=%d)\n",
err);
goto bail;
}
lineBuf = nil; /* now owned by the library */
err = NuUpdatePresizedThread(ExerciserState_GetNuArchive(pState),
strtol(argv[1], nil, 0), pDataSource, &maxLen);
if (err == kNuErrNone)
printf("Exerciser: success; function returned maxLen=%ld\n", maxLen);
bail:
NuFreeDataSource(pDataSource);
if (lineBuf != nil)
free(lineBuf);
return err;
}
/*
* Command table. This drives the user interface.
*/
/* flags for the CommandTable */
#define kFlagArchiveReq (1L) /* must have archive open */
#define kFlagNoArchiveReq (1L<<1) /* must NOT have archive open */
/* command set */
static const struct {
const char* commandStr;
CommandFunc func;
int expectedArgCount;
const char* argumentList;
unsigned long flags;
const char* description;
} gCommandTable[] = {
{ "--- exerciser commands ---", HelpFunc, 0, "", 0,
"" },
{ "?", HelpFunc, 0, "", 0,
"Show help" },
{ "h", HelpFunc, 0, "", 0,
"Show help" },
{ "q", QuitFunc, 0, "", 0,
"Quit program (will abort un-flushed changes)" },
{ "--- archive commands ---", HelpFunc, 0, "", 0,
"" },
{ "ab", AbortFunc, 0, "", kFlagArchiveReq,
"Abort current changes" },
{ "af", AddFileFunc, 1, "filename", kFlagArchiveReq,
"Add file" },
{ "ar", AddRecordFunc, 1, "storageName", kFlagArchiveReq,
"Add record" },
{ "at", AddThreadFunc, 2, "recordIdx threadID", kFlagArchiveReq,
"Add thread to record" },
{ "cl", CloseFunc, 0, "", kFlagArchiveReq,
"Close archive after flushing any changes" },
{ "d", DeleteFunc, 0, "", kFlagArchiveReq,
"Delete all records" },
{ "dr", DeleteRecordFunc, 1, "recordIdx", kFlagArchiveReq,
"Delete record" },
{ "dt", DeleteThreadFunc, 1, "threadIdx", kFlagArchiveReq,
"Delete thread" },
{ "e", ExtractFunc, 0, "", kFlagArchiveReq,
"Extract all files" },
{ "er", ExtractRecordFunc, 1, "recordIdx", kFlagArchiveReq,
"Extract record" },
{ "et", ExtractThreadFunc, 2, "threadIdx filename", kFlagArchiveReq,
"Extract thread" },
{ "fl", FlushFunc, 0, "", kFlagArchiveReq,
"Flush changes" },
{ "gev", GetValueFunc, 1, "ident", kFlagArchiveReq,
"Get value" },
{ "gmh", GetMasterHeaderFunc, 0, "", kFlagArchiveReq,
"Get master header" },
{ "gr", GetRecordFunc, 1, "recordIdx", kFlagArchiveReq,
"Get record" },
{ "grin", GetRecordIdxByNameFunc, 1, "name", kFlagArchiveReq,
"Get recordIdx by name" },
{ "grip", GetRecordIdxByPositionFunc, 1, "position", kFlagArchiveReq,
"Get recordIdx by position" },
{ "ocrw", OpenCreateReadWriteFunc, 1, "filename", kFlagNoArchiveReq,
"Open/create archive read-write" },
{ "oro", OpenReadOnlyFunc, 1, "filename", kFlagNoArchiveReq,
"Open archive read-only" },
{ "ors", OpenStreamingReadOnlyFunc, 1, "filename", kFlagNoArchiveReq,
"Open archive streaming read-only" },
{ "orw", OpenReadWriteFunc, 1, "filename", kFlagNoArchiveReq,
"Open archive read-write" },
{ "p", PrintFunc, 0, "", kFlagArchiveReq,
"Print archive contents" },
{ "pd", PrintDebugFunc, 0, "", kFlagArchiveReq,
"Print debugging output (if available)" },
{ "re", RenameFunc, 3, "recordIdx name sep", kFlagArchiveReq,
"Rename record" },
{ "sec", SetErrorCallbackFunc, 0, "", kFlagArchiveReq,
"Set error callback" },
{ "sev", SetValueFunc, 2, "ident value", kFlagArchiveReq,
"Set value" },
{ "sra", SetRecordAttrFunc, 3, "recordIdx type aux", kFlagArchiveReq,
"Set record attributes" },
{ "t", TestFunc, 0, "", kFlagArchiveReq,
"Test archive" },
{ "upt", UpdatePresizedThreadFunc, 1, "threadIdx", kFlagArchiveReq,
"Update pre-sized thread" },
};
#define kMaxArgs 4
/*
* Display a summary of available commands.
*/
static NuError
HelpFunc(ExerciserState* pState, int argc, char** argv)
{
int i;
(void) pState, (void) argc, (void) argv; /* shut up, gcc */
printf("\nAvailable commands:\n");
for (i = 0; i < (int)NELEM(gCommandTable); i++) {
printf(" %-4s %-21s %s\n",
gCommandTable[i].commandStr,
gCommandTable[i].argumentList,
gCommandTable[i].description);
}
return kNuErrNone;
}
/*
* ===========================================================================
* Control
* ===========================================================================
*/
static const char* kWhitespace = " \t\n";
/*
* Parse a command from the user.
*
* "lineBuf" will be mangled. On success, "pFunc", "pArgc", and "pArgv"
* will receive the results.
*/
static NuError
ParseLine(char* lineBuf, ExerciserState* pState, CommandFunc* pFunc, int* pArgc,
char*** pArgv)
{
NuError err = kNuErrSyntax;
char* command;
char* cp;
int i;
/*
* Parse the strings.
*/
command = strtok(lineBuf, kWhitespace);
if (command == nil) {
/* no command; the user probably just hit "enter" on a blank line */
*pFunc = NothingFunc;
*pArgc = 0;
*pArgv = nil;
err = kNuErrNone;
goto bail;
}
/* no real need to be flexible; add 1 for command and one for nil */
*pArgv = (char**) malloc(sizeof(char*) * (kMaxArgs+2));
(*pArgv)[0] = command;
*pArgc = 1;
cp = strtok(nil, kWhitespace);
while (cp != nil) {
if (*pArgc >= kMaxArgs+1) {
printf("ERROR: too many arguments\n");
goto bail;
}
(*pArgv)[*pArgc] = cp;
(*pArgc)++;
cp = strtok(nil, kWhitespace);
}
assert(*pArgc < kMaxArgs+2);
(*pArgv)[*pArgc] = nil;
/*
* Look up the command.
*/
for (i = 0; i < (int)NELEM(gCommandTable); i++) {
if (strcmp(command, gCommandTable[i].commandStr) == 0)
break;
}
if (i == NELEM(gCommandTable)) {
printf("ERROR: unrecognized command\n");
goto bail;
}
*pFunc = gCommandTable[i].func;
/*
* Check arguments and flags.
*/
if (*pArgc -1 != gCommandTable[i].expectedArgCount) {
printf("ERROR: expected %d args, found %d\n",
gCommandTable[i].expectedArgCount, *pArgc -1);
goto bail;
}
if (gCommandTable[i].flags & kFlagArchiveReq) {
if (ExerciserState_GetNuArchive(pState) == nil) {
printf("ERROR: must have an archive open\n");
goto bail;
}
}
if (gCommandTable[i].flags & kFlagNoArchiveReq) {
if (ExerciserState_GetNuArchive(pState) != nil) {
printf("ERROR: an archive is already open\n");
goto bail;
}
}
/*
* Looks good!
*/
err = kNuErrNone;
bail:
return err;
}
/*
* Interpret commands, do clever things.
*/
static NuError
CommandLoop(void)
{
NuError err = kNuErrNone;
ExerciserState* pState = ExerciserState_New();
CommandFunc func;
char lineBuf[128];
int argc;
char** argv = nil;
while (1) {
printf("\nEnter command (%s)> ", ExerciserState_GetArchiveFile(pState));
fflush(stdout);
if (fgets(lineBuf, sizeof(lineBuf), stdin) == nil) {
printf("\n");
break;
}
if (argv != nil) {
free(argv);
argv = nil;
}
func = nil; /* sanity check */
err = ParseLine(lineBuf, pState, &func, &argc, &argv);
if (err != kNuErrNone)
continue;
assert(func != nil);
if (func == QuitFunc)
break;
err = (*func)(pState, argc, argv);
if (err < 0)
printf("Exerciser: received error %d (%s)\n", err, NuStrError(err));
else if (err > 0)
printf("Exerciser: received error %d\n", err);
if (argv != nil) {
free(argv);
argv = nil;
}
}
if (ExerciserState_GetNuArchive(pState) != nil) {
/* ought to query the archive before saying something like this... */
printf("Exerciser: aborting any un-flushed changes in archive %s\n",
ExerciserState_GetArchivePath(pState));
(void) NuAbort(ExerciserState_GetNuArchive(pState));
err = NuClose(ExerciserState_GetNuArchive(pState));
if (err != kNuErrNone)
printf("Exerciser: got error %d closing archive\n", err);
ExerciserState_SetNuArchive(pState, nil);
}
if (pState != nil)
free(pState);
if (argv != nil)
free(argv);
return kNuErrNone;
}
/*
* Main entry point.
*
* We don't currently take any arguments, so this is pretty straightforward.
*/
int
main(void)
{
NuError result;
long majorVersion, minorVersion, bugVersion;
const char* nufxLibDate;
const char* nufxLibFlags;
(void) NuGetVersion(&majorVersion, &minorVersion, &bugVersion,
&nufxLibDate, &nufxLibFlags);
printf("NufxLib exerciser, linked with NufxLib v%ld.%ld.%ld [%s]\n\n",
majorVersion, minorVersion, bugVersion, nufxLibFlags);
/* stuff useful when debugging lots */
if (unlink(kTempFile) == 0)
fprintf(stderr, "NOTE: whacked exer-temp\n");
if (unlink("new.shk") == 0)
fprintf(stderr, "NOTE: whacked new.shk\n");
#if defined(HAS_MALLOC_CHECK_) && !defined(USE_DMALLOC)
/*
* This is really nice to have on Linux and any other system that
* uses the GNU libc/malloc stuff. It slows things down, but it
* tells you when you do something dumb with malloc/realloc/free.
* (Solaris 2.7 has a similar feature that is enabled by setting the
* environment variable LD_PRELOAD to include watchmalloc.so. Other
* OSs and 3rd-party malloc packages may have similar features.)
*
* This environment variable must be set when the program is launched.
* Tweaking the environment within the program has no effect.
*/
{
char* debugSet = getenv("MALLOC_CHECK_");
if (debugSet == nil)
printf("WARNING: MALLOC_CHECK_ not enabled\n\n");
}
#endif
result = CommandLoop();
exit(result != kNuErrNone);
}