Apple-2-Tools/nulib2
1
0
Fork 0
mirror of https://github.com/fadden/nulib2.git synced 2024-05-28 23:41:29 +00:00
Code Issues Projects Releases Wiki Activity

Reformatted files to use spaces instead of hard tabs. No substantitve changes.

Browse Source
This commit is contained in:
Andy McFadden 2002-09-21 00:59:25 +00:00
parent 768a224513
commit d6a5154b60
28 changed files with 5640 additions and 5632 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

240
nufxlib-0/ChangeLog.txt
View File

@ -1,159 +1,163 @@
2000/05/22 ***** v1.0.1 shipped ***** 2002/09/20 fadden
- pulled the sources out and started fiddling with them again
- changed hard tabs to spaces
2000/05/22 fadden 2000/05/22 ***** v1.0.1 shipped *****
- added workaround for buggy 140K DOS3.3 GSHK images
2000/05/18 ***** v1.0.0 shipped ***** 2000/05/22 fadden
- added workaround for buggy 140K DOS3.3 GSHK images
2000/05/18 fadden 2000/05/18 ***** v1.0.0 shipped *****
- updated version information to indicate final release
2000/03/25 ***** v0.6.1 shipped ***** 2000/05/18 fadden
- updated version information to indicate final release
2000/03/25 fadden 2000/03/25 ***** v0.6.1 shipped *****
- Sheppy says Mac OS X PPC v1.02 and v1.2 work with minor SysDefs tweak
2000/03/05 ***** v0.6.0 (beta) shipped ***** 2000/03/25 fadden
- Sheppy says Mac OS X PPC v1.02 and v1.2 work with minor SysDefs tweak
2000/03/05 fadden 2000/03/05 ***** v0.6.0 (beta) shipped *****
- modified NuOpenRW to call mktemp or mkstemp if tmpPath looks like
a template
- removed DEBUG_MSGS from default CFLAGS
- updated version information to indicate beta release
2000/02/24 ***** v0.5.1 shipped ***** 2000/03/05 fadden
- modified NuOpenRW to call mktemp or mkstemp if tmpPath looks like
a template
- removed DEBUG_MSGS from default CFLAGS
- updated version information to indicate beta release
2000/02/20 changes from Scott Blackman 2000/02/24 ***** v0.5.1 shipped *****
- portability fixes for DJGPP under Win95
2000/02/17 changes from Devin Reade 2000/02/20 changes from Scott Blackman
- portability fixes for BSD, AIX, and others - portability fixes for DJGPP under Win95
2000/02/09 ***** v0.5.0 (alpha) shipped ***** 2000/02/17 changes from Devin Reade
- portability fixes for BSD, AIX, and others
2000/02/08 fadden 2000/02/09 ***** v0.5.0 (alpha) shipped *****
- tweaked the BeOS/PPC config around a little
- deleted some commas to make "gcc -pendantic" happy
2000/02/06 fadden 2000/02/08 fadden
- include @CFLAGS@ in case somebody wants to override them - tweaked the BeOS/PPC config around a little
- deleted some commas to make "gcc -pendantic" happy
2000/02/06 ***** v0.4.0b shipped ***** 2000/02/06 fadden
- include @CFLAGS@ in case somebody wants to override them
2000/02/06 fadden 2000/02/06 ***** v0.4.0b shipped *****
- added "install-shared" make target
- portability fixes for HP/UX
- configure.in test for presence of snprintf/vsnprintf declarations
2000/02/06 ***** v0.4.0a shipped ***** 2000/02/06 fadden
- added "install-shared" make target
- portability fixes for HP/UX
- configure.in test for presence of snprintf/vsnprintf declarations
2000/02/06 fadden 2000/02/06 ***** v0.4.0a shipped *****
- massaged configure.in for BeOS, and added some type casts for mwerks
2000/02/06 ***** v0.4.0 shipped ***** 2000/02/06 fadden
- massaged configure.in for BeOS, and added some type casts for mwerks
2000/02/06 fadden 2000/02/06 ***** v0.4.0 shipped *****
- added value range checking to Nu_SetValue
2000/02/05 fadden 2000/02/06 fadden
- finished "test-basic" - added value range checking to Nu_SetValue
- added an "install" target to copy libnufx and NufxLib.h
- added "mkinstalldirs"
- fixed a memory leak in NuTest
- made several implicit typecasts explicit for Visual C++'s benefit
- renamed MiscStuff's replacement function to "Nu_function"
- use "rb" or "wb" as fopen arg in sample code for Win32
2000/02/04 fadden 2000/02/05 fadden
- wrote a fair piece of "test-basic" - finished "test-basic"
- added "stickyErr" to "toBuffer" data sink so we can catch overruns - added an "install" target to copy libnufx and NufxLib.h
- added "mkinstalldirs"
- fixed a memory leak in NuTest
- made several implicit typecasts explicit for Visual C++'s benefit
- renamed MiscStuff's replacement function to "Nu_function"
- use "rb" or "wb" as fopen arg in sample code for Win32
2000/02/02 fadden 2000/02/04 fadden
- minor changes to get it working under Win32 (Visual C++ 6.0) - wrote a fair piece of "test-basic"
- added --enable-dmalloc to configuration - added "stickyErr" to "toBuffer" data sink so we can catch overruns
- instead of constantly allocating 16K buffers, use pArchive->compBuf
- ignore DataSink convertEOL value when doExpand is false
2000/02/01 fadden 2000/02/02 fadden
- added system-specific PATH_SEP define for samples (imgconv, exerciser) - minor changes to get it working under Win32 (Visual C++ 6.0)
- set the pathname in ErrorStatus for CRC failures - added --enable-dmalloc to configuration
- instead of constantly allocating 16K buffers, use pArchive->compBuf
- ignore DataSink convertEOL value when doExpand is false
2000/01/31 fadden 2000/02/01 fadden
- fixed a typo causing zero-byte GSHK-damaged files to report CRC errors - added system-specific PATH_SEP define for samples (imgconv, exerciser)
- added support for DOS-ordered 2MG images to "imgconv" - set the pathname in ErrorStatus for CRC failures
2000/01/29 ***** v0.3.0 shipped ***** 2000/01/31 fadden
- fixed a typo causing zero-byte GSHK-damaged files to report CRC errors
- added support for DOS-ordered 2MG images to "imgconv"
2000/01/29 fadden 2000/01/29 ***** v0.3.0 shipped *****
- renamed "tests" to "samples"
- changed library version to x.y.z format (major, minor, bug-fix)
- added DEBUG_VERBOSE define, took some stuff out of DEBUG_MSGS
2000/01/28 fadden 2000/01/29 fadden
- make the Skip result work when an input file can't be opened - renamed "tests" to "samples"
- don't allow leading fssep chars in AddRecord - changed library version to x.y.z format (major, minor, bug-fix)
- don't treat a multi-file BNY that happens to have a ShrinkIt archive - added DEBUG_VERBOSE define, took some stuff out of DEBUG_MSGS
in the first slot as a BXY
- added "-t" flag (write to temp) to "launder"
- in OpenReadWrite, treat zero-length archive files as newly-created
- added workaround for GSHK's zero-byte data fork bug
2000/01/26 fadden 2000/01/28 fadden
- added status result flags to NuFlush - make the Skip result work when an input file can't be opened
- dropped kNuAbortAll and added kNuIgnore - don't allow leading fssep chars in AddRecord
- implemented kNuValueIgnoreCRC - don't treat a multi-file BNY that happens to have a ShrinkIt archive
- update the storageType whenever we change the record in the first slot as a BXY
- added "-t" flag (write to temp) to "launder"
- in OpenReadWrite, treat zero-length archive files as newly-created
- added workaround for GSHK's zero-byte data fork bug
2000/01/25 fadden 2000/01/26 fadden
- don't remove the temp file if the rename fails - added status result flags to NuFlush
- Nu_ReportError now optionally uses a callback instead of stderr - dropped kNuAbortAll and added kNuIgnore
- pass NuArchive* and all the trimmings into Nu_ReportError so we can - implemented kNuValueIgnoreCRC
do the callback thing; required adding arguments to lots of places - update the storageType whenever we change the record
- clearly labeled BailError output as debug-only, then replaced most
of the BailErrorQuiet calls with BailError
- added global error message for when pArchive doesn't exist (e.g. Open)
2000/01/24 fadden 2000/01/25 fadden
- added args to "launder", and made it work right with 0-length threads - don't remove the temp file if the rename fails
- reject disk image threads that aren't a valid size - Nu_ReportError now optionally uses a callback instead of stderr
- in NuFlush, recognize when a "copy" set hasn't had any changes made - pass NuArchive* and all the trimmings into Nu_ReportError so we can
- AddThread no longer makes a copy of the DataSource do the callback thing; required adding arguments to lots of places
- clearly labeled BailError output as debug-only, then replaced most
of the BailErrorQuiet calls with BailError
- added global error message for when pArchive doesn't exist (e.g. Open)
2000/01/24 ***** v0.2 shipped ***** 2000/01/24 fadden
- added args to "launder", and made it work right with 0-length threads
- reject disk image threads that aren't a valid size
- in NuFlush, recognize when a "copy" set hasn't had any changes made
- AddThread no longer makes a copy of the DataSource
2000/01/23 fadden 2000/01/24 ***** v0.2 shipped *****
- added "sec" (Set ErrorHandler Callback) to exerciser
- wrote "launder" test program
- made "doExpand" option on data sinks work
2000/01/22 fadden 2000/01/23 fadden
- added OnlyUpdateOlder attribute and implemented for add and extract - added "sec" (Set ErrorHandler Callback) to exerciser
- made HandleExisting work for AddFile/AddRecord - wrote "launder" test program
- AddThread's validation now blocks data and control threads in same - made "doExpand" option on data sinks work
record
- AddFile and AddRecord now use same validation function as AddThread
2000/01/20 fadden 2000/01/22 fadden
- added Eric Shepherd's BeOS shared lib stuff to configure.in - added OnlyUpdateOlder attribute and implemented for add and extract
- restructed the progress updater, and made it work when adding files - made HandleExisting work for AddFile/AddRecord
- AddThread's validation now blocks data and control threads in same
record
- AddFile and AddRecord now use same validation function as AddThread
2000/01/19 fadden 2000/01/20 fadden
- normalized SysDefs.h, changing UNIX to UNIX_LIKE and defining for BeOS - added Eric Shepherd's BeOS shared lib stuff to configure.in
- added "shared" target to makefile - restructed the progress updater, and made it work when adding files
- added BeOS stuff to autoconf setup
2000/01/17 fadden 2000/01/19 fadden
- fixed Makefile issue preventing "tests" from working with old GNU make - normalized SysDefs.h, changing UNIX to UNIX_LIKE and defining for BeOS
- fixed Lzw.c problem fouling up SunOS gcc v2.5.8 - added "shared" target to makefile
- discovered "<" vs "<=" flapping in GSHK, which I can't Mimic - added BeOS stuff to autoconf setup
- fixed option list dump in debug print
- properly return from all Malloc errors; abort is now debug-only again
- lots of BeOS/Metrowerks "it's not gcc" changes from Eric Shepherd
2000/01/17 ***** v0.1 shipped ***** 2000/01/17 fadden
- fixed Makefile issue preventing "tests" from working with old GNU make
- fixed Lzw.c problem fouling up SunOS gcc v2.5.8
- discovered "<" vs "<=" flapping in GSHK, which I can't Mimic
- fixed option list dump in debug print
- properly return from all Malloc errors; abort is now debug-only again
- lots of BeOS/Metrowerks "it's not gcc" changes from Eric Shepherd
2000/01/17 ***** v0.1 shipped *****
(much time passes) (much time passes)
mid-1998 fadden mid-1998 fadden
- work begins - work begins

6
nufxlib-0/README.txt
View File

@ -69,9 +69,9 @@ DJGPP, follow the UNIX instructions.
NufxLib has been tested with Microsoft Visual C++ 6.0. To build NufxLib, NufxLib has been tested with Microsoft Visual C++ 6.0. To build NufxLib,
start up a DOS shell and run vcvars32.bat to set your environment. Run: start up a DOS shell and run vcvars32.bat to set your environment. Run:
nmake -f makefile.msc nmake -f makefile.msc
to build with debugging info, or to build with debugging info, or
nmake -f makefile.msc nodebug=1 nmake -f makefile.msc nodebug=1
to build optimized. to build optimized.
Once the library has been built, "cd samples" and run the same command there. Once the library has been built, "cd samples" and run the same command there.
@ -81,7 +81,7 @@ When it finishes, run "test-basic.exe".
Other Notes Other Notes
=========== ===========
All of the source code was formatted with four-space hard tabs. All of the source code is now formatted with spaces instead of tabs.
If you want to use the library in a multithreaded application, you should If you want to use the library in a multithreaded application, you should
define "USE_REENTRANT_CALLS" to tell it to use reentrant versions of define "USE_REENTRANT_CALLS" to tell it to use reentrant versions of

34
nufxlib-0/samples/Common.h
View File

@ -9,33 +9,33 @@
#ifndef __Common__ #ifndef __Common__
#define __Common__ #define __Common__
#include "SysDefs.h" /* might as well draft off the autoconf */ #include "SysDefs.h" /* might as well draft off the autoconf */
#include "NufxLib.h" #include "NufxLib.h"
#ifdef USE_DMALLOC #ifdef USE_DMALLOC
# include "dmalloc.h" # include "dmalloc.h"
#endif #endif
#define nil NULL /* this is seriously habit-forming */ #define nil NULL /* this is seriously habit-forming */
#define NELEM(x) (sizeof(x) / sizeof((x)[0])) #define NELEM(x) (sizeof(x) / sizeof((x)[0]))
#ifndef __cplusplus #ifndef __cplusplus
#define false 0 #define false 0
#define true (!false) #define true (!false)
#endif #endif
#ifdef FOPEN_WANTS_B #ifdef FOPEN_WANTS_B
# define kNuFileOpenReadOnly "rb" # define kNuFileOpenReadOnly "rb"
# define kNuFileOpenReadWrite "r+b" # define kNuFileOpenReadWrite "r+b"
# define kNuFileOpenWriteTrunc "wb" # define kNuFileOpenWriteTrunc "wb"
# define kNuFileOpenReadWriteCreat "w+b" # define kNuFileOpenReadWriteCreat "w+b"
#else #else
# define kNuFileOpenReadOnly "r" # define kNuFileOpenReadOnly "r"
# define kNuFileOpenReadWrite "r+" # define kNuFileOpenReadWrite "r+"
# define kNuFileOpenWriteTrunc "w" # define kNuFileOpenWriteTrunc "w"
# define kNuFileOpenReadWriteCreat "w+" # define kNuFileOpenReadWriteCreat "w+"
#endif #endif
@ -44,23 +44,23 @@
*/ */
#ifdef MSDOS #ifdef MSDOS
# define PATH_SEP '\\' # define PATH_SEP '\\'
#endif #endif
#ifdef WIN32 #ifdef WIN32
# define PATH_SEP '\\' # define PATH_SEP '\\'
#endif #endif
#ifdef MACOS #ifdef MACOS
# define PATH_SEP ':' # define PATH_SEP ':'
#endif #endif
#if defined(APW) || defined(__ORCAC__) #if defined(APW) || defined(__ORCAC__)
# define PATH_SEP ':' # define PATH_SEP ':'
#endif #endif
#ifndef PATH_SEP #ifndef PATH_SEP
# define PATH_SEP '/' # define PATH_SEP '/'
#endif #endif
#endif /*__Common__*/ #endif /*__Common__*/

1534
nufxlib-0/samples/Exerciser.c
View File

File diff suppressed because it is too large Load Diff

816
nufxlib-0/samples/ImgConv.c
View File

@ -22,43 +22,43 @@ int Nu_strcasecmp(const char *s1, const char *s2);
#endif #endif
#define kTempFile "imgconv.tmp" #define kTempFile "imgconv.tmp"
#define kLocalFssep PATH_SEP #define kLocalFssep PATH_SEP
#define false 0 #define false 0
#define true (!false) #define true (!false)
/* /*
* =========================================================================== * ===========================================================================
* 2IMG stuff * 2IMG stuff
* =========================================================================== * ===========================================================================
*/ */
#define kImgMagic "2IMG" #define kImgMagic "2IMG"
#define kMyCreator "NFXL" #define kMyCreator "NFXL"
#define kImageFormatDOS 0 #define kImageFormatDOS 0
#define kImageFormatProDOS 1 #define kImageFormatProDOS 1
#define kImageFormatNibble 2 #define kImageFormatNibble 2
/* /*
* 2IMG header definition (http://www.magnet.ch/emutech/Tech/). * 2IMG header definition (http://www.magnet.ch/emutech/Tech/).
*/ */
typedef struct ImgHeader { typedef struct ImgHeader {
char magic[4]; char magic[4];
char creator[4]; char creator[4];
short headerLen; short headerLen;
short version; short version;
long imageFormat; long imageFormat;
unsigned long flags; unsigned long flags;
long numBlocks; long numBlocks;
long dataOffset; long dataOffset;
long dataLen; long dataLen;
long cmntOffset; long cmntOffset;
long cmntLen; long cmntLen;
long creatorOffset; long creatorOffset;
long creatorLen; long creatorLen;
long spare[4]; long spare[4];
} ImgHeader; } ImgHeader;
/* /*
@ -67,8 +67,8 @@ typedef struct ImgHeader {
void void
ReadShortLE(FILE* fp, short* pBuf) ReadShortLE(FILE* fp, short* pBuf)
{ {
*pBuf = getc(fp); *pBuf = getc(fp);
*pBuf += (short) getc(fp) << 8; *pBuf += (short) getc(fp) << 8;
} }
/* /*
@ -77,8 +77,8 @@ ReadShortLE(FILE* fp, short* pBuf)
void void
WriteShortLE(FILE* fp, unsigned short val) WriteShortLE(FILE* fp, unsigned short val)
{ {
putc(val, fp); putc(val, fp);
putc(val >> 8, fp); putc(val >> 8, fp);
} }
/* /*
@ -87,10 +87,10 @@ WriteShortLE(FILE* fp, unsigned short val)
void void
ReadLongLE(FILE* fp, long* pBuf) ReadLongLE(FILE* fp, long* pBuf)
{ {
*pBuf = getc(fp); *pBuf = getc(fp);
*pBuf += (long) getc(fp) << 8; *pBuf += (long) getc(fp) << 8;
*pBuf += (long) getc(fp) << 16; *pBuf += (long) getc(fp) << 16;
*pBuf += (long) getc(fp) << 24; *pBuf += (long) getc(fp) << 24;
} }
/* /*
@ -99,10 +99,10 @@ ReadLongLE(FILE* fp, long* pBuf)
void void
WriteLongLE(FILE* fp, unsigned long val) WriteLongLE(FILE* fp, unsigned long val)
{ {
putc(val, fp); putc(val, fp);
putc(val >> 8, fp); putc(val >> 8, fp);
putc(val >> 16, fp); putc(val >> 16, fp);
putc(val >> 24, fp); putc(val >> 24, fp);
} }
/* /*
@ -111,38 +111,38 @@ WriteLongLE(FILE* fp, unsigned long val)
int int
ReadImgHeader(FILE* fp, ImgHeader* pHeader) ReadImgHeader(FILE* fp, ImgHeader* pHeader)
{ {
fread(pHeader->magic, 4, 1, fp); fread(pHeader->magic, 4, 1, fp);
fread(pHeader->creator, 4, 1, fp); fread(pHeader->creator, 4, 1, fp);
ReadShortLE(fp, &pHeader->headerLen); ReadShortLE(fp, &pHeader->headerLen);
ReadShortLE(fp, &pHeader->version); ReadShortLE(fp, &pHeader->version);
ReadLongLE(fp, &pHeader->imageFormat); ReadLongLE(fp, &pHeader->imageFormat);
ReadLongLE(fp, (long*)&pHeader->flags); ReadLongLE(fp, (long*)&pHeader->flags);
ReadLongLE(fp, &pHeader->numBlocks); ReadLongLE(fp, &pHeader->numBlocks);
ReadLongLE(fp, &pHeader->dataOffset); ReadLongLE(fp, &pHeader->dataOffset);
ReadLongLE(fp, &pHeader->dataLen); ReadLongLE(fp, &pHeader->dataLen);
ReadLongLE(fp, &pHeader->cmntOffset); ReadLongLE(fp, &pHeader->cmntOffset);
ReadLongLE(fp, &pHeader->cmntLen); ReadLongLE(fp, &pHeader->cmntLen);
ReadLongLE(fp, &pHeader->creatorOffset); ReadLongLE(fp, &pHeader->creatorOffset);
ReadLongLE(fp, &pHeader->creatorLen); ReadLongLE(fp, &pHeader->creatorLen);
ReadLongLE(fp, &pHeader->spare[0]); ReadLongLE(fp, &pHeader->spare[0]);
ReadLongLE(fp, &pHeader->spare[1]); ReadLongLE(fp, &pHeader->spare[1]);
ReadLongLE(fp, &pHeader->spare[2]); ReadLongLE(fp, &pHeader->spare[2]);
ReadLongLE(fp, &pHeader->spare[3]); ReadLongLE(fp, &pHeader->spare[3]);
if (feof(fp) || ferror(fp)) if (feof(fp) || ferror(fp))
return -1; return -1;
if (strncmp(pHeader->magic, kImgMagic, 4) != 0) { if (strncmp(pHeader->magic, kImgMagic, 4) != 0) {
fprintf(stderr, "ERROR: bad magic number on 2IMG file\n"); fprintf(stderr, "ERROR: bad magic number on 2IMG file\n");
return -1; return -1;
} }
if (pHeader->version > 1) { if (pHeader->version > 1) {
fprintf(stderr, "WARNING: might not be able to handle version=%d\n", fprintf(stderr, "WARNING: might not be able to handle version=%d\n",
pHeader->version); pHeader->version);
} }
return 0; return 0;
} }
/* /*
@ -151,28 +151,28 @@ ReadImgHeader(FILE* fp, ImgHeader* pHeader)
int int
WriteImgHeader(FILE* fp, ImgHeader* pHeader) WriteImgHeader(FILE* fp, ImgHeader* pHeader)
{ {
fwrite(pHeader->magic, 4, 1, fp); fwrite(pHeader->magic, 4, 1, fp);
fwrite(pHeader->creator, 4, 1, fp); fwrite(pHeader->creator, 4, 1, fp);
WriteShortLE(fp, pHeader->headerLen); WriteShortLE(fp, pHeader->headerLen);
WriteShortLE(fp, pHeader->version); WriteShortLE(fp, pHeader->version);
WriteLongLE(fp, pHeader->imageFormat); WriteLongLE(fp, pHeader->imageFormat);
WriteLongLE(fp, pHeader->flags); WriteLongLE(fp, pHeader->flags);
WriteLongLE(fp, pHeader->numBlocks); WriteLongLE(fp, pHeader->numBlocks);
WriteLongLE(fp, pHeader->dataOffset); WriteLongLE(fp, pHeader->dataOffset);
WriteLongLE(fp, pHeader->dataLen); WriteLongLE(fp, pHeader->dataLen);
WriteLongLE(fp, pHeader->cmntOffset); WriteLongLE(fp, pHeader->cmntOffset);
WriteLongLE(fp, pHeader->cmntLen); WriteLongLE(fp, pHeader->cmntLen);
WriteLongLE(fp, pHeader->creatorOffset); WriteLongLE(fp, pHeader->creatorOffset);
WriteLongLE(fp, pHeader->creatorLen); WriteLongLE(fp, pHeader->creatorLen);
WriteLongLE(fp, pHeader->spare[0]); WriteLongLE(fp, pHeader->spare[0]);
WriteLongLE(fp, pHeader->spare[1]); WriteLongLE(fp, pHeader->spare[1]);
WriteLongLE(fp, pHeader->spare[2]); WriteLongLE(fp, pHeader->spare[2]);
WriteLongLE(fp, pHeader->spare[3]); WriteLongLE(fp, pHeader->spare[3]);
if (ferror(fp)) if (ferror(fp))
return -1; return -1;
return 0; return 0;
} }
@ -182,27 +182,27 @@ WriteImgHeader(FILE* fp, ImgHeader* pHeader)
void void
DumpImgHeader(ImgHeader* pHeader) DumpImgHeader(ImgHeader* pHeader)
{ {
printf("--- header contents:\n"); printf("--- header contents:\n");
printf("\tmagic = '%.4s'\n", pHeader->magic); printf("\tmagic = '%.4s'\n", pHeader->magic);
printf("\tcreator = '%.4s'\n", pHeader->creator); printf("\tcreator = '%.4s'\n", pHeader->creator);
printf("\theaderLen = %d\n", pHeader->headerLen); printf("\theaderLen = %d\n", pHeader->headerLen);
printf("\tversion = %d\n", pHeader->version); printf("\tversion = %d\n", pHeader->version);
printf("\timageFormat = %ld\n", pHeader->imageFormat); printf("\timageFormat = %ld\n", pHeader->imageFormat);
printf("\tflags = 0x%08lx\n", pHeader->flags); printf("\tflags = 0x%08lx\n", pHeader->flags);
printf("\tnumBlocks = %ld\n", pHeader->numBlocks); printf("\tnumBlocks = %ld\n", pHeader->numBlocks);
printf("\tdataOffset = %ld\n", pHeader->dataOffset); printf("\tdataOffset = %ld\n", pHeader->dataOffset);
printf("\tdataLen = %ld\n", pHeader->dataLen); printf("\tdataLen = %ld\n", pHeader->dataLen);
printf("\tcmntOffset = %ld\n", pHeader->cmntOffset); printf("\tcmntOffset = %ld\n", pHeader->cmntOffset);
printf("\tcmntLen = %ld\n", pHeader->cmntLen); printf("\tcmntLen = %ld\n", pHeader->cmntLen);
printf("\tcreatorOffset = %ld\n", pHeader->creatorOffset); printf("\tcreatorOffset = %ld\n", pHeader->creatorOffset);
printf("\tcreatorLen = %ld\n", pHeader->creatorLen); printf("\tcreatorLen = %ld\n", pHeader->creatorLen);
printf("\n"); printf("\n");
} }
/* /*
* =========================================================================== * ===========================================================================
* Main functions * Main functions
* =========================================================================== * ===========================================================================
*/ */
@ -214,10 +214,10 @@ typedef enum ArchiveKind { kKindUnknown, kKindShk, kKindImg } ArchiveKind;
*/ */
NuError NuError
CreateProdosSource(const ImgHeader* pHeader, FILE* fp, CreateProdosSource(const ImgHeader* pHeader, FILE* fp,
NuDataSource** ppDataSource) NuDataSource** ppDataSource)
{ {
return NuCreateDataSourceForFP(kNuThreadFormatUncompressed, false, 0, fp, return NuCreateDataSourceForFP(kNuThreadFormatUncompressed, false, 0, fp,
pHeader->dataOffset, pHeader->dataLen, ppDataSource); pHeader->dataOffset, pHeader->dataLen, ppDataSource);
} }
/* /*
@ -226,76 +226,76 @@ CreateProdosSource(const ImgHeader* pHeader, FILE* fp,
*/ */
NuError NuError
CreateDosSource(const ImgHeader* pHeader, FILE* fp, CreateDosSource(const ImgHeader* pHeader, FILE* fp,
NuDataSource** ppDataSource) NuDataSource** ppDataSource)
{ {
NuError err; NuError err;
char* diskBuffer = nil; char* diskBuffer = nil;
long offset; long offset;
if (pHeader->dataLen % 4096) { if (pHeader->dataLen % 4096) {
fprintf(stderr, fprintf(stderr,
"ERROR: image size must be multiple of 4096 (%ld isn't)\n", "ERROR: image size must be multiple of 4096 (%ld isn't)\n",
pHeader->dataLen); pHeader->dataLen);
err = kNuErrGeneric; err = kNuErrGeneric;
goto bail; goto bail;
} }
if (fseek(fp, pHeader->dataOffset, SEEK_SET) < 0) { if (fseek(fp, pHeader->dataOffset, SEEK_SET) < 0) {
err = errno; err = errno;
perror("fseek failed"); perror("fseek failed");
goto bail; goto bail;
} }
diskBuffer = malloc(pHeader->dataLen); diskBuffer = malloc(pHeader->dataLen);
if (diskBuffer == nil) { if (diskBuffer == nil) {
fprintf(stderr, "ERROR: malloc(%ld) failed\n", pHeader->dataLen); fprintf(stderr, "ERROR: malloc(%ld) failed\n", pHeader->dataLen);
err = kNuErrMalloc; err = kNuErrMalloc;
goto bail; goto bail;
} }
/* /*
* Run through the image, reordering each track. This is a * Run through the image, reordering each track. This is a
* reversible transformation, i.e. if you do this twice you're back * reversible transformation, i.e. if you do this twice you're back
* to ProDOS ordering. * to ProDOS ordering.
*/ */
for (offset = 0; offset < pHeader->dataLen; offset += 4096) { for (offset = 0; offset < pHeader->dataLen; offset += 4096) {
fread(diskBuffer + offset + 0x0000, 256, 1, fp); fread(diskBuffer + offset + 0x0000, 256, 1, fp);
fread(diskBuffer + offset + 0x0e00, 256, 1, fp); fread(diskBuffer + offset + 0x0e00, 256, 1, fp);
fread(diskBuffer + offset + 0x0d00, 256, 1, fp); fread(diskBuffer + offset + 0x0d00, 256, 1, fp);
fread(diskBuffer + offset + 0x0c00, 256, 1, fp); fread(diskBuffer + offset + 0x0c00, 256, 1, fp);
fread(diskBuffer + offset + 0x0b00, 256, 1, fp); fread(diskBuffer + offset + 0x0b00, 256, 1, fp);
fread(diskBuffer + offset + 0x0a00, 256, 1, fp); fread(diskBuffer + offset + 0x0a00, 256, 1, fp);
fread(diskBuffer + offset + 0x0900, 256, 1, fp); fread(diskBuffer + offset + 0x0900, 256, 1, fp);
fread(diskBuffer + offset + 0x0800, 256, 1, fp); fread(diskBuffer + offset + 0x0800, 256, 1, fp);
fread(diskBuffer + offset + 0x0700, 256, 1, fp); fread(diskBuffer + offset + 0x0700, 256, 1, fp);
fread(diskBuffer + offset + 0x0600, 256, 1, fp); fread(diskBuffer + offset + 0x0600, 256, 1, fp);
fread(diskBuffer + offset + 0x0500, 256, 1, fp); fread(diskBuffer + offset + 0x0500, 256, 1, fp);
fread(diskBuffer + offset + 0x0400, 256, 1, fp); fread(diskBuffer + offset + 0x0400, 256, 1, fp);
fread(diskBuffer + offset + 0x0300, 256, 1, fp); fread(diskBuffer + offset + 0x0300, 256, 1, fp);
fread(diskBuffer + offset + 0x0200, 256, 1, fp); fread(diskBuffer + offset + 0x0200, 256, 1, fp);
fread(diskBuffer + offset + 0x0100, 256, 1, fp); fread(diskBuffer + offset + 0x0100, 256, 1, fp);
fread(diskBuffer + offset + 0x0f00, 256, 1, fp); fread(diskBuffer + offset + 0x0f00, 256, 1, fp);
} }
if (feof(fp) || ferror(fp)) { if (feof(fp) || ferror(fp)) {
err = errno ? errno : -1; err = errno ? errno : -1;
fprintf(stderr, "ERROR: failed while reading source file\n"); fprintf(stderr, "ERROR: failed while reading source file\n");
goto bail; goto bail;
} }
/* /*
* Create a data source for the buffer. We set the "doClose" flag to * Create a data source for the buffer. We set the "doClose" flag to
* "true", so NufxLib will free the buffer for us. * "true", so NufxLib will free the buffer for us.
*/ */
err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed, true, 0, err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed, true, 0,
(const unsigned char*) diskBuffer, 0, pHeader->dataLen, (const unsigned char*) diskBuffer, 0, pHeader->dataLen,
ppDataSource); ppDataSource);
if (err == kNuErrNone) if (err == kNuErrNone)
diskBuffer = nil; diskBuffer = nil;
bail: bail:
if (diskBuffer != nil) if (diskBuffer != nil)
free(diskBuffer); free(diskBuffer);
return err; return err;
} }
@ -309,146 +309,146 @@ bail:
int int
ConvertFromImgToShk(const char* srcName, const char* dstName) ConvertFromImgToShk(const char* srcName, const char* dstName)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
NuDataSource* pDataSource = nil; NuDataSource* pDataSource = nil;
NuRecordIdx recordIdx; NuRecordIdx recordIdx;
NuFileDetails fileDetails; NuFileDetails fileDetails;
ImgHeader header; ImgHeader header;
FILE* fp = nil; FILE* fp = nil;
long flushStatus; long flushStatus;
char* storageName = nil; char* storageName = nil;
char* cp; char* cp;
printf("Converting 2IMG file '%s' to ShrinkIt archive '%s'\n\n", printf("Converting 2IMG file '%s' to ShrinkIt archive '%s'\n\n",
srcName, dstName); srcName, dstName);
err = kNuErrGeneric; err = kNuErrGeneric;
fp = fopen(srcName, kNuFileOpenReadOnly); fp = fopen(srcName, kNuFileOpenReadOnly);
if (fp == NULL) { if (fp == NULL) {
perror("fopen failed"); perror("fopen failed");
goto bail; goto bail;
} }
if (ReadImgHeader(fp, &header) < 0) { if (ReadImgHeader(fp, &header) < 0) {
fprintf(stderr, "ERROR: header read failed\n"); fprintf(stderr, "ERROR: header read failed\n");
goto bail; goto bail;
} }
DumpImgHeader(&header); DumpImgHeader(&header);
if (header.imageFormat != kImageFormatDOS && if (header.imageFormat != kImageFormatDOS &&
header.imageFormat != kImageFormatProDOS) header.imageFormat != kImageFormatProDOS)
{ {
fprintf(stderr, "ERROR: can only handle DOS and ProDOS images\n"); fprintf(stderr, "ERROR: can only handle DOS and ProDOS images\n");
goto bail; goto bail;
} }
if (header.numBlocks > 1600) if (header.numBlocks > 1600)
printf("WARNING: that's a big honking image!\n"); printf("WARNING: that's a big honking image!\n");
/* /*
* Open a new archive read-write. This refuses to overwrite an * Open a new archive read-write. This refuses to overwrite an
* existing file. * existing file.
*/ */
(void) unlink(kTempFile); (void) unlink(kTempFile);
err = NuOpenRW(dstName, kTempFile, kNuOpenCreat|kNuOpenExcl, &pArchive); err = NuOpenRW(dstName, kTempFile, kNuOpenCreat|kNuOpenExcl, &pArchive);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to create archive (err=%d)\n", err); fprintf(stderr, "ERROR: unable to create archive (err=%d)\n", err);
goto bail; goto bail;
} }
/* create the name that will be stored in the archive */ /* create the name that will be stored in the archive */
storageName = strdup(dstName); storageName = strdup(dstName);
cp = strrchr(storageName, '.'); cp = strrchr(storageName, '.');
if (cp != nil) if (cp != nil)
*cp = '\0'; *cp = '\0';
cp = strrchr(storageName, kLocalFssep); cp = strrchr(storageName, kLocalFssep);
if (cp != nil && *(cp+1) != '\0') if (cp != nil && *(cp+1) != '\0')
cp++; cp++;
else else
cp = storageName; cp = storageName;
/* /*
* We can't say "add file", because NufxLib doesn't know what a 2MG * We can't say "add file", because NufxLib doesn't know what a 2MG
* archive is. However, we can point a DataSource at the data in * archive is. However, we can point a DataSource at the data in
* the file, and construct the record manually. * the file, and construct the record manually.
*/ */
/* set up the contents of the NuFX Record */ /* set up the contents of the NuFX Record */
memset(&fileDetails, 0, sizeof(fileDetails)); memset(&fileDetails, 0, sizeof(fileDetails));
fileDetails.storageName = cp; fileDetails.storageName = cp;
fileDetails.fileSysID = kNuFileSysUnknown; /* DOS? ProDOS? */ fileDetails.fileSysID = kNuFileSysUnknown; /* DOS? ProDOS? */
fileDetails.fileSysInfo = kLocalFssep; fileDetails.fileSysInfo = kLocalFssep;
fileDetails.access = kNuAccessUnlocked; fileDetails.access = kNuAccessUnlocked;
fileDetails.extraType = header.numBlocks; fileDetails.extraType = header.numBlocks;
fileDetails.storageType = 512; fileDetails.storageType = 512;
/* FIX - ought to set the file dates */ /* FIX - ought to set the file dates */
/* add a new record */ /* add a new record */
err = NuAddRecord(pArchive, &fileDetails, &recordIdx); err = NuAddRecord(pArchive, &fileDetails, &recordIdx);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to create record (err=%d)\n", err); fprintf(stderr, "ERROR: unable to create record (err=%d)\n", err);
goto bail; goto bail;
} }
/* /*
* Create a data source for the 2IMG file. We do this differently * Create a data source for the 2IMG file. We do this differently
* for DOS and ProDOS, because we have to rearrange the sector * for DOS and ProDOS, because we have to rearrange the sector
* ordering for DOS-ordered images (ShrinkIt always uses ProDOS order). * ordering for DOS-ordered images (ShrinkIt always uses ProDOS order).
*/ */
switch (header.imageFormat) { switch (header.imageFormat) {
case kImageFormatDOS: case kImageFormatDOS:
err = CreateDosSource(&header, fp, &pDataSource); err = CreateDosSource(&header, fp, &pDataSource);
break; break;
case kImageFormatProDOS: case kImageFormatProDOS:
err = CreateProdosSource(&header, fp, &pDataSource); err = CreateProdosSource(&header, fp, &pDataSource);
break; break;
default: default:
fprintf(stderr, "How the heck did I get here?"); fprintf(stderr, "How the heck did I get here?");
err = kNuErrInternal; err = kNuErrInternal;
goto bail; goto bail;
} }
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to create data source (err=%d)\n", err); fprintf(stderr, "ERROR: unable to create data source (err=%d)\n", err);
goto bail; goto bail;
} }
/* add a disk image thread */ /* add a disk image thread */
err = NuAddThread(pArchive, recordIdx, kNuThreadIDDiskImage, pDataSource, err = NuAddThread(pArchive, recordIdx, kNuThreadIDDiskImage, pDataSource,
nil); nil);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to create thread (err=%d)\n", err); fprintf(stderr, "ERROR: unable to create thread (err=%d)\n", err);
goto bail; goto bail;
} }
pDataSource = nil; /* library owns it now */ pDataSource = nil; /* library owns it now */
/* nothing happens until we Flush */ /* nothing happens until we Flush */
err = NuFlush(pArchive, &flushStatus); err = NuFlush(pArchive, &flushStatus);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: flush failed (err=%d, status=0x%04lx)\n", fprintf(stderr, "ERROR: flush failed (err=%d, status=0x%04lx)\n",
err, flushStatus); err, flushStatus);
goto bail; goto bail;
} }
err = NuClose(pArchive); err = NuClose(pArchive);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: close failed (err=%d)\n", err); fprintf(stderr, "ERROR: close failed (err=%d)\n", err);
goto bail; goto bail;
} }
pArchive = nil; pArchive = nil;
bail: bail:
if (pArchive != nil) { if (pArchive != nil) {
(void)NuAbort(pArchive); (void)NuAbort(pArchive);
(void)NuClose(pArchive); (void)NuClose(pArchive);
} }
NuFreeDataSource(pDataSource); NuFreeDataSource(pDataSource);
if (storageName != nil) if (storageName != nil)
free(storageName); free(storageName);
if (fp != nil) if (fp != nil)
fclose(fp); fclose(fp);
return (err == kNuErrNone) ? 0 : -1; return (err == kNuErrNone) ? 0 : -1;
} }
@ -461,109 +461,109 @@ bail:
int int
ConvertFromShkToImg(const char* srcName, const char* dstName) ConvertFromShkToImg(const char* srcName, const char* dstName)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
NuDataSink* pDataSink = nil; NuDataSink* pDataSink = nil;
NuRecordIdx recordIdx; NuRecordIdx recordIdx;
const NuRecord* pRecord; const NuRecord* pRecord;
const NuThread* pThread = nil; const NuThread* pThread = nil;
ImgHeader header; ImgHeader header;
FILE* fp = nil; FILE* fp = nil;
int idx; int idx;
printf("Converting ShrinkIt archive '%s' to 2IMG file '%s'\n\n", printf("Converting ShrinkIt archive '%s' to 2IMG file '%s'\n\n",
srcName, dstName); srcName, dstName);
/* /*
* Open the archive. * Open the archive.
*/ */
err = NuOpenRO(srcName, &pArchive); err = NuOpenRO(srcName, &pArchive);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to open archive (err=%d)\n", err); fprintf(stderr, "ERROR: unable to open archive (err=%d)\n", err);
goto bail; goto bail;
} }
/* get the first record */ /* get the first record */
err = NuGetRecordIdxByPosition(pArchive, 0, &recordIdx); err = NuGetRecordIdxByPosition(pArchive, 0, &recordIdx);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to get first recordIdx (err=%d)\n", err); fprintf(stderr, "ERROR: unable to get first recordIdx (err=%d)\n", err);
goto bail; goto bail;
} }
err = NuGetRecord(pArchive, recordIdx, &pRecord); err = NuGetRecord(pArchive, recordIdx, &pRecord);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to get first record (err=%d)\n", err); fprintf(stderr, "ERROR: unable to get first record (err=%d)\n", err);
goto bail; goto bail;
} }
/* find a disk image thread */ /* find a disk image thread */
for (idx = 0; idx < (int)NuRecordGetNumThreads(pRecord); idx++) { for (idx = 0; idx < (int)NuRecordGetNumThreads(pRecord); idx++) {
pThread = NuGetThread(pRecord, idx); pThread = NuGetThread(pRecord, idx);
if (NuGetThreadID(pThread) == kNuThreadIDDiskImage) if (NuGetThreadID(pThread) == kNuThreadIDDiskImage)
break; break;
} }
if (idx == (int)NuRecordGetNumThreads(pRecord)) { if (idx == (int)NuRecordGetNumThreads(pRecord)) {
fprintf(stderr, "ERROR: no disk image found in first record\n"); fprintf(stderr, "ERROR: no disk image found in first record\n");
err = -1; err = -1;
goto bail; goto bail;
} }
/* /*
* Looks good. Open the 2IMG file, and create the header. * Looks good. Open the 2IMG file, and create the header.
*/ */
if (access(dstName, F_OK) == 0) { if (access(dstName, F_OK) == 0) {
fprintf(stderr, "ERROR: output file already exists\n"); fprintf(stderr, "ERROR: output file already exists\n");
err = -1; err = -1;
goto bail; goto bail;
} }
fp = fopen(dstName, kNuFileOpenWriteTrunc); fp = fopen(dstName, kNuFileOpenWriteTrunc);
if (fp == NULL) { if (fp == NULL) {
perror("fopen failed"); perror("fopen failed");
goto bail; goto bail;
} }
/* set up the 2MG header, based on the NuFX Record */ /* set up the 2MG header, based on the NuFX Record */
memset(&header, 0, sizeof(header)); memset(&header, 0, sizeof(header));
memcpy(header.magic, kImgMagic, sizeof(header.magic)); memcpy(header.magic, kImgMagic, sizeof(header.magic));
memcpy(header.creator, kMyCreator, sizeof(header.creator)); memcpy(header.creator, kMyCreator, sizeof(header.creator));
header.headerLen = 64; header.headerLen = 64;
header.version = 1; header.version = 1;
header.imageFormat = kImageFormatProDOS; /* always ProDOS-order */ header.imageFormat = kImageFormatProDOS; /* always ProDOS-order */
header.numBlocks = pRecord->recExtraType; header.numBlocks = pRecord->recExtraType;
header.dataOffset = 64; header.dataOffset = 64;
/* old versions of ShrinkIt blew the threadEOF, so use NufxLib's "actual" */ /* old versions of ShrinkIt blew the threadEOF, so use NufxLib's "actual" */
header.dataLen = pThread->actualThreadEOF; header.dataLen = pThread->actualThreadEOF;
DumpImgHeader(&header); DumpImgHeader(&header);
if (WriteImgHeader(fp, &header) < 0) { if (WriteImgHeader(fp, &header) < 0) {
fprintf(stderr, "ERROR: header write failed\n"); fprintf(stderr, "ERROR: header write failed\n");
err = -1; err = -1;
goto bail; goto bail;
} }
/* /*
* We want to expand the disk image thread into "fp" at the current * We want to expand the disk image thread into "fp" at the current
* offset. * offset.
*/ */
err = NuCreateDataSinkForFP(true, kNuConvertOff, fp, &pDataSink); err = NuCreateDataSinkForFP(true, kNuConvertOff, fp, &pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to create data sink (err=%d)\n", err); fprintf(stderr, "ERROR: unable to create data sink (err=%d)\n", err);
goto bail; goto bail;
} }
err = NuExtractThread(pArchive, pThread->threadIdx, pDataSink); err = NuExtractThread(pArchive, pThread->threadIdx, pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to extract thread (err=%d)\n", err); fprintf(stderr, "ERROR: unable to extract thread (err=%d)\n", err);
goto bail; goto bail;
} }
bail: bail:
if (pArchive != nil) if (pArchive != nil)
NuClose(pArchive); NuClose(pArchive);
NuFreeDataSink(pDataSink); NuFreeDataSink(pDataSink);
if (fp != nil) if (fp != nil)
fclose(fp); fclose(fp);
return (err == kNuErrNone) ? 0 : -1; return (err == kNuErrNone) ? 0 : -1;
} }
@ -573,18 +573,18 @@ bail:
ArchiveKind ArchiveKind
DetermineKind(const char* filename) DetermineKind(const char* filename)
{ {
const char* dot; const char* dot;
dot = strrchr(filename, '.'); dot = strrchr(filename, '.');
if (dot == nil) if (dot == nil)
return kKindUnknown; return kKindUnknown;
if (strcasecmp(dot, ".shk") == 0 || strcasecmp(dot, ".sdk") == 0) if (strcasecmp(dot, ".shk") == 0 || strcasecmp(dot, ".sdk") == 0)
return kKindShk; return kKindShk;
else if (strcasecmp(dot, ".2mg") == 0) else if (strcasecmp(dot, ".2mg") == 0)
return kKindImg; return kKindImg;
return kKindUnknown; return kKindUnknown;
} }
@ -595,30 +595,30 @@ DetermineKind(const char* filename)
int int
main(int argc, char** argv) main(int argc, char** argv)
{ {
ArchiveKind kind; ArchiveKind kind;
int cc; int cc;
if (argc != 3) { if (argc != 3) {
fprintf(stderr, "Usage: %s (input.2mg|input.shk) output\n", argv[0]); fprintf(stderr, "Usage: %s (input.2mg|input.shk) output\n", argv[0]);
exit(2); exit(2);
} }
kind = DetermineKind(argv[1]); kind = DetermineKind(argv[1]);
if (kind == kKindUnknown) { if (kind == kKindUnknown) {
fprintf(stderr, "ERROR: input name must end in '.shk' or '.2mg'\n"); fprintf(stderr, "ERROR: input name must end in '.shk' or '.2mg'\n");
exit(2); exit(2);
} }
if (kind == kKindShk) if (kind == kKindShk)
cc = ConvertFromShkToImg(argv[1], argv[2]); cc = ConvertFromShkToImg(argv[1], argv[2]);
else else
cc = ConvertFromImgToShk(argv[1], argv[2]); cc = ConvertFromImgToShk(argv[1], argv[2]);
if (cc) if (cc)
fprintf(stderr, "Failed\n"); fprintf(stderr, "Failed\n");
else else
printf("Done!\n"); printf("Done!\n");
exit(cc != 0); exit(cc != 0);
} }

830
nufxlib-0/samples/Launder.c
View File

@ -29,13 +29,13 @@
#include "Common.h" #include "Common.h"
#define kTempFile "tmp-laundry" #define kTempFile "tmp-laundry"
#define kFlagCopyOnly (1) #define kFlagCopyOnly (1)
#define kFlagReverseThreads (1 << 1) #define kFlagReverseThreads (1 << 1)
#define kFlagFrequentFlush (1 << 2) #define kFlagFrequentFlush (1 << 2)
#define kFlagFrequentAbort (1 << 3) /* implies FrequentFlush */ #define kFlagFrequentAbort (1 << 3) /* implies FrequentFlush */
#define kFlagUseTmp (1 << 4) #define kFlagUseTmp (1 << 4)
/* /*
@ -53,99 +53,99 @@ char gSentRecordWarning = false;
*/ */
NuError NuError
CopyThreadRecompressed(NuArchive* pInArchive, NuArchive* pOutArchive, CopyThreadRecompressed(NuArchive* pInArchive, NuArchive* pOutArchive,
long flags, const NuThread* pThread, long newRecordIdx) long flags, const NuThread* pThread, long newRecordIdx)
{ {
NuError err = kNuErrNone; NuError err = kNuErrNone;
NuDataSource* pDataSource = nil; NuDataSource* pDataSource = nil;
NuDataSink* pDataSink = nil; NuDataSink* pDataSink = nil;
uchar* buffer = nil; uchar* buffer = nil;
/* /*
* Allocate a buffer large enough to hold all the uncompressed data, and * Allocate a buffer large enough to hold all the uncompressed data, and
* wrap a data sink around it. * wrap a data sink around it.
* *
* If the thread is zero bytes long, we can skip this part. * If the thread is zero bytes long, we can skip this part.
*/ */
if (pThread->actualThreadEOF) { if (pThread->actualThreadEOF) {
buffer = malloc(pThread->actualThreadEOF); buffer = malloc(pThread->actualThreadEOF);
if (buffer == nil) { if (buffer == nil) {
err = kNuErrMalloc; err = kNuErrMalloc;
goto bail; goto bail;
} }
err = NuCreateDataSinkForBuffer(true, kNuConvertOff, buffer, err = NuCreateDataSinkForBuffer(true, kNuConvertOff, buffer,
pThread->actualThreadEOF, &pDataSink); pThread->actualThreadEOF, &pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to create data sink (err=%d)\n", fprintf(stderr, "ERROR: unable to create data sink (err=%d)\n",
err); err);
goto bail; goto bail;
} }
/* /*
* Expand the data. For a pre-sized thread, this grabs only the * Expand the data. For a pre-sized thread, this grabs only the
* interesting part of the buffer. * interesting part of the buffer.
*/ */
err = NuExtractThread(pInArchive, pThread->threadIdx, pDataSink); err = NuExtractThread(pInArchive, pThread->threadIdx, pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to extract thread %ld (err=%d)\n", fprintf(stderr, "ERROR: unable to extract thread %ld (err=%d)\n",
pThread->threadIdx, err); pThread->threadIdx, err);
goto bail; goto bail;
} }
} }
/* /*
* The expanded data is in the buffer, now create a data source that * The expanded data is in the buffer, now create a data source that
* describes it. * describes it.
* *
* This is complicated by the existence of pre-sized threads, which * This is complicated by the existence of pre-sized threads, which
* require us to set "otherLen". * require us to set "otherLen".
* *
* We always use "actualThreadEOF" because "thThreadEOF" is broken * We always use "actualThreadEOF" because "thThreadEOF" is broken
* for disk archives created by certain versions of ShrinkIt. * for disk archives created by certain versions of ShrinkIt.
* *
* It's okay to pass in a nil value for "buffer", so long as the * It's okay to pass in a nil value for "buffer", so long as the
* amount of data in the buffer is also zero. The library will do * amount of data in the buffer is also zero. The library will do
* the right thing. * the right thing.
*/ */
if (NuIsPresizedThreadID(NuGetThreadID(pThread))) { if (NuIsPresizedThreadID(NuGetThreadID(pThread))) {
err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed, true, err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed, true,
pThread->thCompThreadEOF, buffer, 0, pThread->thCompThreadEOF, buffer, 0,
pThread->actualThreadEOF, &pDataSource); pThread->actualThreadEOF, &pDataSource);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, fprintf(stderr,
"ERROR: unable to create pre-sized data source (err=%d)\n",err); "ERROR: unable to create pre-sized data source (err=%d)\n",err);
goto bail; goto bail;
} }
} else { } else {
err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed, true, err = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed, true,
0, buffer, 0, 0, buffer, 0,
pThread->actualThreadEOF, &pDataSource); pThread->actualThreadEOF, &pDataSource);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, fprintf(stderr,
"ERROR: unable to create data source (err=%d)\n", err); "ERROR: unable to create data source (err=%d)\n", err);
goto bail; goto bail;
} }
} }
buffer = nil; /* doClose was set, so it's owned by the data source */ buffer = nil; /* doClose was set, so it's owned by the data source */
/* /*
* Schedule the data for addition to the record. * Schedule the data for addition to the record.
*/ */
err = NuAddThread(pOutArchive, newRecordIdx, NuGetThreadID(pThread), err = NuAddThread(pOutArchive, newRecordIdx, NuGetThreadID(pThread),
pDataSource, nil); pDataSource, nil);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to add thread (err=%d)\n", err); fprintf(stderr, "ERROR: unable to add thread (err=%d)\n", err);
goto bail; goto bail;
} }
pDataSource = nil; /* library owns it now */ pDataSource = nil; /* library owns it now */
bail: bail:
if (pDataSource != nil) if (pDataSource != nil)
NuFreeDataSource(pDataSource); NuFreeDataSource(pDataSource);
if (pDataSink != nil) if (pDataSink != nil)
NuFreeDataSink(pDataSink); NuFreeDataSink(pDataSink);
if (buffer != nil) if (buffer != nil)
free(buffer); free(buffer);
return err; return err;
} }
/* /*
@ -167,122 +167,122 @@ bail:
*/ */
NuError NuError
CopyThreadUncompressed(NuArchive* pInArchive, NuArchive* pOutArchive, CopyThreadUncompressed(NuArchive* pInArchive, NuArchive* pOutArchive,
long flags, const NuThread* pThread, long newRecordIdx) long flags, const NuThread* pThread, long newRecordIdx)
{ {
NuError err = kNuErrNone; NuError err = kNuErrNone;
NuDataSource* pDataSource = nil; NuDataSource* pDataSource = nil;
NuDataSink* pDataSink = nil; NuDataSink* pDataSink = nil;
uchar* buffer = nil; uchar* buffer = nil;
/* /*
* If we have some data files that were left uncompressed, perhaps * If we have some data files that were left uncompressed, perhaps
* because of GSHK's "don't compress anything smaller than 512 bytes" * because of GSHK's "don't compress anything smaller than 512 bytes"
* rule, NufxLib will try to compress them. We disable this * rule, NufxLib will try to compress them. We disable this
* behavior by disabling compression. That way, stuff that is * behavior by disabling compression. That way, stuff that is
* already compressed will remain that way, and stuff that isn't * already compressed will remain that way, and stuff that isn't
* compressed won't be. (We really only need to do this once, at * compressed won't be. (We really only need to do this once, at
* the start of the program, but it's illustrative to do it here.) * the start of the program, but it's illustrative to do it here.)
*/ */
err = NuSetValue(pOutArchive, kNuValueDataCompression, kNuCompressNone); err = NuSetValue(pOutArchive, kNuValueDataCompression, kNuCompressNone);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to set compression (err=%d)\n", err); fprintf(stderr, "ERROR: unable to set compression (err=%d)\n", err);
goto bail; goto bail;
} }
/* /*
* Allocate a buffer large enough to hold all the compressed data, and * Allocate a buffer large enough to hold all the compressed data, and
* wrap a data sink around it. * wrap a data sink around it.
*/ */
buffer = malloc(pThread->thCompThreadEOF); buffer = malloc(pThread->thCompThreadEOF);
if (buffer == nil) { if (buffer == nil) {
err = kNuErrMalloc; err = kNuErrMalloc;
goto bail; goto bail;
} }
err = NuCreateDataSinkForBuffer(false, kNuConvertOff, buffer, err = NuCreateDataSinkForBuffer(false, kNuConvertOff, buffer,
pThread->thCompThreadEOF, &pDataSink); pThread->thCompThreadEOF, &pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to create data sink (err=%d)\n", fprintf(stderr, "ERROR: unable to create data sink (err=%d)\n",
err); err);
goto bail; goto bail;
} }
/* /*
* Get the compressed data. For a pre-sized thread, this grabs the * Get the compressed data. For a pre-sized thread, this grabs the
* entire contents of the buffer, including the padding. * entire contents of the buffer, including the padding.
*/ */
err = NuExtractThread(pInArchive, pThread->threadIdx, pDataSink); err = NuExtractThread(pInArchive, pThread->threadIdx, pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to extract thread %ld (err=%d)\n", fprintf(stderr, "ERROR: unable to extract thread %ld (err=%d)\n",
pThread->threadIdx, err); pThread->threadIdx, err);
goto bail; goto bail;
} }
/* /*
* The (perhaps compressed) data is in the buffer, now create a data * The (perhaps compressed) data is in the buffer, now create a data
* source that describes it. * source that describes it.
* *
* This is complicated by the existence of pre-sized threads. There * This is complicated by the existence of pre-sized threads. There
* are two possibilities: * are two possibilities:
* 1. We have a certain amount of non-pre-sized data (thCompThreadEOF) * 1. We have a certain amount of non-pre-sized data (thCompThreadEOF)
* that will expand out to a certain length (actualThreadEOF). * that will expand out to a certain length (actualThreadEOF).
* 2. We have a certain amount of pre-sized data (actualThreadEOF) * 2. We have a certain amount of pre-sized data (actualThreadEOF)
* that will fit within a buffer (thCompThreadEOF). * that will fit within a buffer (thCompThreadEOF).
* As you can see, the arguments need to be reversed for pre-sized * As you can see, the arguments need to be reversed for pre-sized
* threads. * threads.
* *
* We always use "actualThreadEOF" because "thThreadEOF" is broken * We always use "actualThreadEOF" because "thThreadEOF" is broken
* for disk archives created by certain versions of ShrinkIt. * for disk archives created by certain versions of ShrinkIt.
*/ */
if (NuIsPresizedThreadID(NuGetThreadID(pThread))) { if (NuIsPresizedThreadID(NuGetThreadID(pThread))) {
err = NuCreateDataSourceForBuffer(pThread->thThreadFormat, true, err = NuCreateDataSourceForBuffer(pThread->thThreadFormat, true,
pThread->thCompThreadEOF, buffer, 0, pThread->thCompThreadEOF, buffer, 0,
pThread->actualThreadEOF, &pDataSource); pThread->actualThreadEOF, &pDataSource);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, fprintf(stderr,
"ERROR: unable to create pre-sized data source (err=%d)\n",err); "ERROR: unable to create pre-sized data source (err=%d)\n",err);
goto bail; goto bail;
} }
} else { } else {
err = NuCreateDataSourceForBuffer(pThread->thThreadFormat, true, err = NuCreateDataSourceForBuffer(pThread->thThreadFormat, true,
pThread->actualThreadEOF, buffer, 0, pThread->actualThreadEOF, buffer, 0,
pThread->thCompThreadEOF, &pDataSource); pThread->thCompThreadEOF, &pDataSource);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, fprintf(stderr,
"ERROR: unable to create data source (err=%d)\n", err); "ERROR: unable to create data source (err=%d)\n", err);
goto bail; goto bail;
} }
} }
buffer = nil; /* doClose was set, so it's owned by the data source */ buffer = nil; /* doClose was set, so it's owned by the data source */
/* yes, this is a kluge... sigh */ /* yes, this is a kluge... sigh */
err = NuDataSourceSetRawCrc(pDataSource, pThread->thThreadCRC); err = NuDataSourceSetRawCrc(pDataSource, pThread->thThreadCRC);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: can't set source CRC (err=%d)\n", err); fprintf(stderr, "ERROR: can't set source CRC (err=%d)\n", err);
goto bail; goto bail;
} }
/* /*
* Schedule the data for addition to the record. * Schedule the data for addition to the record.
* *
* Note that NuAddThread makes a copy of the data source, and clears * Note that NuAddThread makes a copy of the data source, and clears
* "doClose" on our copy, so we are free to dispose of pDataSource. * "doClose" on our copy, so we are free to dispose of pDataSource.
*/ */
err = NuAddThread(pOutArchive, newRecordIdx, NuGetThreadID(pThread), err = NuAddThread(pOutArchive, newRecordIdx, NuGetThreadID(pThread),
pDataSource, nil); pDataSource, nil);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to add thread (err=%d)\n", err); fprintf(stderr, "ERROR: unable to add thread (err=%d)\n", err);
goto bail; goto bail;
} }
pDataSource = nil; /* library owns it now */ pDataSource = nil; /* library owns it now */
bail: bail:
if (pDataSource != nil) if (pDataSource != nil)
NuFreeDataSource(pDataSource); NuFreeDataSource(pDataSource);
if (pDataSink != nil) if (pDataSink != nil)
NuFreeDataSink(pDataSink); NuFreeDataSink(pDataSink);
if (buffer != nil) if (buffer != nil)
free(buffer); free(buffer);
return err; return err;
} }
@ -294,15 +294,15 @@ bail:
*/ */
NuError NuError
CopyThread(NuArchive* pInArchive, NuArchive* pOutArchive, long flags, CopyThread(NuArchive* pInArchive, NuArchive* pOutArchive, long flags,
const NuThread* pThread, long newRecordIdx) const NuThread* pThread, long newRecordIdx)
{ {
if (flags & kFlagCopyOnly) { if (flags & kFlagCopyOnly) {
return CopyThreadUncompressed(pInArchive, pOutArchive, flags, pThread, return CopyThreadUncompressed(pInArchive, pOutArchive, flags, pThread,
newRecordIdx); newRecordIdx);
} else { } else {
return CopyThreadRecompressed(pInArchive, pOutArchive, flags, pThread, return CopyThreadRecompressed(pInArchive, pOutArchive, flags, pThread,
newRecordIdx); newRecordIdx);
} }
} }
@ -316,91 +316,91 @@ CopyThread(NuArchive* pInArchive, NuArchive* pOutArchive, long flags,
*/ */
NuError NuError
CopyRecord(NuArchive* pInArchive, NuArchive* pOutArchive, long flags, CopyRecord(NuArchive* pInArchive, NuArchive* pOutArchive, long flags,
NuRecordIdx recordIdx) NuRecordIdx recordIdx)
{ {
NuError err = kNuErrNone; NuError err = kNuErrNone;
const NuRecord* pRecord; const NuRecord* pRecord;
const NuThread* pThread; const NuThread* pThread;
NuFileDetails fileDetails; NuFileDetails fileDetails;
NuRecordIdx newRecordIdx; NuRecordIdx newRecordIdx;
long numThreads; long numThreads;
int idx; int idx;
/* /*
* Grab the original record and see how many threads it has. * Grab the original record and see how many threads it has.
*/ */
err = NuGetRecord(pInArchive, recordIdx, &pRecord); err = NuGetRecord(pInArchive, recordIdx, &pRecord);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to get recordIdx %ld\n", recordIdx); fprintf(stderr, "ERROR: unable to get recordIdx %ld\n", recordIdx);
goto bail; goto bail;
} }
/* /*
* Pre-v3 records didn't put CRCs in the thread headers. If we just * Pre-v3 records didn't put CRCs in the thread headers. If we just
* copy the thread over without reprocessing the data, we won't compute * copy the thread over without reprocessing the data, we won't compute
* a CRC for the thread, and we will get CRC failures. * a CRC for the thread, and we will get CRC failures.
*/ */
if (!gSentRecordWarning && (flags & kFlagCopyOnly) && if (!gSentRecordWarning && (flags & kFlagCopyOnly) &&
pRecord->recVersionNumber < 3) pRecord->recVersionNumber < 3)
{ {
printf("WARNING: pre-v3 records that aren't recompressed may exhibit CRC failures\n"); printf("WARNING: pre-v3 records that aren't recompressed may exhibit CRC failures\n");
gSentRecordWarning = true; gSentRecordWarning = true;
} }
numThreads = NuRecordGetNumThreads(pRecord); numThreads = NuRecordGetNumThreads(pRecord);
if (!numThreads) { if (!numThreads) {
fprintf(stderr, "WARNING: recordIdx=%ld was empty\n", recordIdx); fprintf(stderr, "WARNING: recordIdx=%ld was empty\n", recordIdx);
goto bail; goto bail;
} }
/* /*
* Create a new record that looks just like the original. * Create a new record that looks just like the original.
*/ */
memset(&fileDetails, 0, sizeof(fileDetails)); memset(&fileDetails, 0, sizeof(fileDetails));
fileDetails.storageName = pRecord->filename; fileDetails.storageName = pRecord->filename;
fileDetails.fileSysID = pRecord->recFileSysID; fileDetails.fileSysID = pRecord->recFileSysID;
fileDetails.fileSysInfo = pRecord->recFileSysInfo; fileDetails.fileSysInfo = pRecord->recFileSysInfo;
fileDetails.access = pRecord->recAccess; fileDetails.access = pRecord->recAccess;
fileDetails.fileType = pRecord->recFileType; fileDetails.fileType = pRecord->recFileType;
fileDetails.extraType = pRecord->recExtraType; fileDetails.extraType = pRecord->recExtraType;
fileDetails.storageType = pRecord->recStorageType; fileDetails.storageType = pRecord->recStorageType;
fileDetails.createWhen = pRecord->recCreateWhen; fileDetails.createWhen = pRecord->recCreateWhen;
fileDetails.modWhen = pRecord->recModWhen; fileDetails.modWhen = pRecord->recModWhen;
fileDetails.archiveWhen = pRecord->recArchiveWhen; fileDetails.archiveWhen = pRecord->recArchiveWhen;
err = NuAddRecord(pOutArchive, &fileDetails, &newRecordIdx); err = NuAddRecord(pOutArchive, &fileDetails, &newRecordIdx);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: NuAddRecord failed (err=%d)\n", err); fprintf(stderr, "ERROR: NuAddRecord failed (err=%d)\n", err);
goto bail; goto bail;
} }
/* /*
* Copy the threads. * Copy the threads.
*/ */
if (flags & kFlagReverseThreads) { if (flags & kFlagReverseThreads) {
for (idx = numThreads-1; idx >= 0; idx--) { for (idx = numThreads-1; idx >= 0; idx--) {
pThread = NuGetThread(pRecord, idx); pThread = NuGetThread(pRecord, idx);
assert(pThread != nil); assert(pThread != nil);
err = CopyThread(pInArchive, pOutArchive, flags, pThread, err = CopyThread(pInArchive, pOutArchive, flags, pThread,
newRecordIdx); newRecordIdx);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
} }
} else { } else {
for (idx = 0; idx < numThreads; idx++) { for (idx = 0; idx < numThreads; idx++) {
pThread = NuGetThread(pRecord, idx); pThread = NuGetThread(pRecord, idx);
assert(pThread != nil); assert(pThread != nil);
err = CopyThread(pInArchive, pOutArchive, flags, pThread, err = CopyThread(pInArchive, pOutArchive, flags, pThread,
newRecordIdx); newRecordIdx);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
} }
} }
bail: bail:
return err; return err;
} }
@ -412,113 +412,113 @@ bail:
int int
LaunderArchive(const char* inFile, const char* outFile, long flags) LaunderArchive(const char* inFile, const char* outFile, long flags)
{ {
NuError err = kNuErrNone; NuError err = kNuErrNone;
NuArchive* pInArchive = nil; NuArchive* pInArchive = nil;
NuArchive* pOutArchive = nil; NuArchive* pOutArchive = nil;
const NuMasterHeader* pMasterHeader; const NuMasterHeader* pMasterHeader;
NuRecordIdx recordIdx; NuRecordIdx recordIdx;
long idx, flushStatus; long idx, flushStatus;
err = NuOpenRO(inFile, &pInArchive); err = NuOpenRO(inFile, &pInArchive);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: couldn't open input archive '%s' (err=%d)\n", fprintf(stderr, "ERROR: couldn't open input archive '%s' (err=%d)\n",
inFile, err); inFile, err);
goto bail; goto bail;
} }
err = NuOpenRW(outFile, kTempFile, kNuOpenCreat|kNuOpenExcl, &pOutArchive); err = NuOpenRW(outFile, kTempFile, kNuOpenCreat|kNuOpenExcl, &pOutArchive);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: couldn't open output archive '%s' (err=%d)\n", fprintf(stderr, "ERROR: couldn't open output archive '%s' (err=%d)\n",
outFile, err); outFile, err);
goto bail; goto bail;
} }
/* allow duplicates, in case the original archive has them */ /* allow duplicates, in case the original archive has them */
err = NuSetValue(pOutArchive, kNuValueAllowDuplicates, true); err = NuSetValue(pOutArchive, kNuValueAllowDuplicates, true);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: couldn't allow duplicates (err=%d)\n", err); fprintf(stderr, "ERROR: couldn't allow duplicates (err=%d)\n", err);
goto bail; goto bail;
} }
if (flags & kFlagUseTmp) { if (flags & kFlagUseTmp) {
err = NuSetValue(pOutArchive, kNuValueModifyOrig, false); err = NuSetValue(pOutArchive, kNuValueModifyOrig, false);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, fprintf(stderr,
"ERROR: couldn't disable modify orig (err=%d)\n", err); "ERROR: couldn't disable modify orig (err=%d)\n", err);
goto bail; goto bail;
} }
} }
err = NuGetMasterHeader(pInArchive, &pMasterHeader); err = NuGetMasterHeader(pInArchive, &pMasterHeader);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: couldn't get master header (err=%d)\n", err); fprintf(stderr, "ERROR: couldn't get master header (err=%d)\n", err);
goto bail; goto bail;
} }
/* /*
* Iterate through the set of records. * Iterate through the set of records.
*/ */
for (idx = 0; idx < (int)pMasterHeader->mhTotalRecords; idx++) { for (idx = 0; idx < (int)pMasterHeader->mhTotalRecords; idx++) {
err = NuGetRecordIdxByPosition(pInArchive, idx, &recordIdx); err = NuGetRecordIdxByPosition(pInArchive, idx, &recordIdx);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: couldn't get record #%ld (err=%d)\n", fprintf(stderr, "ERROR: couldn't get record #%ld (err=%d)\n",
idx, err); idx, err);
goto bail; goto bail;
} }
err = CopyRecord(pInArchive, pOutArchive, flags, recordIdx); err = CopyRecord(pInArchive, pOutArchive, flags, recordIdx);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
/* /*
* If "frequent abort" is set, abort what we just did and redo it. * If "frequent abort" is set, abort what we just did and redo it.
*/ */
if (flags & kFlagFrequentAbort) { if (flags & kFlagFrequentAbort) {
printf("(abort)\n"); printf("(abort)\n");
err = NuAbort(pOutArchive); err = NuAbort(pOutArchive);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: abort failed (err=%d)\n", err); fprintf(stderr, "ERROR: abort failed (err=%d)\n", err);
goto bail; goto bail;
} }
err = CopyRecord(pInArchive, pOutArchive, flags, recordIdx); err = CopyRecord(pInArchive, pOutArchive, flags, recordIdx);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
} }
/* /*
* If "frequent abort" or "frequent flush" is set, flush after * If "frequent abort" or "frequent flush" is set, flush after
* each record is copied. * each record is copied.
*/ */
if ((flags & kFlagFrequentAbort) || (flags & kFlagFrequentFlush)) { if ((flags & kFlagFrequentAbort) || (flags & kFlagFrequentFlush)) {
printf("(flush)\n"); printf("(flush)\n");
err = NuFlush(pOutArchive, &flushStatus); err = NuFlush(pOutArchive, &flushStatus);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, fprintf(stderr,
"ERROR: flush failed (err=%d, status=0x%04lx)\n", "ERROR: flush failed (err=%d, status=0x%04lx)\n",
err, flushStatus); err, flushStatus);
goto bail; goto bail;
} }
} }
} }
/* first and only flush if frequent-flushing wasn't enabled */ /* first and only flush if frequent-flushing wasn't enabled */
err = NuFlush(pOutArchive, &flushStatus); err = NuFlush(pOutArchive, &flushStatus);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: flush failed (err=%d, status=0x%04lx)\n", fprintf(stderr, "ERROR: flush failed (err=%d, status=0x%04lx)\n",
err, flushStatus); err, flushStatus);
goto bail; goto bail;
} }
bail: bail:
if (pInArchive != nil) if (pInArchive != nil)
NuClose(pInArchive); NuClose(pInArchive);
if (pOutArchive != nil) { if (pOutArchive != nil) {
if (err != kNuErrNone) if (err != kNuErrNone)
NuAbort(pOutArchive); NuAbort(pOutArchive);
NuClose(pOutArchive); /* flush pending changes and close */ NuClose(pOutArchive); /* flush pending changes and close */
} }
return (err != kNuErrNone); return (err != kNuErrNone);
} }
@ -528,7 +528,7 @@ bail:
void void
Usage(const char* argv0) Usage(const char* argv0)
{ {
fprintf(stderr, "Usage: %s [-crfat] infile.shk outfile.shk\n", argv0); fprintf(stderr, "Usage: %s [-crfat] infile.shk outfile.shk\n", argv0);
} }
/* /*
@ -537,51 +537,51 @@ Usage(const char* argv0)
int int
main(int argc, char** argv) main(int argc, char** argv)
{ {
long major, minor, bug; long major, minor, bug;
const char* pBuildDate; const char* pBuildDate;
long flags = 0; long flags = 0;
char* cp = nil; char* cp = nil;
int cc; int cc;
(void) NuGetVersion(&major, &minor, &bug, &pBuildDate, nil); (void) NuGetVersion(&major, &minor, &bug, &pBuildDate, nil);
printf("Using NuFX lib %ld.%ld.%ld built on or after %s\n", printf("Using NuFX lib %ld.%ld.%ld built on or after %s\n",
major, minor, bug, pBuildDate); major, minor, bug, pBuildDate);
if (argc < 3 || argc > 4) { if (argc < 3 || argc > 4) {
Usage(argv[0]); Usage(argv[0]);
exit(2); exit(2);
} }
if (argc == 4) { if (argc == 4) {
cp = argv[1]; cp = argv[1];
if (*cp++ != '-') { if (*cp++ != '-') {
Usage(argv[0]); Usage(argv[0]);
exit(2); exit(2);
} }
while (*cp != '\0') { while (*cp != '\0') {
switch (*cp) { switch (*cp) {
case 'c': flags |= kFlagCopyOnly; break; case 'c': flags |= kFlagCopyOnly; break;
case 'r': flags |= kFlagReverseThreads; break; case 'r': flags |= kFlagReverseThreads; break;
case 'f': flags |= kFlagFrequentFlush; break; case 'f': flags |= kFlagFrequentFlush; break;
case 'a': flags |= kFlagFrequentAbort; break; case 'a': flags |= kFlagFrequentAbort; break;
case 't': flags |= kFlagUseTmp; break; case 't': flags |= kFlagUseTmp; break;
default: default:
Usage(argv[0]); Usage(argv[0]);
exit(2); exit(2);
} }
cp++; cp++;
} }
argv++; argv++;
} }
cc = LaunderArchive(argv[1], argv[2], flags); cc = LaunderArchive(argv[1], argv[2], flags);
if (cc == 0) if (cc == 0)
printf("Success!\n"); printf("Success!\n");
else else
printf("Failed.\n"); printf("Failed.\n");
exit(cc != 0); exit(cc != 0);
} }

1718
nufxlib-0/samples/TestBasic.c
View File

File diff suppressed because it is too large Load Diff

478
nufxlib-0/samples/TestExtract.c
View File

@ -21,15 +21,15 @@
#include "Common.h" #include "Common.h"
#define false 0 #define false 0
#define true (!false) #define true (!false)
#define kHappySize 2408 #define kHappySize 2408
/* /*
* =========================================================================== * ===========================================================================
* ArchiveRecord * ArchiveRecord
* =========================================================================== * ===========================================================================
*/ */
@ -37,13 +37,13 @@
* Track an archive record. * Track an archive record.
*/ */
typedef struct ArchiveRecord { typedef struct ArchiveRecord {
char* filename; char* filename;
NuRecordIdx recordIdx; NuRecordIdx recordIdx;
long numThreads; long numThreads;
NuThread* pThreads; NuThread* pThreads;
struct ArchiveRecord* pNext; struct ArchiveRecord* pNext;
} ArchiveRecord; } ArchiveRecord;
@ -53,24 +53,24 @@ typedef struct ArchiveRecord {
ArchiveRecord* ArchiveRecord*
ArchiveRecord_New(const NuRecord* pRecord) ArchiveRecord_New(const NuRecord* pRecord)
{ {
ArchiveRecord* pArcRec = nil; ArchiveRecord* pArcRec = nil;
pArcRec = malloc(sizeof(*pArcRec)); pArcRec = malloc(sizeof(*pArcRec));
if (pArcRec == nil) if (pArcRec == nil)
return nil; return nil;
if (pRecord->filename == nil) if (pRecord->filename == nil)
pArcRec->filename = strdup("<unknown>"); pArcRec->filename = strdup("<unknown>");
else else
pArcRec->filename = strdup((char*)pRecord->filename); pArcRec->filename = strdup((char*)pRecord->filename);
pArcRec->recordIdx = pRecord->recordIdx; pArcRec->recordIdx = pRecord->recordIdx;
pArcRec->numThreads = NuRecordGetNumThreads(pRecord); pArcRec->numThreads = NuRecordGetNumThreads(pRecord);
(void) NuRecordCopyThreads(pRecord, &pArcRec->pThreads); (void) NuRecordCopyThreads(pRecord, &pArcRec->pThreads);
pArcRec->pNext = nil; pArcRec->pNext = nil;
return pArcRec; return pArcRec;
} }
/* /*
@ -79,14 +79,14 @@ ArchiveRecord_New(const NuRecord* pRecord)
void void
ArchiveRecord_Free(ArchiveRecord* pArcRec) ArchiveRecord_Free(ArchiveRecord* pArcRec)
{ {
if (pArcRec == nil) if (pArcRec == nil)
return; return;
if (pArcRec->filename != nil) if (pArcRec->filename != nil)
free(pArcRec->filename); free(pArcRec->filename);
if (pArcRec->pThreads != nil) if (pArcRec->pThreads != nil)
free(pArcRec->pThreads); free(pArcRec->pThreads);
free(pArcRec); free(pArcRec);
} }
/* /*
@ -95,61 +95,61 @@ ArchiveRecord_Free(ArchiveRecord* pArcRec)
const NuThread* const NuThread*
ArchiveRecord_FindThreadByID(const ArchiveRecord* pArcRec, NuThreadID threadID) ArchiveRecord_FindThreadByID(const ArchiveRecord* pArcRec, NuThreadID threadID)
{ {
const NuThread* pThread; const NuThread* pThread;
int i; int i;
for (i = 0; i < pArcRec->numThreads; i++) { for (i = 0; i < pArcRec->numThreads; i++) {
pThread = NuThreadGetByIdx(pArcRec->pThreads, i); pThread = NuThreadGetByIdx(pArcRec->pThreads, i);
if (NuGetThreadID(pThread) == threadID) if (NuGetThreadID(pThread) == threadID)
return pThread; return pThread;
} }
return nil; return nil;
} }
const char* const char*
ArchiveRecord_GetFilename(const ArchiveRecord* pArcRec) ArchiveRecord_GetFilename(const ArchiveRecord* pArcRec)
{ {
return pArcRec->filename; return pArcRec->filename;
} }
NuRecordIdx NuRecordIdx
ArchiveRecord_GetRecordIdx(const ArchiveRecord* pArcRec) ArchiveRecord_GetRecordIdx(const ArchiveRecord* pArcRec)
{ {
return pArcRec->recordIdx; return pArcRec->recordIdx;
} }
long long
ArchiveRecord_GetNumThreads(const ArchiveRecord* pArcRec) ArchiveRecord_GetNumThreads(const ArchiveRecord* pArcRec)
{ {
return pArcRec->numThreads; return pArcRec->numThreads;
} }
const NuThread* const NuThread*
ArchiveRecord_GetThread(const ArchiveRecord* pArcRec, int idx) ArchiveRecord_GetThread(const ArchiveRecord* pArcRec, int idx)
{ {
if (idx < 0 || idx >= pArcRec->numThreads) if (idx < 0 || idx >= pArcRec->numThreads)
return nil; return nil;
return NuThreadGetByIdx(pArcRec->pThreads, idx); return NuThreadGetByIdx(pArcRec->pThreads, idx);
} }
void void
ArchiveRecord_SetNext(ArchiveRecord* pArcRec, ArchiveRecord* pNextRec) ArchiveRecord_SetNext(ArchiveRecord* pArcRec, ArchiveRecord* pNextRec)
{ {
pArcRec->pNext = pNextRec; pArcRec->pNext = pNextRec;
} }
ArchiveRecord* ArchiveRecord*
ArchiveRecord_GetNext(const ArchiveRecord* pArcRec) ArchiveRecord_GetNext(const ArchiveRecord* pArcRec)
{ {
return pArcRec->pNext; return pArcRec->pNext;
} }
/* /*
* =========================================================================== * ===========================================================================
* ArchiveData * ArchiveData
* =========================================================================== * ===========================================================================
*/ */
@ -157,50 +157,50 @@ ArchiveRecord_GetNext(const ArchiveRecord* pArcRec)
* A collection of records. * A collection of records.
*/ */
typedef struct ArchiveData { typedef struct ArchiveData {
long numRecords; long numRecords;
ArchiveRecord* pRecordHead; ArchiveRecord* pRecordHead;
ArchiveRecord* pRecordTail; ArchiveRecord* pRecordTail;
} ArchiveData; } ArchiveData;
ArchiveData* ArchiveData*
ArchiveData_New(void) ArchiveData_New(void)
{ {
ArchiveData* pArcData; ArchiveData* pArcData;
pArcData = malloc(sizeof(*pArcData)); pArcData = malloc(sizeof(*pArcData));
if (pArcData == nil) if (pArcData == nil)
return nil; return nil;
pArcData->numRecords = 0; pArcData->numRecords = 0;
pArcData->pRecordHead = pArcData->pRecordTail = nil; pArcData->pRecordHead = pArcData->pRecordTail = nil;
return pArcData; return pArcData;
} }
void void
ArchiveData_Free(ArchiveData* pArcData) ArchiveData_Free(ArchiveData* pArcData)
{ {
ArchiveRecord* pNext; ArchiveRecord* pNext;
if (pArcData == nil) if (pArcData == nil)
return; return;
printf("*** Deleting %ld records!\n", pArcData->numRecords); printf("*** Deleting %ld records!\n", pArcData->numRecords);
while (pArcData->pRecordHead != nil) { while (pArcData->pRecordHead != nil) {
pNext = ArchiveRecord_GetNext(pArcData->pRecordHead); pNext = ArchiveRecord_GetNext(pArcData->pRecordHead);
ArchiveRecord_Free(pArcData->pRecordHead); ArchiveRecord_Free(pArcData->pRecordHead);
pArcData->pRecordHead = pNext; pArcData->pRecordHead = pNext;
} }
free(pArcData); free(pArcData);
} }
ArchiveRecord* ArchiveRecord*
ArchiveData_GetRecordHead(const ArchiveData* pArcData) ArchiveData_GetRecordHead(const ArchiveData* pArcData)
{ {
return pArcData->pRecordHead; return pArcData->pRecordHead;
} }
@ -208,52 +208,52 @@ ArchiveData_GetRecordHead(const ArchiveData* pArcData)
void void
ArchiveData_AddRecord(ArchiveData* pArcData, ArchiveRecord* pRecord) ArchiveData_AddRecord(ArchiveData* pArcData, ArchiveRecord* pRecord)
{ {
assert(pRecord != nil); assert(pRecord != nil);
assert((pArcData->pRecordHead == nil && pArcData->pRecordTail == nil) || assert((pArcData->pRecordHead == nil && pArcData->pRecordTail == nil) ||
(pArcData->pRecordHead != nil && pArcData->pRecordTail != nil)); (pArcData->pRecordHead != nil && pArcData->pRecordTail != nil));
if (pArcData->pRecordHead == nil) { if (pArcData->pRecordHead == nil) {
/* first */ /* first */
pArcData->pRecordHead = pArcData->pRecordTail = pRecord; pArcData->pRecordHead = pArcData->pRecordTail = pRecord;
} else { } else {
/* not first, add to end */ /* not first, add to end */
ArchiveRecord_SetNext(pArcData->pRecordTail, pRecord); ArchiveRecord_SetNext(pArcData->pRecordTail, pRecord);
pArcData->pRecordTail = pRecord; pArcData->pRecordTail = pRecord;
} }
pArcData->numRecords++; pArcData->numRecords++;
} }
/* dump the contents of the ArchiveData to stdout */ /* dump the contents of the ArchiveData to stdout */
void void
ArchiveData_DumpContents(const ArchiveData* pArcData) ArchiveData_DumpContents(const ArchiveData* pArcData)
{ {
ArchiveRecord* pArcRec; ArchiveRecord* pArcRec;
pArcRec = pArcData->pRecordHead; pArcRec = pArcData->pRecordHead;
while (pArcRec != nil) { while (pArcRec != nil) {
const NuThread* pThread; const NuThread* pThread;
int i, count; int i, count;
printf("%5ld '%s'\n", printf("%5ld '%s'\n",
ArchiveRecord_GetRecordIdx(pArcRec), ArchiveRecord_GetRecordIdx(pArcRec),
ArchiveRecord_GetFilename(pArcRec)); ArchiveRecord_GetFilename(pArcRec));
count = ArchiveRecord_GetNumThreads(pArcRec); count = ArchiveRecord_GetNumThreads(pArcRec);
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
pThread = ArchiveRecord_GetThread(pArcRec, i); pThread = ArchiveRecord_GetThread(pArcRec, i);
printf(" %5ld 0x%04x 0x%04x\n", pThread->threadIdx, printf(" %5ld 0x%04x 0x%04x\n", pThread->threadIdx,
pThread->thThreadClass, pThread->thThreadKind); pThread->thThreadClass, pThread->thThreadKind);
} }
pArcRec = ArchiveRecord_GetNext(pArcRec); pArcRec = ArchiveRecord_GetNext(pArcRec);
} }
} }
/* /*
* =========================================================================== * ===========================================================================
* Main stuff * Main stuff
* =========================================================================== * ===========================================================================
*/ */
@ -263,19 +263,19 @@ ArchiveData_DumpContents(const ArchiveData* pArcData)
NuResult NuResult
GatherContents(NuArchive* pArchive, void* vpRecord) GatherContents(NuArchive* pArchive, void* vpRecord)
{ {
NuRecord* pRecord = (NuRecord*) vpRecord; NuRecord* pRecord = (NuRecord*) vpRecord;
ArchiveData* pArchiveData = nil; ArchiveData* pArchiveData = nil;
ArchiveRecord* pArchiveRecord = ArchiveRecord_New(pRecord); ArchiveRecord* pArchiveRecord = ArchiveRecord_New(pRecord);
NuGetExtraData(pArchive, (void**)&pArchiveData); NuGetExtraData(pArchive, (void**)&pArchiveData);
assert(pArchiveData != nil); assert(pArchiveData != nil);
printf("*** Filename = '%s'\n", printf("*** Filename = '%s'\n",
pRecord->filename == nil ? "<unknown>":(const char*)pRecord->filename); pRecord->filename == nil ? "<unknown>":(const char*)pRecord->filename);
ArchiveData_AddRecord(pArchiveData, pArchiveRecord); ArchiveData_AddRecord(pArchiveData, pArchiveRecord);
return kNuOK; return kNuOK;
} }
@ -284,28 +284,28 @@ GatherContents(NuArchive* pArchive, void* vpRecord)
*/ */
NuError NuError
ReadAllFilenameThreads(NuArchive* pArchive, ArchiveData* pArchiveData, ReadAllFilenameThreads(NuArchive* pArchive, ArchiveData* pArchiveData,
NuDataSink* pDataSink) NuDataSink* pDataSink)
{ {
NuError err = kNuErrNone; NuError err = kNuErrNone;
ArchiveRecord* pArchiveRecord; ArchiveRecord* pArchiveRecord;
const NuThread* pThread; const NuThread* pThread;
pArchiveRecord = ArchiveData_GetRecordHead(pArchiveData); pArchiveRecord = ArchiveData_GetRecordHead(pArchiveData);
while (pArchiveRecord != nil) { while (pArchiveRecord != nil) {
pThread = ArchiveRecord_FindThreadByID(pArchiveRecord, pThread = ArchiveRecord_FindThreadByID(pArchiveRecord,
kNuThreadIDFilename); kNuThreadIDFilename);
if (pThread != nil) { if (pThread != nil) {
err = NuExtractThread(pArchive, pThread->threadIdx, pDataSink); err = NuExtractThread(pArchive, pThread->threadIdx, pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "*** Extract failed (%d)\n", err); fprintf(stderr, "*** Extract failed (%d)\n", err);
goto bail; goto bail;
} }
} }
pArchiveRecord = ArchiveRecord_GetNext(pArchiveRecord); pArchiveRecord = ArchiveRecord_GetNext(pArchiveRecord);
} }
bail: bail:
return err; return err;
} }
@ -313,96 +313,96 @@ bail:
NuError NuError
ExtractToFile(NuArchive* pArchive, ArchiveData* pArchiveData) ExtractToFile(NuArchive* pArchive, ArchiveData* pArchiveData)
{ {
NuError err; NuError err;
NuDataSink* pDataSink = nil; NuDataSink* pDataSink = nil;
err = NuCreateDataSinkForFile(true, kNuConvertOff, "out.file", PATH_SEP, err = NuCreateDataSinkForFile(true, kNuConvertOff, "out.file", PATH_SEP,
&pDataSink); &pDataSink);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
err = NuSetValue(pArchive, kNuValueHandleExisting, kNuAlwaysOverwrite); err = NuSetValue(pArchive, kNuValueHandleExisting, kNuAlwaysOverwrite);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
err = ReadAllFilenameThreads(pArchive, pArchiveData, pDataSink); err = ReadAllFilenameThreads(pArchive, pArchiveData, pDataSink);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
bail: bail:
(void) NuFreeDataSink(pDataSink); (void) NuFreeDataSink(pDataSink);
if (err == kNuErrNone) if (err == kNuErrNone)
printf("*** File write complete\n"); printf("*** File write complete\n");
return err; return err;
} }
/* extract every filename thread into a FILE*, appending */ /* extract every filename thread into a FILE*, appending */
NuError NuError
ExtractToFP(NuArchive* pArchive, ArchiveData* pArchiveData) ExtractToFP(NuArchive* pArchive, ArchiveData* pArchiveData)
{ {
NuError err; NuError err;
FILE* fp = nil; FILE* fp = nil;
NuDataSink* pDataSink = nil; NuDataSink* pDataSink = nil;
if ((fp = fopen("out.fp", kNuFileOpenWriteTrunc)) == nil) if ((fp = fopen("out.fp", kNuFileOpenWriteTrunc)) == nil)
return kNuErrFileOpen; return kNuErrFileOpen;
err = NuCreateDataSinkForFP(true, kNuConvertOff, fp, &pDataSink); err = NuCreateDataSinkForFP(true, kNuConvertOff, fp, &pDataSink);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
err = ReadAllFilenameThreads(pArchive, pArchiveData, pDataSink); err = ReadAllFilenameThreads(pArchive, pArchiveData, pDataSink);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
bail: bail:
(void) NuFreeDataSink(pDataSink); (void) NuFreeDataSink(pDataSink);
if (fp != nil) if (fp != nil)
fclose(fp); fclose(fp);
if (err == kNuErrNone) if (err == kNuErrNone)
printf("*** FP write complete\n"); printf("*** FP write complete\n");
return err; return err;
} }
/* extract every filename thread into a buffer, advancing as we go */ /* extract every filename thread into a buffer, advancing as we go */
NuError NuError
ExtractToBuffer(NuArchive* pArchive, ArchiveData* pArchiveData) ExtractToBuffer(NuArchive* pArchive, ArchiveData* pArchiveData)
{ {
NuError err; NuError err;
unsigned char buffer[kHappySize]; unsigned char buffer[kHappySize];
NuDataSink* pDataSink = nil; NuDataSink* pDataSink = nil;
unsigned long count; unsigned long count;
err = NuCreateDataSinkForBuffer(true, kNuConvertOff, buffer, kHappySize, err = NuCreateDataSinkForBuffer(true, kNuConvertOff, buffer, kHappySize,
&pDataSink); &pDataSink);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
err = ReadAllFilenameThreads(pArchive, pArchiveData, pDataSink); err = ReadAllFilenameThreads(pArchive, pArchiveData, pDataSink);
if (err != kNuErrNone) { if (err != kNuErrNone) {
if (err == kNuErrBufferOverrun) if (err == kNuErrBufferOverrun)
fprintf(stderr, "*** Hey, buffer wasn't big enough!\n"); fprintf(stderr, "*** Hey, buffer wasn't big enough!\n");
goto bail; goto bail;
} }
/* write the buffer to a file */ /* write the buffer to a file */
(void) NuDataSinkGetOutCount(pDataSink, &count); (void) NuDataSinkGetOutCount(pDataSink, &count);
if (count > 0) { if (count > 0) {
FILE* fp; FILE* fp;
if ((fp = fopen("out.buf", kNuFileOpenWriteTrunc)) != nil) { if ((fp = fopen("out.buf", kNuFileOpenWriteTrunc)) != nil) {
printf("*** Writing %ld bytes\n", count); printf("*** Writing %ld bytes\n", count);
if (fwrite(buffer, count, 1, fp) != 1) if (fwrite(buffer, count, 1, fp) != 1)
err = kNuErrFileWrite; err = kNuErrFileWrite;
fclose(fp); fclose(fp);
} }
} else { } else {
printf("*** No data found!\n"); printf("*** No data found!\n");
} }
bail: bail:
(void) NuFreeDataSink(pDataSink); (void) NuFreeDataSink(pDataSink);
return err; return err;
} }
@ -412,52 +412,52 @@ bail:
int int
DoFileStuff(const char* filename) DoFileStuff(const char* filename)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
NuMasterHeader* pMasterHeader = nil; NuMasterHeader* pMasterHeader = nil;
ArchiveData* pArchiveData = ArchiveData_New(); ArchiveData* pArchiveData = ArchiveData_New();
err = NuOpenRO(filename, &pArchive); err = NuOpenRO(filename, &pArchive);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
NuSetExtraData(pArchive, pArchiveData); NuSetExtraData(pArchive, pArchiveData);
printf("*** Gathering contents!\n"); printf("*** Gathering contents!\n");
err = NuContents(pArchive, GatherContents); err = NuContents(pArchive, GatherContents);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
printf("*** Dumping contents!\n"); printf("*** Dumping contents!\n");
ArchiveData_DumpContents(pArchiveData); ArchiveData_DumpContents(pArchiveData);
err = ExtractToFile(pArchive, pArchiveData); err = ExtractToFile(pArchive, pArchiveData);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
err = ExtractToFP(pArchive, pArchiveData); err = ExtractToFP(pArchive, pArchiveData);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
err = ExtractToBuffer(pArchive, pArchiveData); err = ExtractToBuffer(pArchive, pArchiveData);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
bail: bail:
if (err != kNuErrNone) if (err != kNuErrNone)
fprintf(stderr, "*** ERROR: got error %d\n", err); fprintf(stderr, "*** ERROR: got error %d\n", err);
if (pArchive != nil) { if (pArchive != nil) {
NuError err2 = NuClose(pArchive); NuError err2 = NuClose(pArchive);
if (err == kNuErrNone && err2 != kNuErrNone) if (err == kNuErrNone && err2 != kNuErrNone)
err = err2; err = err2;
} }
if (pMasterHeader != nil) if (pMasterHeader != nil)
free(pMasterHeader); free(pMasterHeader);
if (pArchiveData != nil) if (pArchiveData != nil)
free(pArchiveData); free(pArchiveData);
return err; return err;
} }
@ -467,28 +467,28 @@ bail:
int int
main(int argc, char** argv) main(int argc, char** argv)
{ {
long major, minor, bug; long major, minor, bug;
const char* pBuildDate; const char* pBuildDate;
FILE* infp; FILE* infp;
int cc; int cc;
(void) NuGetVersion(&major, &minor, &bug, &pBuildDate, nil); (void) NuGetVersion(&major, &minor, &bug, &pBuildDate, nil);
printf("Using NuFX lib %ld.%ld.%ld built on or after %s\n", printf("Using NuFX lib %ld.%ld.%ld built on or after %s\n",
major, minor, bug, pBuildDate); major, minor, bug, pBuildDate);
if (argc == 2) { if (argc == 2) {
infp = fopen(argv[1], kNuFileOpenReadOnly); infp = fopen(argv[1], kNuFileOpenReadOnly);
if (infp == nil) { if (infp == nil) {
perror("fopen failed"); perror("fopen failed");
exit(1); exit(1);
} }
} else { } else {
fprintf(stderr, "ERROR: you have to specify a filename\n"); fprintf(stderr, "ERROR: you have to specify a filename\n");
exit(2); exit(2);
} }
cc = DoFileStuff(argv[1]); cc = DoFileStuff(argv[1]);
exit(cc != 0); exit(cc != 0);
} }

88
nufxlib-0/samples/TestSimple.c
View File

@ -24,11 +24,11 @@
NuResult NuResult
ShowContents(NuArchive* pArchive, void* vpRecord) ShowContents(NuArchive* pArchive, void* vpRecord)
{ {
const NuRecord* pRecord = (NuRecord*) vpRecord; const NuRecord* pRecord = (NuRecord*) vpRecord;
printf("*** Filename = '%s'\n", pRecord->filename); printf("*** Filename = '%s'\n", pRecord->filename);
return kNuOK; return kNuOK;
} }
@ -41,31 +41,31 @@ ShowContents(NuArchive* pArchive, void* vpRecord)
int int
DoStreamStuff(FILE* fp) DoStreamStuff(FILE* fp)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
err = NuStreamOpenRO(fp, &pArchive); err = NuStreamOpenRO(fp, &pArchive);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to open stream archive (err=%d)\n", err); fprintf(stderr, "ERROR: unable to open stream archive (err=%d)\n", err);
goto bail; goto bail;
} }
printf("*** Streaming contents!\n"); printf("*** Streaming contents!\n");
err = NuContents(pArchive, ShowContents); err = NuContents(pArchive, ShowContents);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: NuContents failed (err=%d)\n", err); fprintf(stderr, "ERROR: NuContents failed (err=%d)\n", err);
goto bail; goto bail;
} }
bail: bail:
if (pArchive != nil) { if (pArchive != nil) {
NuError err2 = NuClose(pArchive); NuError err2 = NuClose(pArchive);
if (err == kNuErrNone) if (err == kNuErrNone)
err = err2; err = err2;
} }
return err; return err;
} }
@ -75,31 +75,31 @@ bail:
int int
main(int argc, char** argv) main(int argc, char** argv)
{ {
long major, minor, bug; long major, minor, bug;
const char* pBuildDate; const char* pBuildDate;
FILE* infp = nil; FILE* infp = nil;
int cc; int cc;
(void) NuGetVersion(&major, &minor, &bug, &pBuildDate, nil); (void) NuGetVersion(&major, &minor, &bug, &pBuildDate, nil);
printf("Using NuFX lib %ld.%ld.%ld built on or after %s\n", printf("Using NuFX lib %ld.%ld.%ld built on or after %s\n",
major, minor, bug, pBuildDate); major, minor, bug, pBuildDate);
if (argc != 2) { if (argc != 2) {
fprintf(stderr, "Usage: %s (archive-name|-)\n", argv[0]); fprintf(stderr, "Usage: %s (archive-name|-)\n", argv[0]);
exit(2); exit(2);
} }
if (strcmp(argv[1], "-") == 0) if (strcmp(argv[1], "-") == 0)
infp = stdin; infp = stdin;
else { else {
infp = fopen(argv[1], kNuFileOpenReadOnly); infp = fopen(argv[1], kNuFileOpenReadOnly);
if (infp == nil) { if (infp == nil) {
fprintf(stderr, "ERROR: unable to open '%s'\n", argv[1]); fprintf(stderr, "ERROR: unable to open '%s'\n", argv[1]);
exit(1); exit(1);
} }
} }
cc = DoStreamStuff(infp); cc = DoStreamStuff(infp);
exit(cc != 0); exit(cc != 0);
} }

116
nulib2/Add.c
View File

@ -17,58 +17,58 @@ static NuError AddToArchive(NulibState* pState, NuArchive* pArchive);
NuError NuError
DoAdd(NulibState* pState) DoAdd(NulibState* pState)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
long flushStatus; long flushStatus;
assert(pState != nil); assert(pState != nil);
err = OpenArchiveReadWrite(pState); err = OpenArchiveReadWrite(pState);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
pArchive = NState_GetNuArchive(pState); pArchive = NState_GetNuArchive(pState);
assert(pArchive != nil); assert(pArchive != nil);
NState_SetMatchCount(pState, 0); NState_SetMatchCount(pState, 0);
/* tell them about the list of files */ /* tell them about the list of files */
err = AddToArchive(pState, pArchive); err = AddToArchive(pState, pArchive);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
/*(void)NuDebugDumpArchive(pArchive);*/ /*(void)NuDebugDumpArchive(pArchive);*/
if (!NState_GetMatchCount(pState)) if (!NState_GetMatchCount(pState))
printf("%s: no records matched\n", gProgName); printf("%s: no records matched\n", gProgName);
bail: bail:
if (pArchive != nil) { if (pArchive != nil) {
NuError err2; NuError err2;
#if 0 #if 0
if (err != kNuErrNone) { if (err != kNuErrNone) {
printf("Attempting to flush changes in spite of errors...\n"); printf("Attempting to flush changes in spite of errors...\n");
err = kNuErrNone; err = kNuErrNone;
} }
#endif #endif
if (err == kNuErrNone) { if (err == kNuErrNone) {
err = NuFlush(pArchive, &flushStatus); err = NuFlush(pArchive, &flushStatus);
if (err != kNuErrNone && err == kNuErrNone) { if (err != kNuErrNone && err == kNuErrNone) {
ReportError(err, ReportError(err,
"Unable to flush archive changes (status=0x%04lx)", "Unable to flush archive changes (status=0x%04lx)",
flushStatus); flushStatus);
NuAbort(pArchive); NuAbort(pArchive);
} }
} else { } else {
NuAbort(pArchive); NuAbort(pArchive);
} }
err2 = NuClose(pArchive); err2 = NuClose(pArchive);
assert(err2 == kNuErrNone); assert(err2 == kNuErrNone);
} }
return err; return err;
} }
@ -81,29 +81,29 @@ bail:
static NuError static NuError
AddToArchive(NulibState* pState, NuArchive* pArchive) AddToArchive(NulibState* pState, NuArchive* pArchive)
{ {
NuError err = kNuErrNone; NuError err = kNuErrNone;
char* const* pSpec; char* const* pSpec;
ulong fileCount; ulong fileCount;
int i; int i;
assert(pState != nil); assert(pState != nil);
assert(pArchive != nil); assert(pArchive != nil);
if (!NState_GetFilespecCount(pState)) { if (!NState_GetFilespecCount(pState)) {
err = kNuErrSyntax; err = kNuErrSyntax;
ReportError(err, "no files were specified"); ReportError(err, "no files were specified");
} }
fileCount = 0; fileCount = 0;
pSpec = NState_GetFilespecPointer(pState); pSpec = NState_GetFilespecPointer(pState);
for (i = NState_GetFilespecCount(pState); i > 0; i--, pSpec++) { for (i = NState_GetFilespecCount(pState); i > 0; i--, pSpec++) {
err = AddFile(pState, pArchive, *pSpec); err = AddFile(pState, pArchive, *pSpec);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
} }
bail: bail:
return err; return err;
} }

1214
nulib2/ArcUtils.c
View File

File diff suppressed because it is too large Load Diff

176
nulib2/ChangeLog.txt
View File

@ -1,125 +1,129 @@
2000/05/22 ***** v1.0.1 shipped (no changes - version follows nufxlib) ***** 2002/09/20 fadden
- pulled the sources out and started fiddling with them again
- changed hard tabs to spaces
2000/05/18 ***** v1.0.0 shipped ***** 2000/05/22 ***** v1.0.1 shipped (no changes - version follows nufxlib) *****
2000/05/18 fadden 2000/05/18 ***** v1.0.0 shipped *****
- added nulib2 to set of things stripped by "distbin"
- updated version information to indicate final release
2000/03/25 ***** v0.6.1 shipped ***** 2000/05/18 fadden
- added nulib2 to set of things stripped by "distbin"
- updated version information to indicate final release
2000/03/25 ***** v0.6.1 shipped *****
2000/03/25 fadden 2000/03/25 fadden
- Sheppy says Mac OS X PPC v1.02 and v1.2 work with minor SysDefs tweak - Sheppy says Mac OS X PPC v1.02 and v1.2 work with minor SysDefs tweak
2000/03/05 ***** v0.6.0 (beta) shipped ***** 2000/03/05 ***** v0.6.0 (beta) shipped *****
2000/03/05 fadden 2000/03/05 fadden
- don't call mktemp(), just pass template into NuOpenRW - don't call mktemp(), just pass template into NuOpenRW
- removed DEBUG_MSGS from default CFLAGS - removed DEBUG_MSGS from default CFLAGS
- updated version information to indicate beta release - updated version information to indicate beta release
2000/02/24 ***** v0.5.1 shipped ***** 2000/02/24 ***** v0.5.1 shipped *****
2000/02/20 changes from Scott Blackman 2000/02/20 changes from Scott Blackman
- portability fixes for DJGPP under Win95 - portability fixes for DJGPP under Win95
2000/02/17 changes from Devin Reade 2000/02/17 changes from Devin Reade
- portability fixes for BSD, AIX, and others - portability fixes for BSD, AIX, and others
- added "distbin" target - added "distbin" target
2000/02/09 ***** v0.5.0 (alpha) shipped ***** 2000/02/09 ***** v0.5.0 (alpha) shipped *****
2000/02/09 fadden 2000/02/09 fadden
- changed the comparison used when extracting/deleting a list of files - changed the comparison used when extracting/deleting a list of files
from strcasecmp to strcmp, since NufxLib does case-sensitive compares. from strcasecmp to strcmp, since NufxLib does case-sensitive compares.
- fixed the percentage for files and archives larger than 21MB - fixed the percentage for files and archives larger than 21MB
2000/02/08 fadden 2000/02/08 fadden
- tweaked the BeOS/PPC config around a little - tweaked the BeOS/PPC config around a little
- deleted some commas to make "gcc -pedantic" happy - deleted some commas to make "gcc -pedantic" happy
- changed version to x.y.z format here too - changed version to x.y.z format here too
- generalized the "aux" handling to include all MS-DOS device names - generalized the "aux" handling to include all MS-DOS device names
2000/02/06 fadden 2000/02/06 fadden
- include @CFLAGS@ in case somebody wants to override them - include @CFLAGS@ in case somebody wants to override them
2000/02/06 ***** v0.4b shipped ***** 2000/02/06 ***** v0.4b shipped *****
2000/02/06 fadden 2000/02/06 fadden
- added "install-shared" make target - added "install-shared" make target
- portability fixes for HP/UX - portability fixes for HP/UX
2000/02/06 ***** v0.4a shipped ***** 2000/02/06 ***** v0.4a shipped *****
2000/02/06 fadden 2000/02/06 fadden
- massaged configure.in for BeOS, and added some type casts for mwerks - massaged configure.in for BeOS, and added some type casts for mwerks
2000/02/06 ***** v0.4 shipped ***** 2000/02/06 ***** v0.4 shipped *****
2000/02/05 fadden 2000/02/05 fadden
- added "mkinstalldirs" to install target - added "mkinstalldirs" to install target
- added Win32 makefile - added Win32 makefile
- made a few implicit typecasts explicit for Visual C++'s benefit - made a few implicit typecasts explicit for Visual C++'s benefit
- change "aux" to "_aux", because FAT filesystems choke on it - change "aux" to "_aux", because FAT filesystems choke on it
2000/02/04 fadden 2000/02/04 fadden
- added Win32 recursive directory descent - added Win32 recursive directory descent
2000/02/02 fadden 2000/02/02 fadden
- minor changes to get it working under Win32 (Visual C++ 6.0) - minor changes to get it working under Win32 (Visual C++ 6.0)
- added --enable-dmalloc to configuration - added --enable-dmalloc to configuration
2000/02/01 fadden 2000/02/01 fadden
- screen out leading "./", and junk the path if ".." shows up in path - screen out leading "./", and junk the path if ".." shows up in path
- don't try to add comments to records we're skipping - don't try to add comments to records we're skipping
- set kNuValueEOL appropriately for the current system - set kNuValueEOL appropriately for the current system
2000/01/29 ***** v0.3 shipped ***** 2000/01/29 ***** v0.3 shipped *****
2000/01/29 fadden 2000/01/29 fadden
- added "make install" target, with the standard autoconf defines - added "make install" target, with the standard autoconf defines
- added some examples to the man page - added some examples to the man page
2000/01/28 fadden 2000/01/28 fadden
- merged "Kind" and "Type" columns in "v" output - merged "Kind" and "Type" columns in "v" output
- display a '+' when doing EOL conversions on an extracted file - display a '+' when doing EOL conversions on an extracted file
2000/01/26 fadden 2000/01/26 fadden
- added UI for allowing the user to ignore bad CRCs - added UI for allowing the user to ignore bad CRCs
- implemented "-j" (junk paths) for add and extract - implemented "-j" (junk paths) for add and extract
- implemented "-c" (comments) for add and extract - implemented "-c" (comments) for add and extract
- added totals to bottom of "v" output - added totals to bottom of "v" output
2000/01/25 fadden 2000/01/25 fadden
- when extracting without type preservation, append "_rsrc_" to - when extracting without type preservation, append "_rsrc_" to
resource forks resource forks
2000/01/24 fadden 2000/01/24 fadden
- added support for "-k" (add as disk image) flag - added support for "-k" (add as disk image) flag
2000/01/24 ***** v0.2 shipped ***** 2000/01/24 ***** v0.2 shipped *****
2000/01/22 fadden 2000/01/22 fadden
- added support for "-u" (update) and "-f" (freshen) flags - added support for "-u" (update) and "-f" (freshen) flags
- set file dates in AddFile call - set file dates in AddFile call
2000/01/20 fadden 2000/01/20 fadden
- restructed the progress updater - restructed the progress updater
2000/01/19 fadden 2000/01/19 fadden
- normalized SysDefs.h, changing UNIX to UNIX_LIKE and defining for BeOS - normalized SysDefs.h, changing UNIX to UNIX_LIKE and defining for BeOS
- added "shared" target to makefile - added "shared" target to makefile
- added BeOS stuff to autoconf setup - added BeOS stuff to autoconf setup
2000/01/17 fadden 2000/01/17 fadden
- started recording locked/unlocked status - started recording locked/unlocked status
- some BeOS/Metrowerks "it's not gcc" changes from Eric Shepherd - some BeOS/Metrowerks "it's not gcc" changes from Eric Shepherd
- implemented "-s" (stomp existing) and "-0" (no compression) modifiers - implemented "-s" (stomp existing) and "-0" (no compression) modifiers
2000/01/17 ***** v0.1 shipped ***** 2000/01/17 ***** v0.1 shipped *****
(much time passes) (much time passes)
mid-1998 fadden mid-1998 fadden
- work begins - work begins

34
nulib2/Delete.c
View File

@ -18,29 +18,29 @@
NuError NuError
DoDelete(NulibState* pState) DoDelete(NulibState* pState)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
assert(pState != nil); assert(pState != nil);
err = OpenArchiveReadWrite(pState); err = OpenArchiveReadWrite(pState);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
pArchive = NState_GetNuArchive(pState); pArchive = NState_GetNuArchive(pState);
assert(pArchive != nil); assert(pArchive != nil);
NState_SetMatchCount(pState, 0); NState_SetMatchCount(pState, 0);
err = NuDelete(pArchive); err = NuDelete(pArchive);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
if (!NState_GetMatchCount(pState)) if (!NState_GetMatchCount(pState))
printf("%s: no records matched\n", gProgName); printf("%s: no records matched\n", gProgName);
bail: bail:
if (pArchive != nil) if (pArchive != nil)
(void) NuClose(pArchive); (void) NuClose(pArchive);
return err; return err;
} }

196
nulib2/Extract.c
View File

@ -20,67 +20,67 @@
static NuError static NuError
ExtractAllRecords(NulibState* pState, NuArchive* pArchive) ExtractAllRecords(NulibState* pState, NuArchive* pArchive)
{ {
NuError err; NuError err;
const NuRecord* pRecord; const NuRecord* pRecord;
const NuThread* pThread; const NuThread* pThread;
NuRecordIdx recordIdx; NuRecordIdx recordIdx;
NuAttr numRecords; NuAttr numRecords;
int idx, threadIdx; int idx, threadIdx;
DBUG(("--- doing manual extract\n")); DBUG(("--- doing manual extract\n"));
assert(NState_GetCommand(pState) == kCommandExtract); /* no "-p" here */ assert(NState_GetCommand(pState) == kCommandExtract); /* no "-p" here */
err = NuGetAttr(pArchive, kNuAttrNumRecords, &numRecords); err = NuGetAttr(pArchive, kNuAttrNumRecords, &numRecords);
for (idx = 0; idx < (int) numRecords; idx++) { for (idx = 0; idx < (int) numRecords; idx++) {
err = NuGetRecordIdxByPosition(pArchive, idx, &recordIdx); err = NuGetRecordIdxByPosition(pArchive, idx, &recordIdx);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: couldn't get record #%d (err=%d)\n", fprintf(stderr, "ERROR: couldn't get record #%d (err=%d)\n",
idx, err); idx, err);
goto bail; goto bail;
} }
err = NuGetRecord(pArchive, recordIdx, &pRecord); err = NuGetRecord(pArchive, recordIdx, &pRecord);
if (err != kNuErrNone) { if (err != kNuErrNone) {
fprintf(stderr, "ERROR: unable to get recordIdx %ld\n", recordIdx); fprintf(stderr, "ERROR: unable to get recordIdx %ld\n", recordIdx);
goto bail; goto bail;
} }
/* do we want to extract this record? */ /* do we want to extract this record? */
if (!IsSpecified(pState, pRecord)) if (!IsSpecified(pState, pRecord))
continue; continue;
NState_IncMatchCount(pState); NState_IncMatchCount(pState);
/* /*
* Look for a comment thread. * Look for a comment thread.
*/ */
for (threadIdx = 0; (ulong)threadIdx < pRecord->recTotalThreads; for (threadIdx = 0; (ulong)threadIdx < pRecord->recTotalThreads;
threadIdx++) threadIdx++)
{ {
pThread = NuGetThread(pRecord, threadIdx); pThread = NuGetThread(pRecord, threadIdx);
assert(pThread != nil); assert(pThread != nil);
if (NuGetThreadID(pThread) == kNuThreadIDComment && if (NuGetThreadID(pThread) == kNuThreadIDComment &&
pThread->actualThreadEOF > 0) pThread->actualThreadEOF > 0)
{ {
printf("----- '%s':\n", pRecord->filename); printf("----- '%s':\n", pRecord->filename);
err = NuExtractThread(pArchive, pThread->threadIdx, err = NuExtractThread(pArchive, pThread->threadIdx,
NState_GetCommentSink(pState)); NState_GetCommentSink(pState));
if (err != kNuErrNone) { if (err != kNuErrNone) {
printf("[comment extraction failed, continuing\n"); printf("[comment extraction failed, continuing\n");
} else { } else {
printf("\n-----\n"); printf("\n-----\n");
} }
} }
} }
/* extract the record, using the usual mechanisms */ /* extract the record, using the usual mechanisms */
err = NuExtractRecord(pArchive, recordIdx); err = NuExtractRecord(pArchive, recordIdx);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
} }
bail: bail:
return err; return err;
} }
@ -90,40 +90,40 @@ bail:
NuError NuError
DoExtract(NulibState* pState) DoExtract(NulibState* pState)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
assert(pState != nil); assert(pState != nil);
err = OpenArchiveReadOnly(pState); err = OpenArchiveReadOnly(pState);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
pArchive = NState_GetNuArchive(pState); pArchive = NState_GetNuArchive(pState);
assert(pArchive != nil); assert(pArchive != nil);
NState_SetMatchCount(pState, 0); NState_SetMatchCount(pState, 0);
/* /*
* If we're not interested in comments, just use the "bulk" extract * If we're not interested in comments, just use the "bulk" extract
* call. If we want comments, we need to do this one at a time. * call. If we want comments, we need to do this one at a time.
*/ */
if (!NState_GetModComments(pState)) { if (!NState_GetModComments(pState)) {
err = NuExtract(pArchive); err = NuExtract(pArchive);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
} else { } else {
err = ExtractAllRecords(pState, pArchive); err = ExtractAllRecords(pState, pArchive);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
} }
if (!NState_GetMatchCount(pState)) if (!NState_GetMatchCount(pState))
printf("%s: no records match\n", gProgName); printf("%s: no records match\n", gProgName);
bail: bail:
if (pArchive != nil) if (pArchive != nil)
(void) NuClose(pArchive); (void) NuClose(pArchive);
return err; return err;
} }
@ -133,8 +133,8 @@ bail:
NuError NuError
DoExtractToPipe(NulibState* pState) DoExtractToPipe(NulibState* pState)
{ {
/* we handle the "to pipe" part farther down */ /* we handle the "to pipe" part farther down */
return DoExtract(pState); return DoExtract(pState);
} }
@ -144,29 +144,29 @@ DoExtractToPipe(NulibState* pState)
NuError NuError
DoTest(NulibState* pState) DoTest(NulibState* pState)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
assert(pState != nil); assert(pState != nil);
err = OpenArchiveReadOnly(pState); err = OpenArchiveReadOnly(pState);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
pArchive = NState_GetNuArchive(pState); pArchive = NState_GetNuArchive(pState);
assert(pArchive != nil); assert(pArchive != nil);
NState_SetMatchCount(pState, 0); NState_SetMatchCount(pState, 0);
err = NuTest(pArchive); err = NuTest(pArchive);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
if (!NState_GetMatchCount(pState)) if (!NState_GetMatchCount(pState))
printf("%s: no records match\n", gProgName); printf("%s: no records match\n", gProgName);
bail: bail:
if (pArchive != nil) if (pArchive != nil)
(void) NuClose(pArchive); (void) NuClose(pArchive);
return err; return err;
} }

870
nulib2/Filename.c
View File

File diff suppressed because it is too large Load Diff

480
nulib2/List.c
View File

@ -11,31 +11,31 @@
/* kinds of records */ /* kinds of records */
enum RecordKind { enum RecordKind {
kRecordKindUnknown = 0, kRecordKindUnknown = 0,
kRecordKindDisk, kRecordKindDisk,
kRecordKindFile, kRecordKindFile,
kRecordKindForkedFile kRecordKindForkedFile
}; };
static const char* gShortFormatNames[] = { static const char* gShortFormatNames[] = {
"unc", "squ", "lz1", "lz2", "u12", "u16" "unc", "squ", "lz1", "lz2", "u12", "u16"
}; };
#if 0 #if 0
/* days of the week */ /* days of the week */
static const char* gDayNames[] = { static const char* gDayNames[] = {
"[ null ]", "[ null ]",
"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
}; };
#endif #endif
/* months of the year */ /* months of the year */
static const char* gMonths[] = { static const char* gMonths[] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
}; };
#define kNuDateOutputLen 64 #define kNuDateOutputLen 64
/* /*
@ -44,21 +44,21 @@ static const char* gMonths[] = {
int int
ComputePercent(ulong totalSize, ulong size) ComputePercent(ulong totalSize, ulong size)
{ {
int perc; int perc;
if (!totalSize && !size) if (!totalSize && !size)
return 100; /* file is zero bytes long */ return 100; /* file is zero bytes long */
if (totalSize < 21474836) if (totalSize < 21474836)
perc = (totalSize * 100) / size; perc = (totalSize * 100) / size;
else else
perc = totalSize / (size/100); perc = totalSize / (size/100);
/* don't say "0%" if it's not actually zero... it looks dumb */ /* don't say "0%" if it's not actually zero... it looks dumb */
if (!perc && size) if (!perc && size)
perc = 1; perc = 1;
return perc; return perc;
} }
@ -73,29 +73,29 @@ ComputePercent(ulong totalSize, ulong size)
static char* static char*
FormatDateShort(const NuDateTime* pDateTime, char* buffer) FormatDateShort(const NuDateTime* pDateTime, char* buffer)
{ {
/* is it valid? */ /* is it valid? */
if (pDateTime->day > 30 || pDateTime->month > 11 || pDateTime->hour > 24 || if (pDateTime->day > 30 || pDateTime->month > 11 || pDateTime->hour > 24 ||
pDateTime->minute > 59) pDateTime->minute > 59)
{ {
strcpy(buffer, " <invalid> "); strcpy(buffer, " <invalid> ");
goto bail; goto bail;
} }
/* is it empty? */ /* is it empty? */
if ((pDateTime->second | pDateTime->minute | pDateTime->hour | if ((pDateTime->second | pDateTime->minute | pDateTime->hour |
pDateTime->year | pDateTime->day | pDateTime->month | pDateTime->year | pDateTime->day | pDateTime->month |
pDateTime->extra | pDateTime->weekDay) == 0) pDateTime->extra | pDateTime->weekDay) == 0)
{ {
strcpy(buffer, " [No Date] "); strcpy(buffer, " [No Date] ");
goto bail; goto bail;
} }
sprintf(buffer, "%02d-%s-%02d %02d:%02d", sprintf(buffer, "%02d-%s-%02d %02d:%02d",
pDateTime->day+1, gMonths[pDateTime->month], pDateTime->year % 100, pDateTime->day+1, gMonths[pDateTime->month], pDateTime->year % 100,
pDateTime->hour, pDateTime->minute); pDateTime->hour, pDateTime->minute);
bail: bail:
return buffer; return buffer;
} }
@ -105,21 +105,21 @@ bail:
static NuResult static NuResult
ShowContentsShort(NuArchive* pArchive, void* vpRecord) ShowContentsShort(NuArchive* pArchive, void* vpRecord)
{ {
const NuRecord* pRecord = (NuRecord*) vpRecord; const NuRecord* pRecord = (NuRecord*) vpRecord;
NulibState* pState; NulibState* pState;
assert(pArchive != nil); assert(pArchive != nil);
(void) NuGetExtraData(pArchive, (void**) &pState); (void) NuGetExtraData(pArchive, (void**) &pState);
assert(pState != nil); assert(pState != nil);
if (!IsSpecified(pState, pRecord)) if (!IsSpecified(pState, pRecord))
goto bail; goto bail;
printf("%s\n", printf("%s\n",
pRecord->filename == nil ? "<unknown>":(const char*)pRecord->filename); pRecord->filename == nil ? "<unknown>":(const char*)pRecord->filename);
bail: bail:
return kNuOK; return kNuOK;
} }
@ -140,42 +140,42 @@ bail:
*/ */
static NuError static NuError
AnalyzeRecord(const NuRecord* pRecord, enum RecordKind* pRecordKind, AnalyzeRecord(const NuRecord* pRecord, enum RecordKind* pRecordKind,
ushort* pFormat, ulong* pTotalLen, ulong* pTotalCompLen) ushort* pFormat, ulong* pTotalLen, ulong* pTotalCompLen)
{ {
const NuThread* pThread; const NuThread* pThread;
NuThreadID threadID; NuThreadID threadID;
ulong idx; ulong idx;
*pRecordKind = kRecordKindUnknown; *pRecordKind = kRecordKindUnknown;
*pTotalLen = *pTotalCompLen = 0; *pTotalLen = *pTotalCompLen = 0;
*pFormat = kNuThreadFormatUncompressed; *pFormat = kNuThreadFormatUncompressed;
for (idx = 0; idx < pRecord->recTotalThreads; idx++) { for (idx = 0; idx < pRecord->recTotalThreads; idx++) {
pThread = NuGetThread(pRecord, idx); pThread = NuGetThread(pRecord, idx);
assert(pThread != nil); assert(pThread != nil);
if (pThread->thThreadClass == kNuThreadClassData) { if (pThread->thThreadClass == kNuThreadClassData) {
/* replace what's there if this might be more interesting */ /* replace what's there if this might be more interesting */
if (*pFormat == kNuThreadFormatUncompressed) if (*pFormat == kNuThreadFormatUncompressed)
*pFormat = pThread->thThreadFormat; *pFormat = pThread->thThreadFormat;
threadID = NuMakeThreadID(pThread->thThreadClass, threadID = NuMakeThreadID(pThread->thThreadClass,
pThread->thThreadKind); pThread->thThreadKind);
if (threadID == kNuThreadIDRsrcFork) if (threadID == kNuThreadIDRsrcFork)
*pRecordKind = kRecordKindForkedFile; *pRecordKind = kRecordKindForkedFile;
else if (threadID == kNuThreadIDDiskImage) else if (threadID == kNuThreadIDDiskImage)
*pRecordKind = kRecordKindDisk; *pRecordKind = kRecordKindDisk;
else if (threadID == kNuThreadIDDataFork && else if (threadID == kNuThreadIDDataFork &&
*pRecordKind == kRecordKindUnknown) *pRecordKind == kRecordKindUnknown)
*pRecordKind = kRecordKindFile; *pRecordKind = kRecordKindFile;
/* sum up, so we get both forks of forked files */ /* sum up, so we get both forks of forked files */
*pTotalLen += pThread->actualThreadEOF; *pTotalLen += pThread->actualThreadEOF;
*pTotalCompLen += pThread->thCompThreadEOF; *pTotalCompLen += pThread->thCompThreadEOF;
} }
} }
return kNuErrNone; return kNuErrNone;
} }
/* /*
@ -187,89 +187,89 @@ AnalyzeRecord(const NuRecord* pRecord, enum RecordKind* pRecordKind,
static NuResult static NuResult
ShowContentsVerbose(NuArchive* pArchive, void* vpRecord) ShowContentsVerbose(NuArchive* pArchive, void* vpRecord)
{ {
NuError err = kNuErrNone; NuError err = kNuErrNone;
const NuRecord* pRecord = (NuRecord*) vpRecord; const NuRecord* pRecord = (NuRecord*) vpRecord;
enum RecordKind recordKind; enum RecordKind recordKind;
ulong totalLen, totalCompLen; ulong totalLen, totalCompLen;
ushort format; ushort format;
NulibState* pState; NulibState* pState;
char date1[kNuDateOutputLen]; char date1[kNuDateOutputLen];
char tmpbuf[16]; char tmpbuf[16];
int len; int len;
assert(pArchive != nil); assert(pArchive != nil);
(void) NuGetExtraData(pArchive, (void**) &pState); (void) NuGetExtraData(pArchive, (void**) &pState);
assert(pState != nil); assert(pState != nil);
if (!IsSpecified(pState, pRecord)) if (!IsSpecified(pState, pRecord))
goto bail; goto bail;
err = AnalyzeRecord(pRecord, &recordKind, &format, &totalLen, err = AnalyzeRecord(pRecord, &recordKind, &format, &totalLen,
&totalCompLen); &totalCompLen);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
len = strlen(pRecord->filename); len = strlen(pRecord->filename);
if (len <= 27) { if (len <= 27) {
printf("%c%-27.27s ", IsRecordReadOnly(pRecord) ? '+' : ' ', printf("%c%-27.27s ", IsRecordReadOnly(pRecord) ? '+' : ' ',
pRecord->filename); pRecord->filename);
} else { } else {
printf("%c..%-25.25s ", IsRecordReadOnly(pRecord) ? '+' : ' ', printf("%c..%-25.25s ", IsRecordReadOnly(pRecord) ? '+' : ' ',
pRecord->filename + len - 25); pRecord->filename + len - 25);
} }
switch (recordKind) { switch (recordKind) {
case kRecordKindUnknown: case kRecordKindUnknown:
printf("??? $%04lX ", printf("??? $%04lX ",
/*GetFileTypeString(pRecord->recFileType),*/ /*GetFileTypeString(pRecord->recFileType),*/
pRecord->recExtraType); pRecord->recExtraType);
break; break;
case kRecordKindDisk: case kRecordKindDisk:
sprintf(tmpbuf, "%ldk", totalLen / 1024); sprintf(tmpbuf, "%ldk", totalLen / 1024);
printf("Disk %-6s ", tmpbuf); printf("Disk %-6s ", tmpbuf);
break; break;
case kRecordKindFile: case kRecordKindFile:
case kRecordKindForkedFile: case kRecordKindForkedFile:
printf("%s%c $%04lX ", printf("%s%c $%04lX ",
GetFileTypeString(pRecord->recFileType), GetFileTypeString(pRecord->recFileType),
recordKind == kRecordKindForkedFile ? '+' : ' ', recordKind == kRecordKindForkedFile ? '+' : ' ',
pRecord->recExtraType); pRecord->recExtraType);
break; break;
default: default:
assert(0); assert(0);
printf("ERROR "); printf("ERROR ");
} }
printf("%s ", FormatDateShort(&pRecord->recArchiveWhen, date1)); printf("%s ", FormatDateShort(&pRecord->recArchiveWhen, date1));
if (format >= NELEM(gShortFormatNames)) if (format >= NELEM(gShortFormatNames))
printf("??? "); printf("??? ");
else else
printf("%s ", gShortFormatNames[format]); printf("%s ", gShortFormatNames[format]);
/* compute the percent size */ /* compute the percent size */
if ((!totalLen && totalCompLen) || (totalLen && !totalCompLen)) if ((!totalLen && totalCompLen) || (totalLen && !totalCompLen))
printf("--- "); /* weird */ printf("--- "); /* weird */
else if (totalLen < totalCompLen) else if (totalLen < totalCompLen)
printf(">100%% "); /* compression failed? */ printf(">100%% "); /* compression failed? */
else { else {
sprintf(tmpbuf, "%02d%%", ComputePercent(totalCompLen, totalLen)); sprintf(tmpbuf, "%02d%%", ComputePercent(totalCompLen, totalLen));
printf("%4s ", tmpbuf); printf("%4s ", tmpbuf);
} }
if (!totalLen && totalCompLen) if (!totalLen && totalCompLen)
printf(" ????"); /* weird */ printf(" ????"); /* weird */
else else
printf("%8ld", totalLen); printf("%8ld", totalLen);
printf("\n"); printf("\n");
NState_AddToTotals(pState, totalLen, totalCompLen); NState_AddToTotals(pState, totalLen, totalCompLen);
bail: bail:
if (err != kNuErrNone) { if (err != kNuErrNone) {
printf("(ERROR on '%s')\n", pRecord->filename == nil ? printf("(ERROR on '%s')\n", pRecord->filename == nil ?
"<unknown>" : (const char*)pRecord->filename); "<unknown>" : (const char*)pRecord->filename);
} }
return kNuOK; return kNuOK;
} }
/* /*
@ -278,24 +278,24 @@ bail:
NuError NuError
DoListShort(NulibState* pState) DoListShort(NulibState* pState)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
assert(pState != nil); assert(pState != nil);
err = OpenArchiveReadOnly(pState); err = OpenArchiveReadOnly(pState);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
pArchive = NState_GetNuArchive(pState); pArchive = NState_GetNuArchive(pState);
assert(pArchive != nil); assert(pArchive != nil);
err = NuContents(pArchive, ShowContentsShort); err = NuContents(pArchive, ShowContentsShort);
/* fall through with err */ /* fall through with err */
bail: bail:
if (pArchive != nil) if (pArchive != nil)
(void) NuClose(pArchive); (void) NuClose(pArchive);
return err; return err;
} }
@ -305,72 +305,72 @@ bail:
NuError NuError
DoListVerbose(NulibState* pState) DoListVerbose(NulibState* pState)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
const NuMasterHeader* pHeader; const NuMasterHeader* pHeader;
char date1[kNuDateOutputLen]; char date1[kNuDateOutputLen];
char date2[kNuDateOutputLen]; char date2[kNuDateOutputLen];
long totalLen, totalCompLen; long totalLen, totalCompLen;
const char* cp; const char* cp;
assert(pState != nil); assert(pState != nil);
err = OpenArchiveReadOnly(pState); err = OpenArchiveReadOnly(pState);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
pArchive = NState_GetNuArchive(pState); pArchive = NState_GetNuArchive(pState);
assert(pArchive != nil); assert(pArchive != nil);
/* /*
* Try to get just the filename. * Try to get just the filename.
*/ */
if (IsFilenameStdin(NState_GetArchiveFilename(pState))) if (IsFilenameStdin(NState_GetArchiveFilename(pState)))
cp = "<stdin>"; cp = "<stdin>";
else else
cp = FilenameOnly(pState, NState_GetArchiveFilename(pState)); cp = FilenameOnly(pState, NState_GetArchiveFilename(pState));
/* grab the master header block */ /* grab the master header block */
err = NuGetMasterHeader(pArchive, &pHeader); err = NuGetMasterHeader(pArchive, &pHeader);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
printf(" %-15.15s Created:%s Mod:%s Recs:%5lu\n\n", printf(" %-15.15s Created:%s Mod:%s Recs:%5lu\n\n",
cp, cp,
FormatDateShort(&pHeader->mhArchiveCreateWhen, date1), FormatDateShort(&pHeader->mhArchiveCreateWhen, date1),
FormatDateShort(&pHeader->mhArchiveModWhen, date2), FormatDateShort(&pHeader->mhArchiveModWhen, date2),
pHeader->mhTotalRecords); pHeader->mhTotalRecords);
printf(" Name Type Auxtyp Archived" printf(" Name Type Auxtyp Archived"
" Fmat Size Un-Length\n"); " Fmat Size Un-Length\n");
printf("-------------------------------------------------" printf("-------------------------------------------------"
"----------------------------\n"); "----------------------------\n");
err = NuContents(pArchive, ShowContentsVerbose); err = NuContents(pArchive, ShowContentsVerbose);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
/* /*
* Show the totals. NuFX overhead can be as much as 25% for archives * Show the totals. NuFX overhead can be as much as 25% for archives
* with lots of small files. * with lots of small files.
*/ */
NState_GetTotals(pState, &totalLen, &totalCompLen); NState_GetTotals(pState, &totalLen, &totalCompLen);
printf("-------------------------------------------------" printf("-------------------------------------------------"
"----------------------------\n"); "----------------------------\n");
printf(" Uncomp: %ld Comp: %ld %%of orig: %d%%\n", printf(" Uncomp: %ld Comp: %ld %%of orig: %d%%\n",
totalLen, totalCompLen, totalLen, totalCompLen,
totalLen == 0 ? 0 : ComputePercent(totalCompLen, totalLen)); totalLen == 0 ? 0 : ComputePercent(totalCompLen, totalLen));
#ifdef DEBUG_VERBOSE #ifdef DEBUG_VERBOSE
printf(" Overhead: %ld (%d%%)\n", printf(" Overhead: %ld (%d%%)\n",
pHeader->mhMasterEOF - totalCompLen, pHeader->mhMasterEOF - totalCompLen,
ComputePercent(pHeader->mhMasterEOF - totalCompLen, ComputePercent(pHeader->mhMasterEOF - totalCompLen,
pHeader->mhMasterEOF)); pHeader->mhMasterEOF));
#endif #endif
/*(void) NuDebugDumpArchive(pArchive);*/ /*(void) NuDebugDumpArchive(pArchive);*/
bail: bail:
if (pArchive != nil) if (pArchive != nil)
(void) NuClose(pArchive); (void) NuClose(pArchive);
return err; return err;
} }
@ -381,7 +381,7 @@ bail:
static NuResult static NuResult
NullCallback(NuArchive* pArchive, void* vpRecord) NullCallback(NuArchive* pArchive, void* vpRecord)
{ {
return kNuOK; return kNuOK;
} }
/* /*
@ -391,30 +391,30 @@ NullCallback(NuArchive* pArchive, void* vpRecord)
NuError NuError
DoListDebug(NulibState* pState) DoListDebug(NulibState* pState)
{ {
NuError err; NuError err;
NuArchive* pArchive = nil; NuArchive* pArchive = nil;
assert(pState != nil); assert(pState != nil);
err = OpenArchiveReadOnly(pState); err = OpenArchiveReadOnly(pState);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
pArchive = NState_GetNuArchive(pState); pArchive = NState_GetNuArchive(pState);
assert(pArchive != nil); assert(pArchive != nil);
/* have to do something to force the library to scan the archive */ /* have to do something to force the library to scan the archive */
err = NuContents(pArchive, NullCallback); err = NuContents(pArchive, NullCallback);
if (err != kNuErrNone) if (err != kNuErrNone)
goto bail; goto bail;
err = NuDebugDumpArchive(pArchive); err = NuDebugDumpArchive(pArchive);
if (err != kNuErrNone) if (err != kNuErrNone)
fprintf(stderr, "ERROR: debugging not enabled in nufxlib\n"); fprintf(stderr, "ERROR: debugging not enabled in nufxlib\n");
/* fall through with err */ /* fall through with err */
bail: bail:
if (pArchive != nil) if (pArchive != nil)
(void) NuClose(pArchive); (void) NuClose(pArchive);
return err; return err;
} }

524
nulib2/Main.c
View File

@ -20,21 +20,21 @@ const char* gProgName = "Nulib2";
* Which modifiers are valid with which commands? * Which modifiers are valid with which commands?
*/ */
typedef struct ValidCombo { typedef struct ValidCombo {
Command cmd; Command cmd;
Boolean okayForPipe; Boolean okayForPipe;
Boolean filespecRequired; Boolean filespecRequired;
const char* modifiers; const char* modifiers;
} ValidCombo; } ValidCombo;
static const ValidCombo gValidCombos[] = { static const ValidCombo gValidCombos[] = {
{ kCommandAdd, false, true, "ufrj0cke" }, { kCommandAdd, false, true, "ufrj0cke" },
{ kCommandDelete, false, true, "r" }, { kCommandDelete, false, true, "r" },
{ kCommandExtract, true, false, "ufrjclse" }, { kCommandExtract, true, false, "ufrjclse" },
{ kCommandExtractToPipe, true, false, "rl" }, { kCommandExtractToPipe, true, false, "rl" },
{ kCommandListShort, true, false, "" }, { kCommandListShort, true, false, "" },
{ kCommandListVerbose, true, false, "" }, { kCommandListVerbose, true, false, "" },
{ kCommandListDebug, true, false, "" }, { kCommandListDebug, true, false, "" },
{ kCommandTest, true, false, "r" }, { kCommandTest, true, false, "r" },
}; };
@ -46,14 +46,14 @@ static const ValidCombo gValidCombos[] = {
static const ValidCombo* static const ValidCombo*
FindValidComboEntry(Command cmd) FindValidComboEntry(Command cmd)
{ {
int i; int i;
for (i = 0; i < NELEM(gValidCombos); i++) { for (i = 0; i < NELEM(gValidCombos); i++) {
if (gValidCombos[i].cmd == cmd) if (gValidCombos[i].cmd == cmd)
return &gValidCombos[i]; return &gValidCombos[i];
} }
return nil; return nil;
} }
/* /*
@ -63,16 +63,16 @@ FindValidComboEntry(Command cmd)
static Boolean static Boolean
IsValidModifier(Command cmd, char modifier) IsValidModifier(Command cmd, char modifier)
{ {
const ValidCombo* pvc; const ValidCombo* pvc;
pvc = FindValidComboEntry(cmd); pvc = FindValidComboEntry(cmd);
if (pvc != nil) { if (pvc != nil) {
if (strchr(pvc->modifiers, modifier) == nil) if (strchr(pvc->modifiers, modifier) == nil)
return false; return false;
else else
return true; return true;
} else } else
return false; return false;
} }
/* /*
@ -81,13 +81,13 @@ IsValidModifier(Command cmd, char modifier)
static Boolean static Boolean
IsValidOnPipe(Command cmd) IsValidOnPipe(Command cmd)
{ {
const ValidCombo* pvc; const ValidCombo* pvc;
pvc = FindValidComboEntry(cmd); pvc = FindValidComboEntry(cmd);
if (pvc != nil) { if (pvc != nil) {
return pvc->okayForPipe; return pvc->okayForPipe;
} else } else
return false; return false;
} }
/* /*
@ -96,17 +96,17 @@ IsValidOnPipe(Command cmd)
static Boolean static Boolean
IsFilespecRequired(Command cmd) IsFilespecRequired(Command cmd)
{ {
const ValidCombo* pvc; const ValidCombo* pvc;
pvc = FindValidComboEntry(cmd); pvc = FindValidComboEntry(cmd);
if (pvc != nil) { if (pvc != nil) {
return pvc->filespecRequired; return pvc->filespecRequired;
} else { } else {
/* command not found? warn about it here... */ /* command not found? warn about it here... */
fprintf(stderr, "%s: Command %d not found in gValidCombos table\n", fprintf(stderr, "%s: Command %d not found in gValidCombos table\n",
gProgName, cmd); gProgName, cmd);
return false; return false;
} }
} }
@ -116,19 +116,19 @@ IsFilespecRequired(Command cmd)
static const char* static const char*
GetProgName(const NulibState* pState, const char* argv0) GetProgName(const NulibState* pState, const char* argv0)
{ {
const char* result; const char* result;
char sep; char sep;
/* use the appropriate system pathname separator */ /* use the appropriate system pathname separator */
sep = NState_GetSystemPathSeparator(pState); sep = NState_GetSystemPathSeparator(pState);
result = strrchr(argv0, sep); result = strrchr(argv0, sep);
if (result == nil) if (result == nil)
result = argv0; result = argv0;
else else
result++; /* advance past the separator */ result++; /* advance past the separator */
return result; return result;
} }
@ -138,34 +138,34 @@ GetProgName(const NulibState* pState, const char* argv0)
static void static void
Usage(const NulibState* pState) Usage(const NulibState* pState)
{ {
long majorVersion, minorVersion, bugVersion; long majorVersion, minorVersion, bugVersion;
const char* nufxLibDate; const char* nufxLibDate;
const char* nufxLibFlags; const char* nufxLibFlags;
(void) NuGetVersion(&majorVersion, &minorVersion, &bugVersion, (void) NuGetVersion(&majorVersion, &minorVersion, &bugVersion,
&nufxLibDate, &nufxLibFlags); &nufxLibDate, &nufxLibFlags);
printf("\nNulib2 v%s, linked with NufxLib v%ld.%ld.%ld [%s]\n", printf("\nNulib2 v%s, linked with NufxLib v%ld.%ld.%ld [%s]\n",
NState_GetProgramVersion(pState), NState_GetProgramVersion(pState),
majorVersion, minorVersion, bugVersion, nufxLibFlags); majorVersion, minorVersion, bugVersion, nufxLibFlags);
printf("This software is distributed under terms of the GNU General Public License.\n"); printf("This software is distributed under terms of the GNU General Public License.\n");
printf("Written by Andy McFadden, http://www.nulib.com/.\n\n"); printf("Written by Andy McFadden, http://www.nulib.com/.\n\n");
printf("Usage: %s -command[modifiers] archive [filename-list]\n\n", printf("Usage: %s -command[modifiers] archive [filename-list]\n\n",
gProgName); gProgName);
printf( printf(
" -a add files, create arc if needed -x extract files\n" " -a add files, create arc if needed -x extract files\n"
" -t list files (short) -v list files (verbose)\n" " -t list files (short) -v list files (verbose)\n"
" -p extract files to pipe, no msgs -i test archive integrity\n" " -p extract files to pipe, no msgs -i test archive integrity\n"
" -d delete files from archive\n" " -d delete files from archive\n"
"\n" "\n"
" modifiers:\n" " modifiers:\n"
" -u update files (add + keep newest) -f freshen (update, no add)\n" " -u update files (add + keep newest) -f freshen (update, no add)\n"
" -r recurse into subdirs -j junk (don't record) directory names\n" " -r recurse into subdirs -j junk (don't record) directory names\n"
" -0 don't use compression -c add one-line comments\n" " -0 don't use compression -c add one-line comments\n"
" -l auto-convert text files -ll auto-convert ALL files\n" " -l auto-convert text files -ll auto-convert ALL files\n"
" -s stomp existing files w/o asking -k store files as disk images\n" " -s stomp existing files w/o asking -k store files as disk images\n"
" -e preserve ProDOS file types -ee extend preserved names\n" " -e preserve ProDOS file types -ee extend preserved names\n"
); );
} }
@ -175,147 +175,147 @@ Usage(const NulibState* pState)
static int static int
ProcessOptions(NulibState* pState, int argc, char* const* argv) ProcessOptions(NulibState* pState, int argc, char* const* argv)
{ {
const char* cp; const char* cp;
int idx; int idx;
/* /*
* Must have at least a command letter and an archive filename. * Must have at least a command letter and an archive filename.
*/ */
if (argc < 3) { if (argc < 3) {
Usage(pState); Usage(pState);
return -1; return -1;
} }
/* /*
* Argv[1] and any subsequent entries that have a leading hyphen * Argv[1] and any subsequent entries that have a leading hyphen
* are options. Anything after that is a filename. Parse until we * are options. Anything after that is a filename. Parse until we
* think we've hit the filename. * think we've hit the filename.
* *
* By UNIX convention, however, stdin is specified as a file called "-". * By UNIX convention, however, stdin is specified as a file called "-".
*/ */
for (idx = 1; idx < argc; idx++) { for (idx = 1; idx < argc; idx++) {
cp = argv[idx]; cp = argv[idx];
if (idx > 1 && *cp != '-') if (idx > 1 && *cp != '-')
break; break;
if (*cp == '-') if (*cp == '-')
cp++; cp++;
if (*cp == '\0') { if (*cp == '\0') {
if (idx == 1) { if (idx == 1) {
fprintf(stderr, fprintf(stderr,
"%s: You must specify a command after the '-'\n", "%s: You must specify a command after the '-'\n",
gProgName); gProgName);
goto fail; goto fail;
} else { } else {
/* they're using '-' for the filename */ /* they're using '-' for the filename */
break; break;
} }
} }
if (idx == 1) { if (idx == 1) {
switch (tolower(*cp)) { switch (tolower(*cp)) {
case 'a': NState_SetCommand(pState, kCommandAdd); break; case 'a': NState_SetCommand(pState, kCommandAdd); break;
case 'x': NState_SetCommand(pState, kCommandExtract); break; case 'x': NState_SetCommand(pState, kCommandExtract); break;
case 'p': NState_SetCommand(pState, kCommandExtractToPipe); break; case 'p': NState_SetCommand(pState, kCommandExtractToPipe); break;
case 't': NState_SetCommand(pState, kCommandListShort); break; case 't': NState_SetCommand(pState, kCommandListShort); break;
case 'v': NState_SetCommand(pState, kCommandListVerbose); break; case 'v': NState_SetCommand(pState, kCommandListVerbose); break;
case 'z': NState_SetCommand(pState, kCommandListDebug); break; case 'z': NState_SetCommand(pState, kCommandListDebug); break;
case 'i': NState_SetCommand(pState, kCommandTest); break; case 'i': NState_SetCommand(pState, kCommandTest); break;
case 'd': NState_SetCommand(pState, kCommandDelete); break; case 'd': NState_SetCommand(pState, kCommandDelete); break;
default: default:
fprintf(stderr, "%s: Unknown command '%c'\n", gProgName, *cp); fprintf(stderr, "%s: Unknown command '%c'\n", gProgName, *cp);
goto fail; goto fail;
} }
cp++; cp++;
} }
while (*cp != '\0') { while (*cp != '\0') {
switch (tolower(*cp)) { switch (tolower(*cp)) {
case 'u': NState_SetModUpdate(pState, true); break; case 'u': NState_SetModUpdate(pState, true); break;
case 'f': NState_SetModFreshen(pState, true); break; case 'f': NState_SetModFreshen(pState, true); break;
case 'r': NState_SetModRecurse(pState, true); break; case 'r': NState_SetModRecurse(pState, true); break;
case 'j': NState_SetModJunkPaths(pState, true); break; case 'j': NState_SetModJunkPaths(pState, true); break;
case '0': NState_SetModNoCompression(pState, true); break; case '0': NState_SetModNoCompression(pState, true); break;
case 'c': NState_SetModComments(pState, true); break; case 'c': NState_SetModComments(pState, true); break;
case 's': NState_SetModOverwriteExisting(pState, true); break; case 's': NState_SetModOverwriteExisting(pState, true); break;
case 'k': NState_SetModAddAsDisk(pState, true); break; case 'k': NState_SetModAddAsDisk(pState, true); break;
case 'e': case 'e':
if (*(cp-1) == 'e') /* should never point at invalid */ if (*(cp-1) == 'e') /* should never point at invalid */
NState_SetModPreserveTypeExtended(pState, true); NState_SetModPreserveTypeExtended(pState, true);
else else
NState_SetModPreserveType(pState, true); NState_SetModPreserveType(pState, true);
break; break;
case 'l': case 'l':
if (*(cp-1) == 'l') /* should never point at invalid */ if (*(cp-1) == 'l') /* should never point at invalid */
NState_SetModConvertAll(pState, true); NState_SetModConvertAll(pState, true);
else else
NState_SetModConvertText(pState, true); NState_SetModConvertText(pState, true);
break; break;
default: default:
fprintf(stderr, "%s: Unknown modifier '%c'\n", gProgName, *cp); fprintf(stderr, "%s: Unknown modifier '%c'\n", gProgName, *cp);
goto fail; goto fail;
} }
if (!IsValidModifier(NState_GetCommand(pState), (char)tolower(*cp))) if (!IsValidModifier(NState_GetCommand(pState), (char)tolower(*cp)))
{ {
fprintf(stderr, fprintf(stderr,
"%s: The '%c' modifier doesn't make sense here\n", "%s: The '%c' modifier doesn't make sense here\n",
gProgName, tolower(*cp)); gProgName, tolower(*cp));
goto fail; goto fail;
} }
cp++; cp++;
} }
} }
/* /*
* See if we have an archive name. If it's "-", see if we allow that. * See if we have an archive name. If it's "-", see if we allow that.
*/ */
assert(idx < argc); assert(idx < argc);
NState_SetArchiveFilename(pState, argv[idx]); NState_SetArchiveFilename(pState, argv[idx]);
if (IsFilenameStdin(argv[idx])) { if (IsFilenameStdin(argv[idx])) {
if (!IsValidOnPipe(NState_GetCommand(pState))) { if (!IsValidOnPipe(NState_GetCommand(pState))) {
fprintf(stderr, "%s: You can't do that with a pipe\n", fprintf(stderr, "%s: You can't do that with a pipe\n",
gProgName); gProgName);
goto fail; goto fail;
} }
} }
idx++; idx++;
/* /*
* See if we have a file specification. Some of the commands require * See if we have a file specification. Some of the commands require
* a filespec; others just perform the requested operation on all of * a filespec; others just perform the requested operation on all of
* the records in the archive if none is provided. * the records in the archive if none is provided.
*/ */
if (idx < argc) { if (idx < argc) {
/* got one or more */ /* got one or more */
NState_SetFilespecPointer(pState, &argv[idx]); NState_SetFilespecPointer(pState, &argv[idx]);
NState_SetFilespecCount(pState, argc - idx); NState_SetFilespecCount(pState, argc - idx);
} else { } else {
assert(idx == argc); assert(idx == argc);
if (IsFilespecRequired(NState_GetCommand(pState))) { if (IsFilespecRequired(NState_GetCommand(pState))) {
fprintf(stderr, "%s: This command requires a list of files\n", fprintf(stderr, "%s: This command requires a list of files\n",
gProgName); gProgName);
goto fail; goto fail;
} }
NState_SetFilespecPointer(pState, nil); NState_SetFilespecPointer(pState, nil);
NState_SetFilespecCount(pState, 0); NState_SetFilespecCount(pState, 0);
} }
#ifdef DEBUG_VERBOSE #ifdef DEBUG_VERBOSE
NState_DebugDump(pState); NState_DebugDump(pState);
#endif #endif
return 0; return 0;
fail: fail:
fprintf(stderr, fprintf(stderr,
"%s: (invoke without arguments to see usage information)\n", "%s: (invoke without arguments to see usage information)\n",
gProgName); gProgName);
return -1; return -1;
} }
@ -328,42 +328,42 @@ fail:
int int
DoWork(NulibState* pState) DoWork(NulibState* pState)
{ {
NuError err; NuError err;
switch (NState_GetCommand(pState)) { switch (NState_GetCommand(pState)) {
case kCommandAdd: case kCommandAdd:
err = DoAdd(pState); err = DoAdd(pState);
break; break;
case kCommandExtract: case kCommandExtract:
err = DoExtract(pState); err = DoExtract(pState);
break; break;
case kCommandExtractToPipe: case kCommandExtractToPipe:
err = DoExtractToPipe(pState); err = DoExtractToPipe(pState);
break; break;
case kCommandTest: case kCommandTest:
err = DoTest(pState); err = DoTest(pState);
break; break;
case kCommandListShort: case kCommandListShort:
err = DoListShort(pState); err = DoListShort(pState);
break; break;
case kCommandListVerbose: case kCommandListVerbose:
err = DoListVerbose(pState); err = DoListVerbose(pState);
break; break;
case kCommandListDebug: case kCommandListDebug:
err = DoListDebug(pState); err = DoListDebug(pState);
break; break;
case kCommandDelete: case kCommandDelete:
err = DoDelete(pState); err = DoDelete(pState);
break; break;
default: default:
fprintf(stderr, "ERROR: unexpected command %d\n", fprintf(stderr, "ERROR: unexpected command %d\n",
NState_GetCommand(pState)); NState_GetCommand(pState));
err = kNuErrInternal; err = kNuErrInternal;
assert(0); assert(0);
break; break;
} }
return (err != kNuErrNone); return (err != kNuErrNone);
} }
/* /*
@ -372,38 +372,38 @@ DoWork(NulibState* pState)
int int
main(int argc, char** argv) main(int argc, char** argv)
{ {
NulibState* pState = nil; NulibState* pState = nil;
int result = 0; int result = 0;
#if 0 #if 0
extern NuResult ErrorMessageHandler(NuArchive* pArchive, extern NuResult ErrorMessageHandler(NuArchive* pArchive,
void* vErrorMessage); void* vErrorMessage);
NuSetGlobalErrorMessageHandler(ErrorMessageHandler); NuSetGlobalErrorMessageHandler(ErrorMessageHandler);
#endif #endif
if (NState_Init(&pState) != kNuErrNone) { if (NState_Init(&pState) != kNuErrNone) {
fprintf(stderr, "ERROR: unable to initialize globals\n"); fprintf(stderr, "ERROR: unable to initialize globals\n");
exit(1); exit(1);
} }
gProgName = GetProgName(pState, argv[0]); gProgName = GetProgName(pState, argv[0]);
if (ProcessOptions(pState, argc, argv) < 0) { if (ProcessOptions(pState, argc, argv) < 0) {
result = 2; result = 2;
goto bail; goto bail;
} }
if (NState_ExtraInit(pState) != kNuErrNone) { if (NState_ExtraInit(pState) != kNuErrNone) {
fprintf(stderr, "ERROR: additional initialization failed\n"); fprintf(stderr, "ERROR: additional initialization failed\n");
exit(1); exit(1);
} }
result = DoWork(pState); result = DoWork(pState);
if (result) if (result)
printf("Failed.\n"); printf("Failed.\n");
bail: bail:
NState_Free(pState); NState_Free(pState);
exit(result); exit(result);
} }

44
nulib2/MiscStuff.c
View File

@ -19,13 +19,13 @@
const char* const char*
Nu_strerror(int errnum) Nu_strerror(int errnum)
{ {
extern int sys_nerr; extern int sys_nerr;
extern char *sys_errlist[]; extern char *sys_errlist[];
if (errnum < 0 || errnum > sys_nerr) if (errnum < 0 || errnum > sys_nerr)
return NULL; return NULL;
return sys_errlist[errnum]; return sys_errlist[errnum];
} }
#endif #endif
@ -41,13 +41,13 @@ Nu_strerror(int errnum)
void* void*
Nu_memmove(void* dst, const void* src, size_t n) Nu_memmove(void* dst, const void* src, size_t n)
{ {
void* retval = dst; void* retval = dst;
char* srcp = (char*)src; char* srcp = (char*)src;
char* dstp = (char*)dst; char* dstp = (char*)dst;
/* you can normally get away with this if n==0 */ /* you can normally get away with this if n==0 */
assert(dst != NULL); assert(dst != NULL);
assert(src != NULL); assert(src != NULL);
if (dstp == srcp || !n) { if (dstp == srcp || !n) {
/* nothing to do */ /* nothing to do */
@ -63,7 +63,7 @@ Nu_memmove(void* dst, const void* src, size_t n)
*dstp++ = *srcp++; *dstp++ = *srcp++;
} }
return retval; return retval;
} }
#endif #endif
@ -83,7 +83,7 @@ Nu_memmove(void* dst, const void* src, size_t n)
unsigned long unsigned long
Nu_strtoul(const char *nptr, char **endptr, int base) Nu_strtoul(const char *nptr, char **endptr, int base)
{ {
return strtol(nptr, endptr, base); return strtol(nptr, endptr, base);
} }
#endif #endif
@ -94,9 +94,9 @@ Nu_strtoul(const char *nptr, char **endptr, int base)
int int
Nu_strcasecmp(const char *str1, const char *str2) Nu_strcasecmp(const char *str1, const char *str2)
{ {
while (*str1 && *str2 && toupper(*str1) == toupper(*str2)) while (*str1 && *str2 && toupper(*str1) == toupper(*str2))
str1++, str2++; str1++, str2++;
return (toupper(*str1) - toupper(*str2)); return (toupper(*str1) - toupper(*str2));
} }
#endif #endif
@ -108,13 +108,13 @@ Nu_strcasecmp(const char *str1, const char *str2)
int int
Nu_strncasecmp(const char *str1, const char *str2, size_t n) Nu_strncasecmp(const char *str1, const char *str2, size_t n)
{ {
while (n && *str1 && *str2 && toupper(*str1) == toupper(*str2)) while (n && *str1 && *str2 && toupper(*str1) == toupper(*str2))
str1++, str2++, n--; str1++, str2++, n--;
if (n) if (n)
return (toupper(*str1) - toupper(*str2)); return (toupper(*str1) - toupper(*str2));
else else
return 0; /* no mismatch in first n chars */ return 0; /* no mismatch in first n chars */
} }
#endif #endif

34
nulib2/MiscStuff.h
View File

@ -42,11 +42,11 @@ int Nu_strncasecmp(const char *s1, const char *s2, size_t n);
#include <sys/types.h> #include <sys/types.h>
#define nil NULL /* I can't seem to stop typing 'nil' now */ #define nil NULL /* I can't seem to stop typing 'nil' now */
typedef uchar Boolean; typedef uchar Boolean;
#define false (0) #define false (0)
#define true (!false) #define true (!false)
/* /*
@ -54,15 +54,15 @@ typedef uchar Boolean;
*/ */
/* compute #of elements in a static array */ /* compute #of elements in a static array */
#define NELEM(x) (sizeof(x) / sizeof((x)[0])) #define NELEM(x) (sizeof(x) / sizeof((x)[0]))
/* convert single hex digit char to number */ /* convert single hex digit char to number */
#define HexDigit(x) ( !isxdigit((int)(x)) ? -1 : \ #define HexDigit(x) ( !isxdigit((int)(x)) ? -1 : \
(x) <= '9' ? (x) - '0' : toupper(x) +10 - 'A' ) (x) <= '9' ? (x) - '0' : toupper(x) +10 - 'A' )
/* convert number from 0-15 to hex digit */ /* convert number from 0-15 to hex digit */
#define HexConv(x) ( ((uint)(x)) <= 15 ? \ #define HexConv(x) ( ((uint)(x)) <= 15 ? \
( (x) <= 9 ? (x) + '0' : (x) -10 + 'A') : -1 ) ( (x) <= 9 ? (x) + '0' : (x) -10 + 'A') : -1 )
/* /*
@ -80,29 +80,29 @@ typedef uchar Boolean;
#if defined(DEBUG_VERBOSE) #if defined(DEBUG_VERBOSE)
/* quick debug printf macro */ /* quick debug printf macro */
#define DBUG(args) printf args #define DBUG(args) printf args
#else #else
#define DBUG(args) ((void)0) #define DBUG(args) ((void)0)
#endif #endif
#if defined(NDEBUG) #if defined(NDEBUG)
#define DebugFill(addr, len) ((void)0) #define DebugFill(addr, len) ((void)0)
#define DebugAbort() ((void)0) #define DebugAbort() ((void)0)
#else #else
/* when debugging, fill Malloc blocks with junk, unless we're using Purify */ /* when debugging, fill Malloc blocks with junk, unless we're using Purify */
#if !defined(PURIFY) #if !defined(PURIFY)
#define DebugFill(addr, len) memset(addr, 0xa3, len) #define DebugFill(addr, len) memset(addr, 0xa3, len)
#else #else
#define DebugFill(addr, len) ((void)0) #define DebugFill(addr, len) ((void)0)
#endif #endif
#define DebugAbort() abort() #define DebugAbort() abort()
#endif #endif
#define kInvalidFill (0xa3) #define kInvalidFill (0xa3)
#define kInvalidPtr ((void*)0xa3a3a3a3) #define kInvalidPtr ((void*)0xa3a3a3a3)
#endif /*__MiscStuff__*/ #endif /*__MiscStuff__*/

98
nulib2/MiscUtils.c
View File

@ -19,39 +19,39 @@
void void
ReportError(NuError err, const char* format, ...) ReportError(NuError err, const char* format, ...)
{ {
const char* msg; const char* msg;
va_list args; va_list args;
assert(format != nil); assert(format != nil);
va_start(args, format); va_start(args, format);
/* print the message, if any */ /* print the message, if any */
if (format != nil) { if (format != nil) {
fprintf(stderr, "%s: ERROR: ", gProgName); fprintf(stderr, "%s: ERROR: ", gProgName);
vfprintf(stderr, format, args); vfprintf(stderr, format, args);
} }
/* print the error code data, if any */ /* print the error code data, if any */
if (err == kNuErrNone) if (err == kNuErrNone)
fprintf(stderr, "\n"); fprintf(stderr, "\n");
else { else {
if (format != nil) if (format != nil)
fprintf(stderr, ": "); fprintf(stderr, ": ");
msg = nil; msg = nil;
if (err >= 0) if (err >= 0)
msg = strerror(err); msg = strerror(err);
if (msg == nil) if (msg == nil)
msg = NuStrError(err); msg = NuStrError(err);
if (msg == nil) if (msg == nil)
fprintf(stderr, "(unknown err=%d)\n", err); fprintf(stderr, "(unknown err=%d)\n", err);
else else
fprintf(stderr, "%s\n", msg); fprintf(stderr, "%s\n", msg);
} }
va_end(args); va_end(args);
} }
@ -65,46 +65,46 @@ ReportError(NuError err, const char* format, ...)
void* void*
Malloc(size_t size) Malloc(size_t size)
{ {
void* _result; void* _result;
Assert(size > 0); Assert(size > 0);
_result = malloc(size); _result = malloc(size);
if (_result == nil) { if (_result == nil) {
ReportError(kNuErrMalloc, "malloc(%u) failed", (uint) size); ReportError(kNuErrMalloc, "malloc(%u) failed", (uint) size);
DebugAbort(); /* leave a core dump if we're built for it */ DebugAbort(); /* leave a core dump if we're built for it */
} }
DebugFill(_result, size); DebugFill(_result, size);
return _result; return _result;
} }
void* void*
Calloc(size_t size) Calloc(size_t size)
{ {
void* _cresult = Malloc(size); void* _cresult = Malloc(size);
memset(_cresult, 0, size); memset(_cresult, 0, size);
return _cresult; return _cresult;
} }
void* void*
Realloc(void* ptr, size_t size) Realloc(void* ptr, size_t size)
{ {
void* _result; void* _result;
Assert(ptr != nil); /* disallow this usage */ Assert(ptr != nil); /* disallow this usage */
Assert(size > 0); /* disallow this usage */ Assert(size > 0); /* disallow this usage */
_result = realloc(ptr, size); _result = realloc(ptr, size);
if (_result == nil) { if (_result == nil) {
ReportError(kNuErrMalloc, "realloc(%u) failed", (uint) size); ReportError(kNuErrMalloc, "realloc(%u) failed", (uint) size);
DebugAbort(); /* leave a core dump if we're built for it */ DebugAbort(); /* leave a core dump if we're built for it */
} }
return _result; return _result;
} }
void void
Free(void* ptr) Free(void* ptr)
{ {
if (ptr != nil) if (ptr != nil)
free(ptr); free(ptr);
} }
#endif #endif

18
nulib2/Nulib2.h
View File

@ -7,7 +7,7 @@
#ifndef __Nulib2__ #ifndef __Nulib2__
#define __Nulib2__ #define __Nulib2__
#include "SysDefs.h" /* system-dependent defs; must come first */ #include "SysDefs.h" /* system-dependent defs; must come first */
#include <NufxLib.h> #include <NufxLib.h>
#include "State.h" #include "State.h"
#include "MiscStuff.h" #include "MiscStuff.h"
@ -18,10 +18,10 @@
#endif #endif
/* replace unsupported chars with '%xx' */ /* replace unsupported chars with '%xx' */
#define kForeignIndic '%' #define kForeignIndic '%'
/* make our one-line comments this big */ /* make our one-line comments this big */
#define kDefaultCommentLen 200 #define kDefaultCommentLen 200
/* /*
@ -52,9 +52,9 @@ NuError DoTest(NulibState* pState);
const char* GetFileTypeString(ulong fileType); const char* GetFileTypeString(ulong fileType);
const char* NormalizePath(NulibState* pState, NuPathnameProposal* pathProposal); const char* NormalizePath(NulibState* pState, NuPathnameProposal* pathProposal);
void InterpretExtension(NulibState* pState, const char* pathName, void InterpretExtension(NulibState* pState, const char* pathName,
ulong* pFileType, ulong* pAuxType); ulong* pFileType, ulong* pAuxType);
Boolean ExtractPreservationString(NulibState* pState, char* pathname, Boolean ExtractPreservationString(NulibState* pState, char* pathname,
ulong* pFileType, ulong* pAuxType, NuThreadID* pThreadID); ulong* pFileType, ulong* pAuxType, NuThreadID* pThreadID);
void DenormalizePath(NulibState* pState, char* pathBuf); void DenormalizePath(NulibState* pState, char* pathBuf);
const char* FilenameOnly(NulibState* pState, const char* pathname); const char* FilenameOnly(NulibState* pState, const char* pathname);
const char* FindExtension(NulibState* pState, const char* pathname); const char* FindExtension(NulibState* pState, const char* pathname);
@ -73,7 +73,7 @@ void ReportError(NuError err, const char* format, ...)
__attribute__ ((format(printf, 2, 3))) __attribute__ ((format(printf, 2, 3)))
#endif #endif
; ;
#ifdef USE_DMALLOC /* want file and line numbers for calls */ #ifdef USE_DMALLOC /* want file and line numbers for calls */
# define Malloc(size) malloc(size) # define Malloc(size) malloc(size)
# define Calloc(size) calloc(1, size) # define Calloc(size) calloc(1, size)
# define Realloc(ptr, size) realloc(ptr, size) # define Realloc(ptr, size) realloc(ptr, size)
@ -87,11 +87,11 @@ void Free(void* ptr);
/* SysUtils.c */ /* SysUtils.c */
NuError NormalizeFileName(NulibState* pState, const char* srcp, long srcLen, NuError NormalizeFileName(NulibState* pState, const char* srcp, long srcLen,
char fssep, char** pDstp, long dstLen); char fssep, char** pDstp, long dstLen);
NuError NormalizeDirectoryName(NulibState* pState, const char* srcp, NuError NormalizeDirectoryName(NulibState* pState, const char* srcp,
long srcLen, char fssep, char** pDstp, long dstLen); long srcLen, char fssep, char** pDstp, long dstLen);
char* MakeTempArchiveName(NulibState* pState); char* MakeTempArchiveName(NulibState* pState);
NuError AddFile(NulibState* pState, NuArchive* pArchive, NuError AddFile(NulibState* pState, NuArchive* pArchive,
const char* pathname); const char* pathname);
#endif /*__Nulib2__*/ #endif /*__Nulib2__*/

6
nulib2/README.txt
View File

@ -59,16 +59,16 @@ DJGPP, follow the UNIX instructions.
NuLib2 has been tested with Microsoft Visual C++ 6.0. To build NuLib2, NuLib2 has been tested with Microsoft Visual C++ 6.0. To build NuLib2,
start up a DOS shell and run vcvars32.bat to set your environment. Run: start up a DOS shell and run vcvars32.bat to set your environment. Run:
nmake -f makefile.msc nmake -f makefile.msc
to build with debugging info, or to build with debugging info, or
nmake -f makefile.msc nodebug=1 nmake -f makefile.msc nodebug=1
to build optimized. to build optimized.
Other Notes Other Notes
=========== ===========
All of the source code was formatted with four-space hard tabs. All of the source code is now formatted with spaces instead of tabs.
Fun benchmark of the day: Fun benchmark of the day:

318
nulib2/State.c
View File

@ -18,19 +18,19 @@ static const char* gProgramVersion = "1.0.1";
NuError NuError
NState_Init(NulibState** ppState) NState_Init(NulibState** ppState)
{ {
assert(ppState != nil); assert(ppState != nil);
*ppState = Calloc(sizeof(**ppState)); *ppState = Calloc(sizeof(**ppState));
if (*ppState == nil) if (*ppState == nil)
return kNuErrMalloc; return kNuErrMalloc;
/* /*
* Initialize the contents to default values. * Initialize the contents to default values.
*/ */
(*ppState)->systemPathSeparator = PATH_SEP; (*ppState)->systemPathSeparator = PATH_SEP;
(*ppState)->programVersion = gProgramVersion; (*ppState)->programVersion = gProgramVersion;
return kNuErrNone; return kNuErrNone;
} }
/* /*
@ -39,30 +39,30 @@ NState_Init(NulibState** ppState)
NuError NuError
NState_ExtraInit(NulibState* pState) NState_ExtraInit(NulibState* pState)
{ {
NuError err; NuError err;
NuValue convertEOL; NuValue convertEOL;
/* /*
* Create a data sink for "stdout", in case we use the "-p" command. * Create a data sink for "stdout", in case we use the "-p" command.
* Set the EOL conversion according to the "-l" modifier. * Set the EOL conversion according to the "-l" modifier.
*/ */
convertEOL = kNuConvertOff; convertEOL = kNuConvertOff;
if (pState->modConvertText) if (pState->modConvertText)
convertEOL = kNuConvertAuto; convertEOL = kNuConvertAuto;
if (pState->modConvertAll) if (pState->modConvertAll)
convertEOL = kNuConvertOn; convertEOL = kNuConvertOn;
err = NuCreateDataSinkForFP(true, convertEOL, stdout, &pState->pPipeSink); err = NuCreateDataSinkForFP(true, convertEOL, stdout, &pState->pPipeSink);
if (err != kNuErrNone) if (err != kNuErrNone)
return err; return err;
/* /*
* Create a data sink for "stdout", in case we use the "-c" modifier. * Create a data sink for "stdout", in case we use the "-c" modifier.
* The EOL conversion is always on. * The EOL conversion is always on.
*/ */
err = NuCreateDataSinkForFP(true, kNuConvertOn, stdout, err = NuCreateDataSinkForFP(true, kNuConvertOn, stdout,
&pState->pCommentSink); &pState->pCommentSink);
return err; return err;
} }
@ -72,16 +72,16 @@ NState_ExtraInit(NulibState* pState)
void void
NState_Free(NulibState* pState) NState_Free(NulibState* pState)
{ {
if (pState == nil) if (pState == nil)
return; return;
Free(pState->renameToStr); /* ?? */ Free(pState->renameToStr); /* ?? */
Free(pState->tempPathnameBuf); Free(pState->tempPathnameBuf);
if (pState->pPipeSink != nil) if (pState->pPipeSink != nil)
NuFreeDataSink(pState->pPipeSink); NuFreeDataSink(pState->pPipeSink);
if (pState->pCommentSink != nil) if (pState->pCommentSink != nil)
NuFreeDataSink(pState->pCommentSink); NuFreeDataSink(pState->pCommentSink);
Free(pState); Free(pState);
} }
@ -89,411 +89,411 @@ NState_Free(NulibState* pState)
void void
NState_DebugDump(const NulibState* pState) NState_DebugDump(const NulibState* pState)
{ {
/* this will break when the code changes, but it's just for debugging */ /* this will break when the code changes, but it's just for debugging */
static const char* kCommandNames[] = { static const char* kCommandNames[] = {
"<unknown>", "<unknown>",
"add", "add",
"delete", "delete",
"extract", "extract",
"extractToPipe", "extractToPipe",
"listShort", "listShort",
"listVerbose", "listVerbose",
"listDebug", "listDebug",
"test", "test",
}; };
assert(pState != nil); assert(pState != nil);
printf("NState:\n"); printf("NState:\n");
printf(" programVersion: '%s'\n", pState->programVersion); printf(" programVersion: '%s'\n", pState->programVersion);
printf(" systemPathSeparator: '%c'\n", pState->systemPathSeparator); printf(" systemPathSeparator: '%c'\n", pState->systemPathSeparator);
printf(" archiveFilename: '%s'\n", pState->archiveFilename); printf(" archiveFilename: '%s'\n", pState->archiveFilename);
printf(" filespec: %ld (%s ...)\n", pState->filespecCount, printf(" filespec: %ld (%s ...)\n", pState->filespecCount,
!pState->filespecCount ? "<none>" : *pState->filespecPointer); !pState->filespecCount ? "<none>" : *pState->filespecPointer);
printf(" command: %d (%s); modifiers:\n", pState->command, printf(" command: %d (%s); modifiers:\n", pState->command,
kCommandNames[pState->command]); kCommandNames[pState->command]);
if (pState->modUpdate) if (pState->modUpdate)
printf(" update\n"); printf(" update\n");
if (pState->modFreshen) if (pState->modFreshen)
printf(" freshen\n"); printf(" freshen\n");
if (pState->modRecurse) if (pState->modRecurse)
printf(" recurse\n"); printf(" recurse\n");
if (pState->modJunkPaths) if (pState->modJunkPaths)
printf(" junkPaths\n"); printf(" junkPaths\n");
if (pState->modNoCompression) if (pState->modNoCompression)
printf(" noCompression\n"); printf(" noCompression\n");
if (pState->modComments) if (pState->modComments)
printf(" comments\n"); printf(" comments\n");
if (pState->modConvertText) if (pState->modConvertText)
printf(" convertText\n"); printf(" convertText\n");
if (pState->modConvertAll) if (pState->modConvertAll)
printf(" convertAll\n"); printf(" convertAll\n");
if (pState->modOverwriteExisting) if (pState->modOverwriteExisting)
printf(" overwriteExisting\n"); printf(" overwriteExisting\n");
if (pState->modPreserveType) if (pState->modPreserveType)
printf(" preserveType\n"); printf(" preserveType\n");
if (pState->modPreserveTypeExtended) if (pState->modPreserveTypeExtended)
printf(" preserveTypeExtended\n"); printf(" preserveTypeExtended\n");
printf("\n"); printf("\n");
} }
#endif #endif
/* /*
* =========================================================================== * ===========================================================================
* Simple set/get functions * Simple set/get functions
* =========================================================================== * ===========================================================================
*/ */
char char
NState_GetSystemPathSeparator(const NulibState* pState) NState_GetSystemPathSeparator(const NulibState* pState)
{ {
return pState->systemPathSeparator; return pState->systemPathSeparator;
} }
const char* const char*
NState_GetProgramVersion(const NulibState* pState) NState_GetProgramVersion(const NulibState* pState)
{ {
return pState->programVersion; return pState->programVersion;
} }
NuArchive* NuArchive*
NState_GetNuArchive(const NulibState* pState) NState_GetNuArchive(const NulibState* pState)
{ {
return pState->pArchive; return pState->pArchive;
} }
void void
NState_SetNuArchive(NulibState* pState, NuArchive* pArchive) NState_SetNuArchive(NulibState* pState, NuArchive* pArchive)
{ {
pState->pArchive = pArchive; pState->pArchive = pArchive;
} }
Boolean Boolean
NState_GetSuppressOutput(const NulibState* pState) NState_GetSuppressOutput(const NulibState* pState)
{ {
return pState->suppressOutput; return pState->suppressOutput;
} }
void void
NState_SetSuppressOutput(NulibState* pState, Boolean doSuppress) NState_SetSuppressOutput(NulibState* pState, Boolean doSuppress)
{ {
pState->suppressOutput = doSuppress; pState->suppressOutput = doSuppress;
} }
Boolean Boolean
NState_GetInputUnavailable(const NulibState* pState) NState_GetInputUnavailable(const NulibState* pState)
{ {
return pState->inputUnavailable; return pState->inputUnavailable;
} }
void void
NState_SetInputUnavailable(NulibState* pState, Boolean isUnavailable) NState_SetInputUnavailable(NulibState* pState, Boolean isUnavailable)
{ {
pState->inputUnavailable = isUnavailable; pState->inputUnavailable = isUnavailable;
} }
NuRecordIdx NuRecordIdx
NState_GetRenameFromIdx(const NulibState* pState) NState_GetRenameFromIdx(const NulibState* pState)
{ {
return pState->renameFromIdx; return pState->renameFromIdx;
} }
void void
NState_SetRenameFromIdx(NulibState* pState, NuRecordIdx recordIdx) NState_SetRenameFromIdx(NulibState* pState, NuRecordIdx recordIdx)
{ {
pState->renameFromIdx = recordIdx; pState->renameFromIdx = recordIdx;
} }
char* char*
NState_GetRenameToStr(const NulibState* pState) NState_GetRenameToStr(const NulibState* pState)
{ {
return pState->renameToStr; return pState->renameToStr;
} }
void void
NState_SetRenameToStr(NulibState* pState, char* str) NState_SetRenameToStr(NulibState* pState, char* str)
{ {
Free(pState->renameToStr); Free(pState->renameToStr);
pState->renameToStr = str; pState->renameToStr = str;
} }
NuDataSink* NuDataSink*
NState_GetPipeSink(const NulibState* pState) NState_GetPipeSink(const NulibState* pState)
{ {
return pState->pPipeSink; return pState->pPipeSink;
} }
NuDataSink* NuDataSink*
NState_GetCommentSink(const NulibState* pState) NState_GetCommentSink(const NulibState* pState)
{ {
return pState->pCommentSink; return pState->pCommentSink;
} }
long long
NState_GetMatchCount(const NulibState* pState) NState_GetMatchCount(const NulibState* pState)
{ {
return pState->matchCount; return pState->matchCount;
} }
void void
NState_SetMatchCount(NulibState* pState, long count) NState_SetMatchCount(NulibState* pState, long count)
{ {
pState->matchCount = count; pState->matchCount = count;
} }
void void
NState_IncMatchCount(NulibState* pState) NState_IncMatchCount(NulibState* pState)
{ {
pState->matchCount++; pState->matchCount++;
} }
void void
NState_AddToTotals(NulibState* pState, long len, long compLen) NState_AddToTotals(NulibState* pState, long len, long compLen)
{ {
pState->totalLen += len; pState->totalLen += len;
pState->totalCompLen += compLen; pState->totalCompLen += compLen;
} }
void void
NState_GetTotals(NulibState* pState, long* pTotalLen, long* pTotalCompLen) NState_GetTotals(NulibState* pState, long* pTotalLen, long* pTotalCompLen)
{ {
*pTotalLen = pState->totalLen; *pTotalLen = pState->totalLen;
*pTotalCompLen = pState->totalCompLen; *pTotalCompLen = pState->totalCompLen;
} }
long long
NState_GetTempPathnameLen(NulibState* pState) NState_GetTempPathnameLen(NulibState* pState)
{ {
return pState->tempPathnameAlloc; return pState->tempPathnameAlloc;
} }
void void
NState_SetTempPathnameLen(NulibState* pState, long len) NState_SetTempPathnameLen(NulibState* pState, long len)
{ {
char* newBuf; char* newBuf;
len++; /* add one for the '\0' */ len++; /* add one for the '\0' */
if (pState->tempPathnameAlloc < len) { if (pState->tempPathnameAlloc < len) {
if (pState->tempPathnameBuf == nil) if (pState->tempPathnameBuf == nil)
newBuf = Malloc(len); newBuf = Malloc(len);
else else
newBuf = Realloc(pState->tempPathnameBuf, len); newBuf = Realloc(pState->tempPathnameBuf, len);
assert(newBuf != nil); assert(newBuf != nil);
if (newBuf == nil) { if (newBuf == nil) {
Free(pState->tempPathnameBuf); Free(pState->tempPathnameBuf);
pState->tempPathnameBuf = nil; pState->tempPathnameBuf = nil;
pState->tempPathnameAlloc = 0; pState->tempPathnameAlloc = 0;
ReportError(kNuErrMalloc, "buf realloc failed (%ld)", len); ReportError(kNuErrMalloc, "buf realloc failed (%ld)", len);
return; return;
} }
pState->tempPathnameBuf = newBuf; pState->tempPathnameBuf = newBuf;
pState->tempPathnameAlloc = len; pState->tempPathnameAlloc = len;
} }
} }
char* char*
NState_GetTempPathnameBuf(NulibState* pState) NState_GetTempPathnameBuf(NulibState* pState)
{ {
return pState->tempPathnameBuf; return pState->tempPathnameBuf;
} }
Command Command
NState_GetCommand(const NulibState* pState) NState_GetCommand(const NulibState* pState)
{ {
return pState->command; return pState->command;
} }
void void
NState_SetCommand(NulibState* pState, Command cmd) NState_SetCommand(NulibState* pState, Command cmd)
{ {
pState->command = cmd; pState->command = cmd;
} }
const char* const char*
NState_GetArchiveFilename(const NulibState* pState) NState_GetArchiveFilename(const NulibState* pState)
{ {
return pState->archiveFilename; return pState->archiveFilename;
} }
void void
NState_SetArchiveFilename(NulibState* pState, const char* archiveFilename) NState_SetArchiveFilename(NulibState* pState, const char* archiveFilename)
{ {
pState->archiveFilename = archiveFilename; pState->archiveFilename = archiveFilename;
} }
char* const* char* const*
NState_GetFilespecPointer(const NulibState* pState) NState_GetFilespecPointer(const NulibState* pState)
{ {
return pState->filespecPointer; return pState->filespecPointer;
} }
void void
NState_SetFilespecPointer(NulibState* pState, char* const* filespecPointer) NState_SetFilespecPointer(NulibState* pState, char* const* filespecPointer)
{ {
pState->filespecPointer = filespecPointer; pState->filespecPointer = filespecPointer;
} }
long long
NState_GetFilespecCount(const NulibState* pState) NState_GetFilespecCount(const NulibState* pState)
{ {
return pState->filespecCount; return pState->filespecCount;
} }
void void
NState_SetFilespecCount(NulibState* pState, long filespecCount) NState_SetFilespecCount(NulibState* pState, long filespecCount)
{ {
pState->filespecCount = filespecCount; pState->filespecCount = filespecCount;
} }
Boolean Boolean
NState_GetModUpdate(const NulibState* pState) NState_GetModUpdate(const NulibState* pState)
{ {
return pState->modUpdate; return pState->modUpdate;
} }
void void
NState_SetModUpdate(NulibState* pState, Boolean val) NState_SetModUpdate(NulibState* pState, Boolean val)
{ {
pState->modUpdate = val; pState->modUpdate = val;
} }
Boolean Boolean
NState_GetModFreshen(const NulibState* pState) NState_GetModFreshen(const NulibState* pState)
{ {
return pState->modFreshen; return pState->modFreshen;
} }
void void
NState_SetModFreshen(NulibState* pState, Boolean val) NState_SetModFreshen(NulibState* pState, Boolean val)
{ {
pState->modFreshen = val; pState->modFreshen = val;
} }
Boolean Boolean
NState_GetModRecurse(const NulibState* pState) NState_GetModRecurse(const NulibState* pState)
{ {
return pState->modRecurse; return pState->modRecurse;
} }
void void
NState_SetModRecurse(NulibState* pState, Boolean val) NState_SetModRecurse(NulibState* pState, Boolean val)
{ {
pState->modRecurse = val; pState->modRecurse = val;
} }
Boolean Boolean
NState_GetModJunkPaths(const NulibState* pState) NState_GetModJunkPaths(const NulibState* pState)
{ {
return pState->modJunkPaths; return pState->modJunkPaths;
} }
void void
NState_SetModJunkPaths(NulibState* pState, Boolean val) NState_SetModJunkPaths(NulibState* pState, Boolean val)
{ {
pState->modJunkPaths = val; pState->modJunkPaths = val;
} }
Boolean Boolean
NState_GetModNoCompression(const NulibState* pState) NState_GetModNoCompression(const NulibState* pState)
{ {
return pState->modNoCompression; return pState->modNoCompression;
} }
void void
NState_SetModNoCompression(NulibState* pState, Boolean val) NState_SetModNoCompression(NulibState* pState, Boolean val)
{ {
pState->modNoCompression = val; pState->modNoCompression = val;
} }
Boolean Boolean
NState_GetModComments(const NulibState* pState) NState_GetModComments(const NulibState* pState)
{ {
return pState->modComments; return pState->modComments;
} }
void void
NState_SetModComments(NulibState* pState, Boolean val) NState_SetModComments(NulibState* pState, Boolean val)
{ {
pState->modComments = val; pState->modComments = val;
} }
Boolean Boolean
NState_GetModConvertText(const NulibState* pState) NState_GetModConvertText(const NulibState* pState)
{ {
return pState->modConvertText; return pState->modConvertText;
} }
void void
NState_SetModConvertText(NulibState* pState, Boolean val) NState_SetModConvertText(NulibState* pState, Boolean val)
{ {
pState->modConvertText = val; pState->modConvertText = val;
} }
Boolean Boolean
NState_GetModConvertAll(const NulibState* pState) NState_GetModConvertAll(const NulibState* pState)
{ {
return pState->modConvertAll; return pState->modConvertAll;
} }
void void
NState_SetModConvertAll(NulibState* pState, Boolean val) NState_SetModConvertAll(NulibState* pState, Boolean val)
{ {
pState->modConvertAll = val; pState->modConvertAll = val;
} }
Boolean Boolean
NState_GetModOverwriteExisting(const NulibState* pState) NState_GetModOverwriteExisting(const NulibState* pState)
{ {
return pState->modOverwriteExisting; return pState->modOverwriteExisting;
} }
void void
NState_SetModOverwriteExisting(NulibState* pState, Boolean val) NState_SetModOverwriteExisting(NulibState* pState, Boolean val)
{ {
pState->modOverwriteExisting = val; pState->modOverwriteExisting = val;
} }
Boolean Boolean
NState_GetModAddAsDisk(const NulibState* pState) NState_GetModAddAsDisk(const NulibState* pState)
{ {
return pState->modAddAsDisk; return pState->modAddAsDisk;
} }
void void
NState_SetModAddAsDisk(NulibState* pState, Boolean val) NState_SetModAddAsDisk(NulibState* pState, Boolean val)
{ {
pState->modAddAsDisk = val; pState->modAddAsDisk = val;
} }
Boolean Boolean
NState_GetModPreserveType(const NulibState* pState) NState_GetModPreserveType(const NulibState* pState)
{ {
return pState->modPreserveType; return pState->modPreserveType;
} }
void void
NState_SetModPreserveType(NulibState* pState, Boolean val) NState_SetModPreserveType(NulibState* pState, Boolean val)
{ {
pState->modPreserveType = val; pState->modPreserveType = val;
} }
Boolean Boolean
NState_GetModPreserveTypeExtended(const NulibState* pState) NState_GetModPreserveTypeExtended(const NulibState* pState)
{ {
return pState->modPreserveTypeExtended; return pState->modPreserveTypeExtended;
} }
void void
NState_SetModPreserveTypeExtended(NulibState* pState, Boolean val) NState_SetModPreserveTypeExtended(NulibState* pState, Boolean val)
{ {
pState->modPreserveTypeExtended = val; pState->modPreserveTypeExtended = val;
} }

90
nulib2/State.h
View File

@ -16,15 +16,15 @@
* (Some debug code in NState_DebugDump() is sensitive to the order here.) * (Some debug code in NState_DebugDump() is sensitive to the order here.)
*/ */
typedef enum Command { typedef enum Command {
kCommandUnknown = 0, kCommandUnknown = 0,
kCommandAdd, kCommandAdd,
kCommandDelete, kCommandDelete,
kCommandExtract, kCommandExtract,
kCommandExtractToPipe, kCommandExtractToPipe,
kCommandListShort, kCommandListShort,
kCommandListVerbose, kCommandListVerbose,
kCommandListDebug, kCommandListDebug,
kCommandTest kCommandTest
} Command; } Command;
@ -32,48 +32,48 @@ typedef enum Command {
* Program-wide state. * Program-wide state.
*/ */
typedef struct NulibState { typedef struct NulibState {
/* global goodness */ /* global goodness */
const char* programVersion; const char* programVersion;
/* system-specific values */ /* system-specific values */
char systemPathSeparator; char systemPathSeparator;
/* pointer to archive we're working with */ /* pointer to archive we're working with */
NuArchive* pArchive; NuArchive* pArchive;
/* misc state */ /* misc state */
Boolean suppressOutput; Boolean suppressOutput;
Boolean inputUnavailable; Boolean inputUnavailable;
NuRecordIdx renameFromIdx; NuRecordIdx renameFromIdx;
char* renameToStr; char* renameToStr;
NuDataSink* pPipeSink; NuDataSink* pPipeSink;
NuDataSink* pCommentSink; NuDataSink* pCommentSink;
long matchCount; long matchCount;
long totalLen; long totalLen;
long totalCompLen; long totalCompLen;
/* temp storage */ /* temp storage */
long tempPathnameAlloc; long tempPathnameAlloc;
char* tempPathnameBuf; char* tempPathnameBuf;
/* command-line options */ /* command-line options */
Command command; Command command;
Boolean modUpdate; Boolean modUpdate;
Boolean modFreshen; Boolean modFreshen;
Boolean modRecurse; Boolean modRecurse;
Boolean modJunkPaths; Boolean modJunkPaths;
Boolean modNoCompression; Boolean modNoCompression;
Boolean modComments; Boolean modComments;
Boolean modConvertText; Boolean modConvertText;
Boolean modConvertAll; Boolean modConvertAll;
Boolean modOverwriteExisting; Boolean modOverwriteExisting;
Boolean modAddAsDisk; Boolean modAddAsDisk;
Boolean modPreserveType; Boolean modPreserveType;
Boolean modPreserveTypeExtended; Boolean modPreserveTypeExtended;
const char* archiveFilename; const char* archiveFilename;
char* const* filespecPointer; char* const* filespecPointer;
long filespecCount; long filespecCount;
} NulibState; } NulibState;
NuError NState_Init(NulibState** ppState); NuError NState_Init(NulibState** ppState);

56
nulib2/SunOS4.h
View File

@ -13,35 +13,35 @@
#define __SunOS4__ #define __SunOS4__
#ifdef __GNUC__ #ifdef __GNUC__
extern int _flsbuf(int, FILE*); extern int _flsbuf(int, FILE*);
extern int _filbuf(FILE*); extern int _filbuf(FILE*);
#endif #endif
extern void bcopy(char*, char*, int); extern void bcopy(char*, char*, int);
extern int fclose(FILE*); extern int fclose(FILE*);
extern int fflush(FILE*); extern int fflush(FILE*);
extern int fprintf(FILE*, const char*, ...); extern int fprintf(FILE*, const char*, ...);
extern int fread(char*, int, int, FILE *); extern int fread(char*, int, int, FILE *);
extern int fseek(FILE*, long, int); extern int fseek(FILE*, long, int);
extern int ftruncate(int, off_t); extern int ftruncate(int, off_t);
extern int fwrite(const char*, int, int, FILE*); extern int fwrite(const char*, int, int, FILE*);
extern char* mktemp(char *template); extern char* mktemp(char *template);
extern time_t mktime(struct tm*); extern time_t mktime(struct tm*);
extern int perror(const char*); extern int perror(const char*);
extern int printf(const char*, ...); extern int printf(const char*, ...);
extern int remove(const char*); extern int remove(const char*);
extern int rename(const char*, const char*); extern int rename(const char*, const char*);
extern int tolower(int); extern int tolower(int);
extern int setvbuf(FILE*, char*, int, int); extern int setvbuf(FILE*, char*, int, int);
extern int sscanf(char*, const char*, ...); extern int sscanf(char*, const char*, ...);
extern int strcasecmp(const char*, const char*); extern int strcasecmp(const char*, const char*);
extern int strncasecmp(const char*, const char*, size_t); extern int strncasecmp(const char*, const char*, size_t);
extern long strtol(const char *, char **, int); extern long strtol(const char *, char **, int);
extern int system(const char*); extern int system(const char*);
extern time_t timelocal(struct tm*); extern time_t timelocal(struct tm*);
extern time_t time(time_t*); extern time_t time(time_t*);
extern int toupper(int); extern int toupper(int);
extern int vfprintf(FILE*, const char *, va_list); extern int vfprintf(FILE*, const char *, va_list);
extern char* vsprintf(char *str, const char *format, va_list ap); extern char* vsprintf(char *str, const char *format, va_list ap);
#endif /*__SunOS4__*/ #endif /*__SunOS4__*/

10
nulib2/SysDefs.h
View File

@ -93,16 +93,16 @@
#if defined(WINDOWS_LIKE) #if defined(WINDOWS_LIKE)
# ifndef F_OK # ifndef F_OK
# define F_OK 02 # define F_OK 02
# endif # endif
# ifndef R_OK # ifndef R_OK
# define R_OK 04 # define R_OK 04
# endif # endif
#endif #endif
#if defined(__unix__) || defined(__unix) || defined(__BEOS__) || \ #if defined(__unix__) || defined(__unix) || defined(__BEOS__) || \
defined(__hpux) || defined(_AIX) || defined(__APPLE__) defined(__hpux) || defined(_AIX) || defined(__APPLE__)
# define UNIX_LIKE # define UNIX_LIKE
#endif #endif
@ -190,7 +190,7 @@
# endif # endif
#endif #endif
#ifdef __GNUC__ /* this was missing from BeOS __MWERKS__, and probably others */ #ifdef __GNUC__ /* this was missing from BeOS __MWERKS__, and probably others */
# define HAS__FUNCTION__ # define HAS__FUNCTION__
#endif #endif
@ -207,7 +207,7 @@
# define SYSTEM_DEFAULT_EOL "\n" # define SYSTEM_DEFAULT_EOL "\n"
#endif #endif
#ifndef MAX_PATH_LEN #ifndef MAX_PATH_LEN
# define MAX_PATH_LEN 1024 # define MAX_PATH_LEN 1024
#endif #endif
#endif /*__SysDefs__*/ #endif /*__SysDefs__*/

1188
nulib2/SysUtils.c
View File

File diff suppressed because it is too large Load Diff

56
nulib2/configure.in
View File

@ -15,7 +15,7 @@ dnl Checks for header files.
AC_HEADER_DIRENT AC_HEADER_DIRENT
AC_HEADER_STDC AC_HEADER_STDC
AC_CHECK_HEADERS(fcntl.h limits.h malloc.h stdlib.h strings.h sys/stat.h \ AC_CHECK_HEADERS(fcntl.h limits.h malloc.h stdlib.h strings.h sys/stat.h \
sys/time.h sys/types.h unistd.h) sys/time.h sys/types.h unistd.h)
dnl Checks for typedefs, structures, and compiler characteristics. dnl Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST AC_C_CONST
@ -37,50 +37,50 @@ dnl BeOS doesn't like /usr/local/include, and gets feisty about it. If libdir
dnl and includedir are set to defaults, replace them with BeOS values. This dnl and includedir are set to defaults, replace them with BeOS values. This
dnl might be going a little too far... dnl might be going a little too far...
if test "$host_os" = "beos"; then if test "$host_os" = "beos"; then
if test "$prefix" = "NONE" -a \ if test "$prefix" = "NONE" -a \
"$includedir" = '${prefix}/include' -a \ "$includedir" = '${prefix}/include' -a \
"$libdir" = '${exec_prefix}/lib' -a \ "$libdir" = '${exec_prefix}/lib' -a \
"$bindir" = '${exec_prefix}/bin' -a \ "$bindir" = '${exec_prefix}/bin' -a \
"$mandir" = '${prefix}/man' "$mandir" = '${prefix}/man'
then then
echo replacing install locations with BeOS values echo replacing install locations with BeOS values
prefix=/boot prefix=/boot
includedir='${prefix}/develop/headers' includedir='${prefix}/develop/headers'
libdir='${exec_prefix}/home/config/lib' libdir='${exec_prefix}/home/config/lib'
bindir='${exec_prefix}/home/config/bin' bindir='${exec_prefix}/home/config/bin'
mandir='/tmp' mandir='/tmp'
AC_SUBST(prefix) AC_SUBST(prefix)
AC_SUBST(includedir) AC_SUBST(includedir)
AC_SUBST(libdir) AC_SUBST(libdir)
AC_SUBST(bindir) AC_SUBST(bindir)
AC_SUBST(mandir) AC_SUBST(mandir)
fi fi
fi fi
dnl Figure out what the build and link flags should be dnl Figure out what the build and link flags should be
if test "$host_cpu" = "powerpc" -a "$host_os" = "beos"; then if test "$host_cpu" = "powerpc" -a "$host_os" = "beos"; then
dnl BeOS/PPC with Metrowerks compiler dnl BeOS/PPC with Metrowerks compiler
CC=cc CC=cc
GCC= GCC=
CFLAGS='-proc 603 -opt full' CFLAGS='-proc 603 -opt full'
echo "forcing CC to \"$CC\" and CFLAGS to \"$CFLAGS\"" echo "forcing CC to \"$CC\" and CFLAGS to \"$CFLAGS\""
fi fi
dnl if we're using gcc, include gcc-specific warning flags dnl if we're using gcc, include gcc-specific warning flags
dnl ( dnl (
if test -z "$GCC"; then if test -z "$GCC"; then
BUILD_FLAGS='$(OPT)' BUILD_FLAGS='$(OPT)'
else else
BUILD_FLAGS='$(OPT) $(GCC_FLAGS)' BUILD_FLAGS='$(OPT) $(GCC_FLAGS)'
fi fi
AC_SUBST(BUILD_FLAGS) AC_SUBST(BUILD_FLAGS)
DMALLOC= DMALLOC=
AC_ARG_ENABLE(dmalloc, [ --enable-dmalloc: do dmalloc stuff], \ AC_ARG_ENABLE(dmalloc, [ --enable-dmalloc: do dmalloc stuff], \
[ echo "--- enabling dmalloc"; [ echo "--- enabling dmalloc";
DMALLOC="-L/usr/local/lib -ldmalloc"; AC_DEFINE(USE_DMALLOC) ]) DMALLOC="-L/usr/local/lib -ldmalloc"; AC_DEFINE(USE_DMALLOC) ])
AC_SUBST(DMALLOC) AC_SUBST(DMALLOC)
AC_OUTPUT(Makefile) AC_OUTPUT(Makefile)