summaryrefslogtreecommitdiff
path: root/macos/source/macos.c
diff options
context:
space:
mode:
Diffstat (limited to 'macos/source/macos.c')
-rw-r--r--macos/source/macos.c1079
1 files changed, 1079 insertions, 0 deletions
diff --git a/macos/source/macos.c b/macos/source/macos.c
new file mode 100644
index 0000000..3cfee7b
--- /dev/null
+++ b/macos/source/macos.c
@@ -0,0 +1,1079 @@
+/*
+ Copyright (c) 1990-2005 Info-ZIP. All rights reserved.
+
+ See the accompanying file LICENSE, version 2004-May-22 or later
+ (the contents of which are also included in zip.h) for terms of use.
+ If, for some reason, both of these files are missing, the Info-ZIP license
+ also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
+*/
+/*---------------------------------------------------------------------------
+
+ macos.c
+
+ Macintosh-specific routines for use with Info-ZIP's Zip 2.3 and later.
+
+ ---------------------------------------------------------------------------*/
+
+
+/*****************************************************************************/
+/* Includes */
+/*****************************************************************************/
+
+#include "zip.h"
+
+#include "revision.h"
+#include "crypt.h"
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sound.h>
+
+#include <unistd.h>
+
+#include <Strings.h>
+#include <setjmp.h>
+
+/* #include "charmap.h" */
+#include "helpers.h"
+#include "macstuff.h"
+#include "pathname.h"
+#include "recurse.h"
+
+
+/*****************************************************************************/
+/* Macros, typedefs */
+/*****************************************************************************/
+
+#define PATH_END MacPathEnd
+
+/*****************************************************************************/
+/* Global Vars */
+/*****************************************************************************/
+
+int error_level; /* used only in ziperr() */
+
+
+/* Note: sizeof() returns the size of this allusion
+ 13 is current length of "XtraStuf.mac:" */
+extern const char ResourceMark[13]; /* var is initialized in file pathname.c */
+
+
+extern jmp_buf EnvForExit;
+MacZipGlobals MacZip;
+
+unsigned long count_of_Zippedfiles = 0;
+
+
+/*****************************************************************************/
+/* Module level Vars */
+/*****************************************************************************/
+
+static const char MacPathEnd = ':'; /* the Macintosh dir separator */
+
+/* Inform Progress vars */
+long estTicksToFinish;
+long createTime;
+long updateTicks;
+
+static char *Time_Est_strings[] = {
+ "Zipping Files; Items done:",
+ "More than 24 hours",
+ "More than %s hours",
+ "About %s hours, %s minutes",
+ "About an hour",
+ "Less than an hour",
+ "About %s minutes, %s seconds",
+ "About a minute",
+ "Less than a minute",
+ "About %s seconds",
+ "About a second",
+ "About 1 minute, %s seconds"};
+
+
+
+/*****************************************************************************/
+/* Prototypes */
+/*****************************************************************************/
+
+int DoCurrentDir(void);
+
+void DoAboutBox(void);
+void DoQuit(void);
+void DoEventLoop(void);
+
+void ZipInitAllVars(void);
+void UserStop(void);
+Boolean IsZipFile(char *name);
+
+static long EstimateCompletionTime(const long progressMax,
+ const long progressSoFar, unsigned char percent);
+static void UpdateTimeToComplete(void);
+
+
+
+
+#ifdef USE_SIOUX
+#include <sioux.h>
+void DoWarnUserDupVol( char *FullPath );
+
+/*****************************************************************************/
+/* Functions */
+/*****************************************************************************/
+
+/*
+** Standalone Unzip with Metrowerks SIOUX starts here
+**
+*/
+int main(int argc, char **argv)
+{
+ int return_code;
+
+ SIOUXSettings.asktosaveonclose = FALSE;
+ SIOUXSettings.showstatusline = TRUE;
+
+ SIOUXSettings.columns = 100;
+ SIOUXSettings.rows = 40;
+
+ /* 30 = MacZip Johnny Lee's; 40 = new (my) MacZip */
+ MacZip.MacZipMode = NewZipMode_EF;
+
+ argc = ccommand(&argv);
+ if (verbose) PrintArguments(argc, argv);
+
+ ZipInitAllVars();
+
+ return_code = zipmain(argc, argv);
+
+ if (verbose) printf("\n\n Finish");
+ return return_code;
+}
+
+
+
+/*
+** SIOUX needs no extra event handling
+**
+*/
+
+void UserStop(void)
+{
+};
+
+
+
+
+/*
+** Password enter function '*' printed for each char
+**
+*/
+
+int macgetch(void)
+{
+ WindowPtr whichWindow;
+ EventRecord theEvent;
+ char c; /* one-byte buffer for read() to use */
+
+ do {
+ SystemTask();
+ if (!GetNextEvent(everyEvent, &theEvent))
+ theEvent.what = nullEvent;
+ else {
+ switch (theEvent.what) {
+ case keyDown:
+ c = theEvent.message & charCodeMask;
+ break;
+ case mouseDown:
+ if (FindWindow(theEvent.where, &whichWindow) ==
+ inSysWindow)
+ SystemClick(&theEvent, whichWindow);
+ break;
+ case updateEvt:
+ break;
+ }
+ }
+ } while (theEvent.what != keyDown);
+
+ printf("*");
+ fflush(stdout);
+
+ return (int)c;
+}
+
+#endif
+
+
+
+
+/******************************/
+/* Function version_local() */
+/******************************/
+
+/*
+** Print Compilers version and compile time/date
+**
+*/
+
+void version_local()
+{
+/* prints e.g:
+Compiled with Metrowerks CodeWarrior version 2000 for PowerPC Processor
+ compile time: Feb 4 1998 17:49:49.
+*/
+
+static ZCONST char CompiledWith[] =
+ "\n\nCompiled with %s %x for %s \n %s %s %s.\n\n";
+
+ printf(CompiledWith,
+
+
+#ifdef __MWERKS__
+ " Metrowerks CodeWarrior version", __MWERKS__,
+#endif
+
+
+#ifdef __MC68K__
+ " MC68K Processor",
+#else
+ " PowerPC Processor",
+#endif
+
+#ifdef __DATE__
+ "compile time: ", __DATE__, __TIME__
+#else
+ "", "", ""
+#endif
+ );
+} /* end function version_local() */
+
+
+
+
+
+/*
+** Deletes a dir if the switch '-m' is used
+**
+*/
+
+int deletedir(char *path)
+{
+static char Num = 0;
+static FSSpec trashfolder;
+static Boolean FirstCall = true;
+static Boolean Immediate_File_Deletion = false;
+OSErr err;
+FSSpec dirToDelete;
+char currpath[NAME_MAX], *envptr;
+CInfoPBRec fpb;
+
+/* init this function */
+if ((path == NULL) ||
+ (strlen(path) == 0))
+ {
+ Num = 0;
+ FirstCall = true;
+ return -1;
+ }
+
+UserStop();
+
+GetCompletePath(currpath,path,&dirToDelete, &err);
+
+if (FirstCall == true)
+ {
+ FirstCall = false;
+ envptr = getenv("Immediate_File_Deletion");
+ if (!(envptr == (char *)NULL || *envptr == '\0'))
+ {
+ if (stricmp(envptr,"yes") == 0)
+ Immediate_File_Deletion = true;
+ else
+ Immediate_File_Deletion = false;
+ }
+ err = FSpFindFolder(dirToDelete.vRefNum, kTrashFolderType,
+ kDontCreateFolder,&trashfolder);
+ printerr("FSpFindFolder:",err,err,__LINE__,__FILE__,path);
+ }
+
+ fpb.dirInfo.ioNamePtr = dirToDelete.name;
+ fpb.dirInfo.ioVRefNum = dirToDelete.vRefNum;
+ fpb.dirInfo.ioDrDirID = dirToDelete.parID;
+ fpb.dirInfo.ioFDirIndex = 0;
+
+ err = PBGetCatInfoSync(&fpb);
+ printerr("PBGetCatInfo deletedir ", err, err,
+ __LINE__, __FILE__, "");
+
+if (fpb.dirInfo.ioDrNmFls > 0)
+ {
+ return 0; /* do not move / delete folders which are not empty */
+ }
+
+if (Immediate_File_Deletion)
+ {
+ err = FSpDelete(&dirToDelete);
+ return err;
+ }
+
+err = CatMove (dirToDelete.vRefNum, dirToDelete.parID,
+ dirToDelete.name, trashfolder.parID, trashfolder.name);
+
+/* -48 = file is already existing so we have to rename it before
+ moving the file */
+if (err == -48)
+ {
+ Num++;
+ if (dirToDelete.name[0] >= 28) /* cut foldername if to long */
+ dirToDelete.name[0] = 28;
+ P2CStr(dirToDelete.name);
+ sprintf(currpath,"%s~%d",(char *)dirToDelete.name,Num);
+ C2PStr(currpath);
+ C2PStr((char *)dirToDelete.name);
+ err = HRename (dirToDelete.vRefNum, dirToDelete.parID,
+ dirToDelete.name, (unsigned char *) currpath);
+
+ err = CatMove (dirToDelete.vRefNum, dirToDelete.parID,
+ (unsigned char *) currpath, trashfolder.parID,
+ trashfolder.name);
+ }
+
+return err;
+}
+
+
+
+
+/*
+** Set the file-type so the archive will get the correct icon, type
+** and creator code.
+*/
+
+void setfiletype(char *new_f, unsigned long Creator, unsigned long Type)
+{
+OSErr err;
+
+if (strcmp(zipfile, new_f) == 0)
+ err = FSpChangeCreatorType(&MacZip.ZipFileSpec, Creator, Type);
+printerr("FSpChangeCreatorType:", err, err, __LINE__, __FILE__, new_f);
+
+return;
+}
+
+
+
+
+
+/*
+** Convert the external (native) filename into Zip's internal Unix compatible
+** name space.
+*/
+
+char *ex2in(char *externalFilen, int isdir, int *pdosflag)
+/* char *externalFilen external file name */
+/* int isdir input: externalFilen is a directory */
+/* int *pdosflag output: force MSDOS file attributes? */
+/* Convert the external file name to a zip file name, returning the malloc'ed
+ string or NULL if not enough memory. */
+{
+ char *internalFilen; /* internal file name (malloc'ed) */
+ char *t; /* shortened name */
+ char *Pathname;
+ char buffer[NAME_MAX];
+ int dosflag;
+
+ AssertStr(externalFilen, externalFilen)
+ AssertBool(isdir,"")
+
+ dosflag = dosify; /* default for non-DOS and non-OS/2 */
+
+ /* Find starting point in name before doing malloc */
+ for (t = externalFilen; *t == PATH_END; t++)
+ ;
+
+ if (!MacZip.StoreFullPath)
+ {
+ Pathname = StripPartialDir(buffer, MacZip.SearchDir,t);
+ }
+ else
+ {
+ Pathname = t;
+ }
+
+ /* Make changes, if any, to the copied name (leave original intact) */
+ if (!pathput)
+ {
+ t = last(Pathname, PATH_END);
+ }
+ else t = Pathname;
+
+ /* Malloc space for internal name and copy it */
+ if ((internalFilen = malloc(strlen(t) + 10 + strlen(ResourceMark) )) == NULL)
+ return NULL;
+
+ sstrcpy(internalFilen, t);
+
+ /* we have to eliminate illegal chars:
+ * The name space for Mac filenames and Zip filenames (unix style names)
+ * do both include all printable extended-ASCII characters. The only
+ * difference we have to take care of is the single special character
+ * used as path delimiter:
+ * ':' on MacOS and '/' on Unix and '\' on Dos.
+ * So, to convert between Mac filenames and Unix filenames without any
+ * loss of information, we simply interchange ':' and '/'. Additionally,
+ * we try to convert the coding of the extended-ASCII characters into
+ * InfoZip's standard ISO 8859-1 codepage table.
+ */
+ MakeCompatibleString(internalFilen, ':', '/', '/', ':',
+ MacZip.CurrTextEncodingBase);
+
+ /* Returned malloc'ed name */
+ if (pdosflag)
+ *pdosflag = dosflag;
+
+ if (isdir)
+ {
+ return internalFilen; /* avoid warning on unused variable */
+ }
+
+ if (dosify)
+ {
+ msname(internalFilen);
+ printf("\n ex2in: %s",internalFilen);
+ }
+
+ return internalFilen;
+}
+
+
+
+/*
+** Collect all filenames. Go through all directories
+**
+*/
+
+int wild(char *Pathpat)
+ /* path/pattern to match */
+/* If not in exclude mode, expand the pattern based on the contents of the
+ file system. Return an error code in the ZE_ class. */
+{
+FSSpec Spec;
+char fullpath[NAME_MAX];
+OSErr err;
+
+AssertStr(Pathpat, Pathpat);
+
+if (noisy) printf("%s \n\n",GetZipVersionsInfo());
+
+if (extra_fields == 0)
+ {
+ MacZip.DataForkOnly = true;
+ }
+
+/* for switch '-R' -> '.' means current dir */
+if (strcmp(Pathpat,".") == 0) sstrcpy(Pathpat,"*");
+
+sstrcpy(MacZip.Pattern,Pathpat);
+
+if (recurse)
+ {
+ MacZip.StoreFoldersAlso = true;
+ MacZip.SearchLevels = 0; /* if 0 we aren't checking levels */
+ }
+else
+ {
+ MacZip.StoreFoldersAlso = false;
+ MacZip.SearchLevels = 1;
+ }
+
+/* make complete path */
+GetCompletePath(fullpath, MacZip.Pattern, &Spec,&err);
+err = PrintUserHFSerr((err != -43) && (err != 0), err, MacZip.Pattern);
+printerr("GetCompletePath:", err, err, __LINE__, __FILE__, fullpath);
+
+/* extract the filepattern */
+GetFilename(MacZip.Pattern, fullpath);
+
+/* extract Path and get FSSpec of search-path */
+/* get FSSpec of search-path ; we need a dir to start
+ searching for filenames */
+TruncFilename(MacZip.SearchDir, fullpath);
+GetCompletePath(MacZip.SearchDir, MacZip.SearchDir, &Spec,&err);
+
+if (noisy) {
+ if (MacZip.SearchLevels == 0)
+ {
+ printf("\nSearch Pattern: [%s] Levels: all", MacZip.Pattern);
+ }
+ else
+ {
+ printf("\nSearch Pattern: [%s] Levels: %d", MacZip.Pattern,
+ MacZip.SearchLevels);
+ }
+ printf("\nSearch Path: [%s]", MacZip.SearchDir);
+ printf("\nZip-File: [%s] \n",MacZip.ZipFullPath);
+
+}
+
+/* we are working only with pathnames;
+ * this can cause big problems on a mac ...
+ */
+if (CheckMountedVolumes(MacZip.SearchDir) > 1)
+ DoWarnUserDupVol(MacZip.SearchDir);
+
+/* start getting all filenames */
+err = FSpRecurseDirectory(&Spec, MacZip.SearchLevels);
+printerr("FSpRecurseDirectory:", err, err, __LINE__, __FILE__, "");
+
+return ZE_OK;
+}
+
+
+
+/*
+** Convert the internal filename into a external (native).
+** The user will see this modified filename.
+** For more performance:
+** I do not completly switch back to the native macos filename.
+** The user will still see directory separator '/' and the converted
+** charset.
+*/
+
+char *in2ex(char *n) /* internal file name */
+/* Convert the zip file name to an external file name, returning the malloc'ed
+ string or NULL if not enough memory. */
+{
+ char *x; /* external file name */
+
+ AssertStr(n,n)
+
+ if ((x = malloc(strlen(n) + 1)) == NULL)
+ return NULL;
+
+ RfDfFilen2Real(x, n, MacZip.MacZipMode, MacZip.DataForkOnly,
+ &MacZip.CurrentFork);
+
+ return x;
+}
+
+
+
+
+/*
+** Process on filenames. This function will be called to collect
+** the filenames.
+*/
+
+int procname(char *filename, /* name to process */
+ int caseflag) /* true to force case-sensitive match
+ (always false on a Mac) */
+/* Process a name . Return
+ an error code in the ZE_ class. */
+{
+ int rc; /* matched flag */
+
+AssertBool(caseflag,"caseflag")
+AssertStr(filename,filename)
+
+ /* add or remove name of file */
+rc = newname(filename, MacZip.isDirectory, caseflag);
+
+return rc;
+}
+
+
+
+
+ulg filetime(
+char *f, /* name of file to get info on */
+ulg *a, /* return value: file attributes */
+long *n, /* return value: file size */
+iztimes *t) /* return value: access, modific. and creation times */
+/* If file *f does not exist, return 0. Else, return the file's last
+ modified date and time as an MSDOS date and time. The date and
+ time is returned in a long with the date most significant to allow
+ unsigned integer comparison of absolute times. Also, if a is not
+ a NULL pointer, store the file attributes there, with the high two
+ bytes being the Unix attributes, and the low byte being a mapping
+ of that to DOS attributes. If n is not NULL, store the file size
+ there. If t is not NULL, the file's access, modification and creation
+ times are stored there as UNIX time_t values.
+ If f is "-", use standard input as the file. If f is a device, return
+ a file size of -1 */
+{
+ struct stat s; /* results of stat() */
+
+ AssertStr(f,f)
+
+ if (strlen(f) == 0) return 0;
+
+ if (SSTAT(f, &s) != 0)
+ /* Accept about any file kind including directories
+ * (stored with trailing : with -r option)
+ */
+ return 0;
+
+ if (a != NULL) {
+ *a = ((ulg)s.st_mode << 16) | !(s.st_mode & S_IWRITE);
+ if (MacZip.isDirectory) {
+ *a |= MSDOS_DIR_ATTR;
+ }
+ }
+ if (n != NULL)
+ *n = (s.st_mode & UNX_IFMT) == UNX_IFREG ? s.st_size : -1L;
+ if (t != NULL) {
+ t->atime = s.st_atime;
+ t->mtime = s.st_mtime;
+ t->ctime = s.st_ctime; /* on Mac, st_ctime contains creation time! */
+ }
+
+ return unix2dostime(&s.st_mtime);
+}
+
+
+
+void stamp(char *f, ulg d)
+/* char *f; name of file to change */
+/* ulg d; dos-style time to change it to */
+/* Set last updated and accessed time of file f to the DOS time d. */
+{
+ time_t u[2]; /* argument for utime() */
+
+f = f;
+
+ /* Convert DOS time to time_t format in u */
+
+ u[0] = u[1] = dos2unixtime(d);
+/* utime(f, u); */
+}
+
+
+
+
+/*
+** return only the longest part of the path:
+** second parameter: Volume:test folder:second folder:
+** third parameter: Volume:test folder:second folder:third folder:file
+** result will be: third folder:file
+** first parameter: contains string buffer that will be used to prepend
+** the "resource mark" part in front of the result when
+** a resource fork is processed in "M3" mode.
+**
+*/
+
+char *StripPartialDir(char *CompletePath,
+ const char *PartialPath, const char *FullPath)
+{
+const char *tmpPtr1 = PartialPath;
+const char *tmpPtr2 = FullPath;
+int result;
+
+Assert_it(CompletePath,"StripPartialDir","")
+AssertStrNoOverlap(FullPath,PartialPath,PartialPath)
+
+if (MacZip.DataForkOnly)
+ {
+ tmpPtr2 += strlen(tmpPtr1);
+ return (char *)tmpPtr2;
+ }
+
+switch (MacZip.MacZipMode)
+ {
+ case JohnnyLee_EF:
+ {
+ tmpPtr2 += strlen(tmpPtr1);
+ return (char *)tmpPtr2;
+ break;
+ }
+
+ case NewZipMode_EF:
+ { /* determine Fork type */
+ result = strncmp(FullPath, ResourceMark, sizeof(ResourceMark)-2);
+ if (result != 0)
+ { /* data fork */
+ MacZip.CurrentFork = DataFork;
+ tmpPtr2 += strlen(tmpPtr1);
+ return (char *)tmpPtr2;
+ }
+ else
+ { /* resource fork */
+ MacZip.CurrentFork = ResourceFork;
+ sstrcpy(CompletePath, ResourceMark);
+ tmpPtr2 += strlen(tmpPtr1);
+ tmpPtr2 += sizeof(ResourceMark);
+ sstrcat(CompletePath, tmpPtr2);
+ return (char *)CompletePath;
+ }
+ break;
+ }
+ }
+
+ return NULL; /* function should never reach this point */
+}
+
+
+
+
+/*
+** Init all global variables
+** Must be called for each zip-run
+*/
+
+void ZipInitAllVars(void)
+{
+getcwd(MacZip.CurrentPath, sizeof(MacZip.CurrentPath));
+/* MacZip.MacZipMode = JohnnyLee_EF; */
+MacZip.MacZipMode = NewZipMode_EF;
+
+MacZip.DataForkOnly = false;
+MacZip.CurrentFork = NoFork;
+
+MacZip.StoreFoldersAlso = false;
+
+MacZip.FoundFiles = 0;
+MacZip.FoundDirectories = 0;
+MacZip.RawCountOfItems = 0;
+MacZip.BytesOfData = 0;
+
+MacZip.StoreFullPath = false;
+MacZip.StatingProgress = false;
+MacZip.IncludeInvisible = false;
+
+MacZip.isMacStatValid = false;
+
+MacZip.CurrTextEncodingBase = FontScript();
+
+MacZip.HaveGMToffset = false;
+
+createTime = TickCount();
+estTicksToFinish = -1;
+updateTicks = 0;
+
+/* init some functions */
+IsZipFile(NULL);
+
+destroy(NULL);
+deletedir(NULL);
+ShowCounter(true);
+
+extra_fields = 1;
+error_level = 0;
+count_of_Zippedfiles = 0;
+}
+
+
+
+
+/*
+** Get the findercomment and store it as file-comment in the Zip-file
+**
+*/
+char *GetComment(char *filename)
+{
+OSErr err;
+static char buffer[NAME_MAX];
+char buffer2[NAME_MAX];
+char *tmpPtr;
+
+if (filename == NULL) return NULL;
+
+ /* now we can convert Unix-Path in HFS-Path */
+for (tmpPtr = filename; *tmpPtr; tmpPtr++)
+ if (*tmpPtr == '/')
+ *tmpPtr = ':';
+
+if (MacZip.StoreFullPath)
+ { /* filename is already a fullpath */
+ sstrcpy(buffer,filename);
+ }
+else
+ { /* make a fullpath */
+ sstrcpy(buffer,MacZip.SearchDir);
+ sstrcat(buffer,filename);
+ }
+
+/* make fullpath and get FSSpec */
+/* Unfortunately: I get only the converted filename here */
+/* so filenames with extended characters can not be found */
+GetCompletePath(buffer2,buffer, &MacZip.fileSpec, &err);
+printerr("GetCompletePath:",(err != -43) && (err != -120) && (err != 0) ,
+ err,__LINE__,__FILE__,buffer);
+
+err = FSpDTGetComment(&MacZip.fileSpec, (unsigned char *) buffer);
+printerr("FSpDTGetComment:", (err != -5012) && (err != 0), err,
+ __LINE__, __FILE__, filename);
+P2CStr((unsigned char *) buffer);
+if (err == -5012) return NULL; /* no finder-comments found */
+
+if (noisy) printf("\n%32s -> %s",filename, buffer);
+/*
+Beside the script change we need only to change 0x0d in 0x0a
+so the last two arguments are not needed and does nothing.
+*/
+MakeCompatibleString(buffer, 0x0d, 0x0a, ' ', ' ',
+ MacZip.CurrTextEncodingBase);
+
+return buffer;
+}
+
+
+
+
+/*
+** Print a progress indicator for stating the files
+**
+*/
+
+void PrintStatProgress(char *msg)
+{
+
+if (!noisy) return; /* do no output if noisy is false */
+
+MacZip.StatingProgress = true;
+
+if (strcmp(msg,"done") == 0)
+ {
+ MacZip.StatingProgress = false;
+ printf("\n ... done \n\n");
+ }
+else printf("\n %s",msg);
+
+}
+
+
+
+
+void InformProgress(const long progressMax, const long progressSoFar )
+{
+int curr_percent;
+char no_time[5] = "...";
+
+curr_percent = percent(progressMax, progressSoFar);
+
+if (curr_percent < 95)
+ {
+ estTicksToFinish = EstimateCompletionTime(progressMax,
+ progressSoFar, curr_percent);
+ }
+else
+ {
+ rightStatusString(no_time);
+ leftStatusString(no_time);
+ }
+
+updateTicks = TickCount() + 60;
+return;
+}
+
+
+void ShowCounter(Boolean reset)
+{
+static char statusline[100];
+static unsigned long filecount = 0;
+
+if (reset)
+ {
+ filecount = 0;
+ return;
+ }
+
+if (noisy)
+ {
+ sprintf(statusline, "%6d", filecount++);
+ rightStatusString(statusline);
+ }
+}
+
+
+static long EstimateCompletionTime(const long progressMax,
+ const long progressSoFar,
+ unsigned char curr_percent)
+{
+ long max = progressMax, value = progressSoFar;
+ static char buf[100];
+ unsigned long ticksTakenSoFar = TickCount() - createTime;
+ float currentRate = (float) ticksTakenSoFar / (float) value;
+ long newEst = (long)( currentRate * (float)( max - value ));
+
+ sprintf(buf, "%d [%d%%]",progressSoFar, curr_percent);
+ rightStatusString(buf);
+
+ estTicksToFinish = newEst;
+
+ UpdateTimeToComplete();
+
+return estTicksToFinish;
+}
+
+
+
+
+
+static void UpdateTimeToComplete(void)
+{
+ short days, hours, minutes, seconds;
+ char estStr[255];
+ Str15 xx, yy;
+ short idx = 0;
+
+ if ( estTicksToFinish == -1 )
+ return;
+
+ days = estTicksToFinish / 5184000L;
+ hours = ( estTicksToFinish - ( days * 5184000L )) / 216000L;
+ minutes = ( estTicksToFinish - ( days * 5184000L ) -
+ ( hours * 216000L )) / 3600L;
+ seconds = ( estTicksToFinish - ( days * 5184000L ) -
+ ( hours * 216000L ) - ( minutes * 3600L )) / 60L;
+
+ xx[0] = 0;
+ yy[0] = 0;
+
+ if ( days )
+ {
+ /* "more than 24 hours" */
+
+ idx = 1;
+ goto setEstTimeStr;
+ }
+
+ if ( hours >= 8 )
+ {
+ /* "more than x hours" */
+
+ NumToString( hours, xx );
+ idx = 2;
+ goto setEstTimeStr;
+ }
+
+ if ( estTicksToFinish > 252000L ) /* > 1hr, 10 minutes */
+ {
+ /* "about x hours, y minutes" */
+
+ NumToString( hours, xx );
+ NumToString( minutes, yy );
+ idx = 3;
+ goto setEstTimeStr;
+ }
+
+ if ( estTicksToFinish > 198000L ) /* > 55 minutes */
+ {
+ /* "about an hour" */
+ idx = 4;
+ goto setEstTimeStr;
+ }
+
+ if ( estTicksToFinish > 144000L ) /* > 40 minutes */
+ {
+ /* "less than an hour" */
+
+ idx = 5;
+ goto setEstTimeStr;
+ }
+
+ if ( estTicksToFinish > 4200L ) /* > 1 minute, 10 sec */
+ {
+ /* "about x minutes, y seconds */
+
+ NumToString( minutes, xx );
+ NumToString( seconds, yy );
+
+ if ( minutes == 1 )
+ idx = 11;
+ else
+ idx = 6;
+ goto setEstTimeStr;
+ }
+
+ if ( estTicksToFinish > 3000L ) /* > 50 seconds */
+ {
+ /* "about a minute" */
+
+ idx = 7;
+ goto setEstTimeStr;
+ }
+
+ if ( estTicksToFinish > 1500L ) /* > 25 seconds */
+ {
+ /* "less than a minute" */
+
+ idx = 8;
+ goto setEstTimeStr;
+ }
+
+ if ( estTicksToFinish > 120L ) /* > 2 seconds */
+ {
+ NumToString( seconds, xx );
+ idx = 9;
+ goto setEstTimeStr;
+ }
+
+ idx = 10;
+
+ setEstTimeStr:
+ sprintf(estStr,Time_Est_strings[idx],P2CStr(xx),P2CStr(yy));
+ leftStatusString((char *)estStr);
+}
+
+
+
+
+
+/*
+** Just return the zip version
+**
+*/
+
+char *GetZipVersionsInfo(void)
+{
+static char ZipVersion[100];
+
+sprintf(ZipVersion, "Zip Module\n%d.%d%d%s of %s", Z_MAJORVER, Z_MINORVER,
+ Z_PATCHLEVEL, Z_BETALEVEL, REVDATE);
+
+return ZipVersion;
+}
+
+
+
+
+#ifndef USE_SIOUX
+
+/*
+** Just return the copyright message
+**
+*/
+
+char *GetZipCopyright(void)
+{
+static char CopyR[300];
+
+sstrcpy(CopyR, copyright[0]);
+sstrcat(CopyR, copyright[1]);
+sstrcat(CopyR, "\r\rPlease send bug reports to the authors at\r"\
+ "Zip-Bugs@lists.wku.edu");
+
+return CopyR;
+}
+
+
+
+
+/*
+** Just return the compilers date/time
+**
+*/
+
+char *GetZipVersionLocal(void)
+{
+static char ZipVersionLocal[50];
+
+sprintf(ZipVersionLocal, "[%s %s]", __DATE__, __TIME__);
+
+return ZipVersionLocal;
+}
+
+#endif /* #ifndef USE_SIOUX */
+
+
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-25 09:20:13 +0000