nulib2/nufxlib-0/MiscUtils.c

/*
 * NuFX archive manipulation library
 * Copyright (C) 2000 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.
 *
 * Miscellaneous NufxLib utility functions.
 */
#define __MiscUtils_c__
#include "NufxLibPriv.h"

/*
 * Big fat hairy global.  Unfortunately this is unavoidable.
 */
NuCallback gNuGlobalErrorMessageHandler = nil;


const char* kNufxLibName = "nufxlib";


/*
 * strerror() equivalent for NufxLib errors.
 */
const char*
Nu_StrError(NuError err)
{
	/*
	 * BUG: this should be set up as per-thread storage in an MT environment.
	 * I would be more inclined to worry about this if I was expecting
	 * it to be used.  So long as valid values are passed in, and the
	 * switch statement is kept up to date, we should never have cause
	 * to return this.
	 *
	 * An easier solution, should this present a problem for someone, would
	 * be to have the function return nil or "unknown error" when the
	 * error value isn't recognized.
	 */
	static char defaultMsg[32];

	switch (err) {
	case kNuErrNone:
		return "(no error)";

	case kNuErrGeneric:
		return "NufxLib generic error";
	case kNuErrInternal:
		return "NufxLib internal error";
	case kNuErrUsage:
		return "NufxLib usage error";
	case kNuErrSyntax:
		return "NufxLib syntax error";
	case kNuErrMalloc:
		return "NufxLib malloc error";
	case kNuErrInvalidArg:
		return "Invalid arguments to NufxLib";
	case kNuErrBadStruct:
		return "Bad NuArchive structure passed to NufxLib";
	case kNuErrBusy:
		return "Attempted invalid reentrant call";

	case kNuErrSkipped:
		return "Skipped by user";
	case kNuErrAborted:
		return "Processing aborted";
	case kNuErrRename:
		return "User wants to rename file";

	case kNuErrFile:
		return "NufxLib trouble with a file";
	case kNuErrFileOpen:
		return "NufxLib unable to open file";
	case kNuErrFileClose:
		return "NufxLib unable to close file";
	case kNuErrFileRead:
		return "NufxLib unable to read file";
	case kNuErrFileWrite:
		return "NufxLib unable to write file";
	case kNuErrFileSeek:
		return "NufxLib unable to seek file";
	case kNuErrFileExists:
		return "File already exists";
	case kNuErrFileNotFound:
		return "No such file or directory";
	case kNuErrFileStat:
		return "Couldn't get file info";
	case kNuErrFileNotReadable:
		return "Read access denied";

	case kNuErrDirExists:
		return "Directory already exists";
	case kNuErrNotDir:
		return "Not a directory";
	case kNuErrNotRegularFile:
		return "Not a regular file";
	case kNuErrDirCreate:
		return "Unable to create directory";
	case kNuErrOpenDir:
		return "Unable to open directory";
	case kNuErrReadDir:
		return "Unable to read directory";
	case kNuErrFileSetDate:
		return "Unable to set file date";
	case kNuErrFileSetAccess:
		return "Unable to set file access";

	case kNuErrNotNuFX:
		return "Input is not a NuFX archive";
	case kNuErrBadMHVersion:
		return "Unrecognized Master Header version";
	case kNuErrRecHdrNotFound:
		return "Next record not found";
	case kNuErrNoRecords:
		return "No records in archive";
	case kNuErrBadRecord:
		return "Bad data in record";
	case kNuErrBadMHCRC:
		return "Bad Master Header CRC";
	case kNuErrBadRHCRC:
		return "Bad Record header CRC";
	case kNuErrBadThreadCRC:
		return "Bad Thread header CRC";
	case kNuErrBadDataCRC:
		return "Data CRC mismatch";

	case kNuErrBadFormat:
		return "Thread compression format unsupported";
	case kNuErrBadData:
		return "Bad data found";
	case kNuErrBufferOverrun:
		return "Buffer overrun";
	case kNuErrBufferUnderrun:
		return "Buffer underrun";
	case kNuErrOutMax:
		return "Output limit exceeded";

	case kNuErrNotFound:
		return "Not found";
	case kNuErrRecordNotFound:
		return "Record not found";
	case kNuErrRecIdxNotFound:
		return "RecordIdx not found";
	case kNuErrThreadIdxNotFound:
		return "ThreadIdx not found";
	case kNuErrThreadIDNotFound:
		return "ThreadID not found";
	case kNuErrRecNameNotFound:
		return "Record name not found";
	case kNuErrRecordExists:
		return "Record already exists";

	case kNuErrAllDeleted:
		return "Tried to delete all files";
	case kNuErrArchiveRO:
		return "Archive is in read-only mode";
	case kNuErrModRecChange:
		return "Attempt to alter a modified record";
	case kNuErrModThreadChange:
		return "Attempt to alter a modified thread";
	case kNuErrThreadAdd:
		return "Can't add conflicting threadID";
	case kNuErrNotPreSized:
		return "Operation only permitted on pre-sized threads";
	case kNuErrPreSizeOverflow:
		return "Data exceeds pre-sized thread size";
	case kNuErrInvalidFilename:
		return "Invalid filename";

	case kNuErrLeadingFssep:
		return "Storage name started with fssep char";
	case kNuErrNotNewer:
		return "New item wasn't newer than existing";
	case kNuErrDuplicateNotFound:
		return "Can only update an existing item";
	case kNuErrDamaged:
		return "Original archive may have been damaged";

	default:
		sprintf(defaultMsg, "(error=%d)", err);
		return defaultMsg;
	}
}


#define kNuHeftyBufSize	256		/* all error messages should fit in this */
#define kNuExtraGoodies	8		/* leave room for "\0" and other trivial chars*/

/*
 * Similar to perror(), but takes the error as an argument, and knows
 * about NufxLib errors as well as system errors.
 *
 * Depending on the compiler, "file", "line", and "function" may be nil/zero.
 *
 * Calling here with "pArchive"==nil is allowed, but should only be done
 * if the archive is inaccessible (perhaps because it failed to open).  We
 * can't invoke the error message callback if the pointer is nil.
 */
void
Nu_ReportError(NuArchive* pArchive, const char* file, int line,
	const char* function, Boolean isDebug, NuError err, const char* format, ...)
{
	NuErrorMessage errorMessage;
	const char* msg;
	va_list args;
	char buf[kNuHeftyBufSize];
	int count;
	#if defined(HAVE_SNPRINTF) || defined(SPRINTF_RETURNS_INT)
	int cc;
	#endif

	Assert(format != nil);


	va_start(args, format);

	#if defined(HAVE_VSNPRINTF) && defined(VSNPRINTF_DECLARED)
	count = vsnprintf(buf, sizeof(buf)-kNuExtraGoodies, format, args);
	#else
	  #ifdef SPRINTF_RETURNS_INT
		count = vsprintf(buf, format, args);
	  #else
		vsprintf(buf, format, args);
		count = strlen(buf);
	  #endif
	#endif

	va_end(args);

	Assert(count > 0);
	if (count < 0)
		goto bail;

	/* print the error code data, if any */
	if (err != kNuErrNone) {
		/* we know we have room for ": ", because of kNuExtraGoodies */
		strcpy(buf+count, ": ");
		count += 2;

		msg = nil;
		if (err >= 0)
			msg = strerror(err);
		if (msg == nil)
			msg = Nu_StrError(err);

		#if defined(HAVE_SNPRINTF) && defined(SNPRINTF_DECLARED)
		if (msg == nil)
			cc = snprintf(buf+count, sizeof(buf) - count,
						"(unknown err=%d)", err);
		else
			cc = snprintf(buf+count, sizeof(buf) - count, "%s", msg);
		#else
		  #ifdef SPRINTF_RETURNS_INT
			if (msg == nil)
				cc = sprintf(buf+count, "(unknown err=%d)", err);
			else
				cc = sprintf(buf+count, "%s", msg);
			Assert(cc > 0);
			count += cc;
		  #else
			if (msg == nil)
				sprintf(buf+count, "(unknown err=%d)", err);
			else
				sprintf(buf+count, "%s", msg);
			count += strlen(buf + count);
		  #endif
		#endif

	}

	#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) || \
		!defined(SNPRINTF_DELCARED) || !defined(VSNPRINTF_DECLARED)
	/* couldn't do it right, so check for overflow */
	Assert(count <= kNuHeftyBufSize);
	#endif

	if ((pArchive != nil && pArchive->messageHandlerFunc == nil) ||
		(pArchive == nil && gNuGlobalErrorMessageHandler == nil))
	{
		if (isDebug) {
			fprintf(stderr, "%s: [%s:%d %s] %s\n", kNufxLibName,
				file, line, function, buf);
		} else {
			fprintf(stderr, "%s: ERROR: %s\n", kNufxLibName, buf);
		}
	} else {
		errorMessage.message = buf;
		errorMessage.err = err;
		errorMessage.isDebug = isDebug;
		errorMessage.file = file;
		errorMessage.line = line;
		errorMessage.function = function;
		
		if (pArchive == nil)
			(void) (*gNuGlobalErrorMessageHandler)(pArchive, &errorMessage);
		else
			(void) (*pArchive->messageHandlerFunc)(pArchive, &errorMessage);
	}

bail:
	return;
}


/*
 * Memory allocation wrappers.
 *
 * Under gcc these would be macros, but not all compilers can handle that.
 *
 * [ It should be possible to use mmalloc instead of malloc.  Just tuck the
 *   mmalloc descriptor into the NuArchive struct. ]
 */

#ifndef USE_DMALLOC
void*
Nu_Malloc(NuArchive* pArchive, size_t size)
{
	void* _result;

	Assert(size > 0);
	_result = malloc(size);
	if (_result == nil) {
		Nu_ReportError(NU_BLOB, kNuErrMalloc, "malloc(%u) failed", (uint) size);
		DebugAbort();	/* leave a core dump if we're built for it */
	}
	DebugFill(_result, size);
	return _result;
}

void*
Nu_Calloc(NuArchive* pArchive, size_t size)
{
	void* _cresult = Nu_Malloc(pArchive, size);
	memset(_cresult, 0, size);
	return _cresult;
}

void*
Nu_Realloc(NuArchive* pArchive, void* ptr, size_t size)
{
	void* _result;

	Assert(ptr != nil);		/* disallow this usage */
	Assert(size > 0);		/* disallow this usage */
	_result = realloc(ptr, size);
	if (_result == nil) {
		Nu_ReportError(NU_BLOB, kNuErrMalloc, "realloc(%u) failed",(uint) size);
		DebugAbort();	/* leave a core dump if we're built for it */
	}
	return _result;
}

void
Nu_Free(NuArchive* pArchive, void* ptr)
{
	if (ptr != nil)
		free(ptr);
}
#endif