home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / archiver / pxsrc21a.arj / POLYXARC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-12  |  70.5 KB  |  1,639 lines
  1. /*
  2.  
  3.     PolyXarc: de-archives most archive formats (with the help of the
  4.     de-archive programs).
  5.  
  6.  */
  7. #define R_VERS  "2.1a"
  8. #define R_DATE  "12 May 1991"
  9.  
  10. #ifdef AMIGA
  11. #define R_PORT  "(Amiga 0.02)"
  12. #endif
  13.  
  14. #ifdef OS_2
  15. #define R_PORT  "(OS/2 1.3)"
  16. #endif
  17.  
  18. #ifdef MSDOS
  19. #define R_PORT  "(MSDOS)"
  20. #endif
  21.  
  22. /*
  23. -----------------------------------------------------------------------------
  24. Version 2.1a, 12 May 1991: if pak_dosort found a header error, it would return
  25.     the same error level as for a fatal error (couldn't open or read the file).
  26.     We were leaving the filename intact and exiting instead of renaming to
  27.     BAD_ARC and continuing when we were doing bundles. pak_dosort now returns
  28.     a 6 for that error.
  29.     Now MSC 6.0a compatible (hexit didn't work).
  30. Version 2.1, 5 April 1991: Released DOS and OS/2 versions.
  31.     1 January 1991: Will now accept quoted strings and hex numbers in the
  32.     SIGNATURE and ARC lines.
  33.      - A whitespace character is a space or tab.
  34.      - Normally, each non-whitespace character is simply treated as a
  35.        character.
  36.      - If you place double-quotes (") around a string or part of a string,
  37.        that string will be accepted intact, including whitespace.
  38.      - If you place a less-than sign (<) in a string, the following characters
  39.        will be considered to be 2-digit hex numbers until a greater-than sign
  40.        (>) is reached. A hex digit is any numeric digit (0-9) or any letter
  41.        from A to F (a-f or A-F). Normally the hex digits will be taken in
  42.        pairs, but if any other character is imbedded, it will be considered to
  43.        be a number break and the next digit will start the next number.
  44.      - If you imbed a backslash ('\'), the backslash will be thrown away and
  45.        the next character will be accepted as a character. This allows you
  46.        to imbed the double-quote (") and less-than (<) characters as
  47.        characters.
  48.     10 December 1990: Now sorts .ARC signatures, primarily by ARC version,
  49.     secondarily by signature level. This means the user need not worry about
  50.     the order, and it simplifies explanation greatly. Added new examples for
  51.     PAK 2.51 to POLYXARC.CFG.
  52.     18 September 1990: Added support for type 1 ARC headers (see PAKSORTM).
  53.     Added support for version 6 headers; version 5 ARC programs can't handle
  54.     them. There is now an alternate verb in the config file for version 6
  55.     archivers, ARC6. ARC or ARC5 will work for the old stuff.
  56.     23 May, 1990: Added a visual indication of the errorlevel at exit to
  57.     expedite debugging.
  58.     21 May, 1990: Added the -# flag, which tells PolyXarc to ignore any
  59.     bundle names that don't end with a decimal digit when using the -F
  60.     option. Occasionally a file with a .MOD or some such extension shows
  61.     up, and can cause all kinds of havoc. The default is to process them.
  62. Version 2.0, 9 April 1990: Cleaned up some minor stuff. Lattice 'C' on the
  63.     Amiga seems to have a problem with leading zeros with the %.3d format, so
  64.     we changed it to %0.3d for the Amiga implementation only. Ripped out a
  65.     bunch of comments that described the .CFG file in detail; this code is
  66.     big enough as it is! Released version 2.0 (finally!). jjn
  67.     31 March 1990: Bill Andrus added definitions, DIRFIND.C, and conditional
  68.     compilations for IBM C/2 1.1 (or MSC 5.1) under OS/2 with the IBM SDK
  69.     Version 1.2 Toolkit.  Also insured the MSC conditional works for C/2.
  70.     22 March 1990: Steve Palm added definitions and conditional compilations
  71.     for Lattice C on the Amiga. I altered some of the stuff to make it even
  72.     more portable.
  73.     20 February 1990: Changed the way the template works. First I eliminated
  74.     the format type. Then I changed the %s specifications to %1, %2, %3, and
  75.     %4. Then I added the ability to have more than one file spec on the
  76.     command line; everything after the first spec will name a file to be
  77.     extracted. So now the four template specs are:
  78.         %1: extract string
  79.         %2: overwrite string
  80.         %3: archive name string
  81.         %4: extract name string
  82. Version 1.1a, 3 December 1989: I found another flaw in the bubble sort
  83.     routine. jjn
  84. Version 1.1, 2 December 1989: David Page pointed out that SPAZ would
  85.     automatically assume a wildcard extension if the archive name was
  86.     specified without an extension. I have added this to PolyXarc. jjn
  87. Version 1.0, 2 December 1989: This is the initial release. I now have the
  88.     NOSORT verb override the -F switch if it is used. That is, specifying
  89.     -F and NOSORT will cause PolyXarc not to sort .ARC files. Also found a
  90.     logic error in my bubble sort and fixed it. jjn
  91. Version 0.7, 25 November 1989: Previously, any error would cause PolyXarc
  92.     to exit. Now, if it is in -f mode, if the file is 0-length then PolyXarc
  93.     will simply delete it; if it gets an error return from the archiver, it
  94.     spits out a warning message, renames the file to BAD_ARC.???, and keeps
  95.     going. I also changed the config file a bit. jjn
  96. Version 0.6, 21 November 1989: Whoops! this_arc didn't get reset after each
  97.     file, so if you unpacked an .ARC file and then something else, it
  98.     wouldn't work. Fixed that by resetting this_arc at the same time as
  99.     this_signature. Added wildcard support for the non-f mode, which should
  100.     have been there in the first place. jjn
  101. Version 0.5, 20 November 1989: Fixed a bug in the -m support; I was
  102.     subtracting in the wrong direction. If the configuration file is not
  103.     specified on the command line, PolyXarc now looks for the default in
  104.     the current directory, then in the directory of the .EXE file, then
  105.     looks for a PENGUIN file. jjn
  106. Version 0.4, 18 November 1989: Fixed a bug in the -f support: Turbo C cannot
  107.     malloc(0), so I now always malloc() at least one item. jjn
  108. Version 0.3, 18 November 1989: More code cleanup. Removed the extensive
  109.     help stuff. Changed from Microsoft C 5.1 to Turbo C 2.0, which went from
  110.     96k to 32k (runtime, not .EXE size). Added the runtime configuration
  111.     display and -f option support. jjn
  112. Version 0.2, 17 November 1989: Cleaned up some error handling. jjn
  113. Version 0.1, 16 November 1989: Created by Jeffrey J. Nonken
  114. -----------------------------------------------------------------------------
  115.  
  116. Public domain by Jeffrey J. Nonken, February 1991. No strings, no bullshit.
  117. Do what you want with it. Nobody owns it.
  118.  
  119. However, I would like it if you would refer all changes and enhancements to
  120. me. This way I can maintain it properly. Thanks.
  121.  
  122. Jeffrey J. Nonken: sysop of Opus 1:273/715 Blue Bell, Pa. (215)279-9799
  123. My address and phone number will probably change in July, 1991.
  124. Please send correspondence to:
  125. Jeffrey J. Nonken
  126. 507 Ave. Presidio
  127. San Clemente, Ca. 92672
  128.  
  129. This was compiled with Turbo C v2.0.
  130.  
  131. -----
  132.  
  133. Steve Palm was not available to help with an Amiga port of 2.1. The following
  134. applies only to version 2.0:
  135.  
  136. Amiga Correspondence can go to:
  137. Steven M. Palm, sysop of "The Siberian Amiga (MAIL ONLY) 1:11/16"
  138. 1000 E. Easterday Ave, #2
  139. Sault Ste. Marie, MI 49783
  140.  
  141. All thanks and credit for the program belong to Jeffrey, though.
  142.  
  143. Amiga version compiled under Lattice C 5.05
  144.  
  145. -----
  146.  
  147. Bill Andrus of 1:109/301 is responsible for the OS/2 port.
  148.  
  149. -----
  150.  
  151. Please note: this source should compile under Lattice C 5.05 on the Amiga,
  152. or Turbo C 2.0 or Microsoft C 5.1 under MSDOS on the IBM. All you need do is
  153. predefine the appropriate label on the command line. However, Turbo C has
  154. a problem with the source files if they have been formatted by the Amiga.
  155. TC requires CRLF newline sequences, where the Amiga only uses LF for newlines.
  156. MSC doesn't seem to have any problem with the Amiga's newline sequences.
  157.  
  158. It should also compile under IBM C/2 and MSC 6.0a under OS/2.
  159.  */
  160.  
  161. #include <stdio.h>
  162. #include <stdlib.h>
  163. #include <string.h>
  164. #include <ctype.h>
  165. #include <dos.h>
  166. #include <errno.h>
  167.  
  168. #ifdef AMIGA
  169. #define _NEAR_
  170. #endif
  171.  
  172. #ifdef TURBOC
  173. #include <dir.h>
  174. #include <process.h>
  175. #define _NEAR_
  176. #endif
  177.  
  178. #ifdef MSC
  179. #include <malloc.h>
  180. #include <memory.h>
  181. #include <process.h>
  182. #define _NEAR_ near
  183. #endif
  184.  
  185. #ifdef OS_2
  186. #include <process.h>
  187. extern int dir_findfirst(char *filename,int attribute,struct find_t *dta);
  188. extern int dir_findnext(struct find_t *dta);
  189. #endif
  190.  
  191. #include "p_common.h"       /* Portability defines.  Must be after */
  192.                             /* system includes on the Amiga... */
  193.  
  194. #include "pakmdefn.h"       /* Mike Housky's sort function definitions. */
  195.  
  196. /****************************************************************************/
  197.  
  198. #ifdef TURBOC
  199. #define bf_name ff_name
  200. #define bf_time ff_ftime
  201. #define bf_date ff_fdate
  202. #define bf_size ff_fsize
  203. #endif
  204. #ifdef AMIGA
  205. #define bf_name filename
  206. #define bf_time time
  207. #define bf_date date
  208. #define bf_size size
  209. #endif
  210. #ifdef MSC
  211. #define bf_name name
  212. #define bf_time wr_time
  213. #define bf_date wr_date
  214. #define bf_size size
  215. #endif
  216.  
  217. #define OVER_LEN 6                  /* Size of overwrite string. */
  218. #define EXTR_LEN 6                  /* Size of extract string. */
  219. #define SIGN_LEN 6                  /* Size of signature string. */
  220.  
  221. #define DEFAULT_NAME "POLYXARC.CFG" /* Default name for configuration file. */
  222.  
  223. typedef struct SIGNATURE_TAG        /* 'Signature' structure. */
  224. {
  225.     long    file_offset;            /* Offset from beginning/end of file. */
  226.     char    overwrite[OVER_LEN];    /* Overwrite parameter string. */
  227.     char    extract[EXTR_LEN];      /* Extract parameter string. */
  228.     char    signature[SIGN_LEN];    /* Actual signature string. */
  229.     char    *cmdline;               /* Command line for calling de-archiver. */
  230. } SIGNATURE_TYPE;
  231.  
  232. typedef struct ARC_TAG              /* 'Archive level' structure. */
  233. {
  234.     byte    type;                   /* .ARC level */
  235.     byte    version;                /* True if version 6 headers found. */
  236.     char    overwrite[OVER_LEN];    /* Overwrite parameter string. */
  237.     char    extract[EXTR_LEN];      /* Extract parameter string. */
  238.     char    *cmdline;               /* Command line for calling de-archiver. */
  239. } ARC_TYPE;
  240.  
  241. typedef struct FILE_TAG             /* Bundle file directory information. */
  242. {
  243. #ifdef AMIGA
  244.     char          filename[108];    /* currently 30 chars are used */
  245.     long          time;
  246.     long          date;
  247. #endif
  248. #ifdef IBM
  249.     char          filename[13];     /* FILENAME.EXT of file. */
  250.     unsigned      time;             /* Last time updated. */
  251.     unsigned      date;             /* Last date updated. */
  252. #endif
  253.     long          size;             /* Size of the file in bytes. */
  254. } FILE_TYPE;
  255.  
  256. /****************************************************************************/
  257.  
  258. FILE_TYPE   * _NEAR_ file_list = NULL;  /* list of files ('malloc'ed). */
  259. ARC_TYPE    * _NEAR_ arc_list;
  260. SIGNATURE_TYPE * _NEAR_ signature_list;
  261.  
  262. int _NEAR_ this_net;                /* Our net number. */
  263. int _NEAR_ this_node;               /* Our node number. */
  264. int _NEAR_ config_name_set = 0;     /* TRUE if config name specified. */
  265. int _NEAR_ archive_name_set = 0;    /* TRUE if archive name specified. */
  266. int _NEAR_ arc_count = 0;           /* Number of .ARC formats defined. */
  267. int _NEAR_ signature_count = 0;     /* Number of other formats defined. */
  268. int _NEAR_ nosort = 0;              /* TRUE if should not sort .ARC files. */
  269. int _NEAR_ delete_archives = 0;     /* TRUE if should auto-delete files. */
  270. int _NEAR_ do_all_bundles = 0;      /* TRUE if processing all mail bundles. */
  271. int _NEAR_ do_n_bundles = 0;        /* Number of archives to do (0 == all). */
  272. int _NEAR_ show_addresses = 0;      /* TRUE to display bundle addresses. */
  273. int _NEAR_ this_signature = -1;     /* Which signature was found. */
  274. int _NEAR_ this_arc = -1;           /* Which arc level was found. */
  275. int _NEAR_ arc = 0;                 /* TRUE if an .ARC format file found. */
  276. int _NEAR_ overwrite = 0;           /* TRUE if automatic overwrite. */
  277. int _NEAR_ quiet = 0;               /* TRUE makes PolyXarc quieter. */
  278. int _NEAR_ name_count = 0;          /* Counts number of non-switch parameters. */
  279. int _NEAR_ ignore_archiver_errors = 0;  /* TRUE continues on archiver errors. */
  280. int _NEAR_ digits_only = 0;         /* TRUE forces digits only on bundle names. */
  281.  
  282.  
  283. #ifdef AMIGA
  284.     extern  int errno;
  285.     int     _NEAR_ msflag   = 1;            /* causes dir searches to use */
  286.                                         /* MS-DOS wildcards */
  287. #endif
  288. char _NEAR_ archive_name[fname_len] = "";/* Name of archive (from command line). */
  289. char _NEAR_ extract_name[128] = "";     /* Name(s) of file(s) to be extracted
  290.                                                         (from command line). */
  291. char _NEAR_ config_name[fname_len] = DEFAULT_NAME;  /* Name of configuration file. */
  292.  
  293. /****************************************************************************
  294. The following define the find_first/find_next environment. The functions that
  295. come with MSC and TURBO C are nearly identical, varying only in some minor
  296. details. 'buffer' is the structure in which the file search routines store
  297. the file information. 'jjn_findfirst' and 'jjn_findnext' are macros that
  298. resolve to the actual calls to the first/next library routines in the two
  299. different libraries. The only differences are the function names, and that two
  300. parameters are swapped in the find_first routine.
  301. ****************************************************************************/
  302. #ifdef TURBOC
  303. static struct ffblk _NEAR_ buffer;
  304. #define jjn_findfirst(f,a,b) findfirst(f,b,a)
  305. #define jjn_findnext(b) findnext(b)
  306. #endif
  307.  
  308. #ifdef AMIGA
  309. struct ffblk {
  310.         LONG    diskkey;
  311.         LONG    direntrytype;
  312.         char    filename[108];
  313.         LONG    protection;
  314.         LONG    entrytype;
  315.         LONG    size;
  316.         LONG    numblocks;
  317.         LONG    date;
  318.         LONG    time;
  319.         LONG    ticks;
  320.         char    comment[80];
  321.         char    reserved[36];
  322.     };
  323. static struct ffblk _NEAR_ buffer;
  324. #   define jjn_findfirst(f,a,b) dfind((struct FileInfoBlock *) b,(char *) f,(int) a)
  325. #   define jjn_findnext(b) dnext((struct FileInfoBlock *) b)
  326. #endif
  327.  
  328.  
  329. #ifdef MSC
  330.  
  331. #ifdef MSDOS
  332. static struct find_t _NEAR_ buffer;
  333. #define jjn_findfirst(f,a,b) _dos_findfirst(f,a,b)
  334. #define jjn_findnext(b) _dos_findnext(b)
  335. #endif
  336.  
  337. #ifdef OS_2
  338. static struct find_t _NEAR_ buffer;
  339. #define jjn_findfirst(f,a,b) dir_findfirst(f,a,b)
  340. #define jjn_findnext(b) dir_findnext(b)
  341. #endif
  342.  
  343. #endif
  344.  
  345. /* This holds the highest compression level found in an .ARC file. */
  346. extern int16 _NEAR_ highest_type;
  347. /* This tells whether we have found version 6 headers. */
  348. extern int16 _NEAR_ version6;
  349.  
  350.  
  351. /*****************************************************************************
  352.       quit() tells what errorlevel is being returned, then calls exit().
  353. *****************************************************************************/
  354. void quit(int errorlevel)
  355. {
  356.     if (!quiet)
  357.         printf("\nErrorlevel on exit: %d.\n",errorlevel);
  358.     exit(errorlevel);
  359. }
  360.  
  361. /*****************************************************************************
  362. default_ext() appends a default extension to a filename. Normal operation
  363. happens when the given default extension does not have a period as the first
  364. character. If this is the case, the default extension is only appended if
  365. dest does not already have one. If the given default extension has a period,
  366. it forces the dest to have the default extension even if it already had one.
  367.  
  368.  -----> NOTE:  The AmigaDOS system does not require nor expect a filename
  369.                to contain an extension.  DO NOT USE THIS ROUTINE there.
  370.  
  371. Examples:
  372.   Assume filename is "MYFILE.JNK".
  373.  
  374.   default_ext(filename,"EXT");  [filename is left as "MYFILE.JNK".]
  375.   default_ext(filename,".EXT"); [filename is now "MYFILE.EXT".]
  376.  
  377.   Assume filename is "MYFILE".
  378.  
  379.   default_ext(filename,"EXT");  [filename is now "MYFILE.EXT".]
  380.   default_ext(filename,".EXT"); [filename is now "MYFILE.EXT".]
  381. *****************************************************************************/
  382. #ifndef AMIGA
  383. char *default_ext(char *dest,char *def_ext)
  384. {
  385. register int i;
  386.  
  387.     for (i = strlen(dest) - 1; i >= 0; --i) /* Look for \, :, or . */
  388.     {
  389.         if (dest[i] == '.')         /* Found a period. Force it? */
  390.         {
  391.             if (def_ext[0] != '.')  /* If none in default ext, forget it. */
  392.             {
  393.                 return(dest);       /* Return the given extension. */
  394.             }
  395.             else
  396.             {
  397.                 strcpy(dest+i,def_ext); /* Otherwise, copy new default ext. */
  398.                 return(dest);           /* Return with a new extension. */
  399.             }
  400.         }
  401.         if (dest[i] == c_slash || dest[i] == ':')   /* Found one, no period. */
  402.             i = 0;                              /* Force it to drop through. */
  403.     }
  404.     /* If it got this far, there was no extension. */
  405.     if (def_ext[0] != '.')          /* Is there a period in the default ext? */
  406.         strcat(dest,".");           /* If not, add one. */
  407.     strcat(dest,def_ext);           /* Now add the default extension. */
  408.     return(dest);
  409. }
  410. #endif
  411.  
  412. /****************************************************************************
  413. Limit a string to len characters. This routine modifies the original string
  414. and returns the string's address.
  415. ****************************************************************************/
  416. char *strtrunc(char *string,int len)
  417. {
  418. register int i;                 /* Index into the string. */
  419.  
  420.     i = 0;                      /* Start from the beginning. */
  421.     while (string[i] != '\0')   /* Do until we reach the end. */
  422.     {
  423.         if (i == len)           /* Did we count len characters? */
  424.         {
  425.             string[i] = '\0';   /* Yes, truncate the string here. */
  426.             return(string);     /* Return the truncated string. */
  427.         }
  428.         ++i;                    /* Not found yet, look farther. */
  429.     }
  430.     return(string); /* String too short for truncation, return unmodified. */
  431. }
  432.  
  433. /****************************************************************************
  434. Add a backslash (\) to the end of a path. Only does so if the last character
  435. is not already a backslash or a colon. Note: the Amiga uses a forward slash.
  436. ****************************************************************************/
  437. #ifdef IBM
  438. #   pragma check_stack-
  439. #endif
  440. void slash(char *pathspec)
  441. {
  442. register int        i;
  443.  
  444.     i = strlen(pathspec);               /* Find the end of the string. */
  445.     if (i--)    /* Check for 0 length. If non-zero, backpedal and process it. */
  446.         if ((pathspec[i] != c_slash) && /* See if last char is a backslash */
  447.                 (pathspec[i] != ':'))   /*  or a colon. */
  448.             strcat(pathspec,s_slash);   /* If not, add a backslash. */
  449. }
  450. #ifdef IBM
  451. #   pragma check_stack+
  452. #endif
  453. /****************************************************************************
  454. Separate drive:directory from name.ext. The original string is not changed.
  455. ****************************************************************************/
  456. void path_name(char *filespec,char *path,char *name)
  457. {
  458. register int    i;
  459.  
  460.     strupr(filespec);                           /* Make it upper case. */
  461.     for (i = strlen(filespec); i >= 0; --i)     /* Start from the end. */
  462.     {
  463.         if (filespec[i] == ':' || filespec[i] == c_slash)   /* '\' or ':'? */
  464.         {
  465.             ++i;                /* Yes, point to next char. */
  466.             if (name != NULL)   /* Copy filename if there is an address. */
  467.                 strcpy(name,filespec + i);
  468.             if (path != NULL)   /* Copy file if there is an address. */
  469.             {
  470.                 strncpy(path,filespec,i);   /* Copy only i characters. */
  471.                 path[i] = '\0';             /* Terminate the dest string. */
  472.             }
  473.             return;             /* We got it; now let's return it. */
  474.         }
  475.     }
  476.  
  477. /* If we get this far, we never found a colon or backslash. That implies that
  478.    the filespec is filename.ext only, no path. */
  479.  
  480.     if (path != NULL)       /* Copy empty path if an address was provided. */
  481.         strcpy(path,"");
  482.     if (name != NULL)       /* Copy filename.ext if an address was provided. */
  483.         strcpy(name,filespec);
  484. }
  485.  
  486. /****************************************************************************
  487.            This converts a hexASCII digit into a numeric value.
  488. ****************************************************************************/
  489. char hexit(char c)
  490. {
  491.     c = (char) toupper(c); /* Necessary for MSC 6.0a */
  492.     c -= '0';
  493.     if (c > 9)
  494.         c -= 7;
  495.     return(c);
  496. }
  497.  
  498. /****************************************************************************
  499. This parses off one parameter from the given string and returns its address.
  500. It works similarly to strtok() except that only the string parameter is
  501. specified; the parsing action is fixed.
  502.  
  503. On the first call per string, pass the string address.
  504. On subsequent calls for that string, pass a NULL pointer.
  505. ****************************************************************************/
  506. #define SCANNING 1
  507. #define QUOTE    2
  508. #define HEX1     3
  509. #define HEX2     4
  510. #define FINISHED 5
  511. #define DEADSTOP 6
  512.  
  513. char *parmtok(char *string,char *tokens)
  514. {
  515. static char *oldstring;
  516. char *newstring;
  517. register int i;
  518. register int j;
  519. register int state;
  520.  
  521.     if (string != NULL)
  522.         oldstring = string;
  523.     while (strchr(tokens,*oldstring) != NULL)
  524.         if (*oldstring == '\0')
  525.             return(NULL);
  526.         else
  527.             ++oldstring;
  528.     i = 0;
  529.     j = 0;
  530.     state = SCANNING;
  531.     do
  532.     {
  533.         switch(state)
  534.         {
  535.             case SCANNING:
  536.                 if (oldstring[i] == '\0')
  537.                     state = DEADSTOP;
  538.                 else if (strchr(tokens,oldstring[i]) != NULL)
  539.                     state = FINISHED;
  540.                 else if (oldstring[i] == '"')
  541.                     state = QUOTE;
  542.                 else if (oldstring[i] == '\\')
  543.                 {
  544.                     if (oldstring[++i] == '\0')
  545.                         state = DEADSTOP;
  546.                     else
  547.                         oldstring[j++] = oldstring[i];
  548.                 }
  549.                 else if (oldstring[i] == '<')
  550.                     state = HEX1;
  551.                 else
  552.                     oldstring[j++] = oldstring[i];
  553.                 break;
  554.             case QUOTE:
  555.                 if (oldstring[i] == '\\')
  556.                     oldstring[j++] = oldstring[++i];
  557.                 else if (oldstring[i] == '"')
  558.                     state = SCANNING;
  559.                 else if (oldstring[i] == '\0')
  560.                     state = DEADSTOP;
  561.                 else
  562.                     oldstring[j++] = oldstring[i];
  563.                 break;
  564.             case HEX1:
  565.             case HEX2:
  566.                 if (oldstring[i] == '>')
  567.                     state = SCANNING;
  568.                 else if (oldstring[i] == '\0')
  569.                     state = DEADSTOP;
  570.                 else if (isxdigit(oldstring[i]))
  571.                 {
  572.                     if (state == HEX1)
  573.                     {
  574.                         oldstring[j] = hexit(oldstring[i]);
  575.                         state = HEX2;
  576.                     }
  577.                     else
  578.                     {
  579.                         oldstring[j] = (char) (((byte) oldstring[j] << 4) | (byte) hexit(oldstring[i]));
  580.                         state = HEX1;
  581.                         ++j;
  582.                     }
  583.                 }
  584.                 else
  585.                 {
  586.                     if (state == HEX2)
  587.                         ++j;
  588.                     state = HEX1;
  589.                 }
  590.                 break;
  591.         }
  592.         ++i;
  593.     } while (state != FINISHED && state != DEADSTOP);
  594.     oldstring[j] = '\0';
  595.     newstring = oldstring;
  596.     oldstring += (state == DEADSTOP) ? (i - 1) : i;
  597.     return(newstring);
  598. }
  599.  
  600. /****************************************************************************
  601.      If the first file timestamp is later than the second, return TRUE.
  602. ****************************************************************************/
  603. #ifdef IBM
  604. #   pragma check_stack-
  605. #endif
  606. int compare(FILE_TYPE *f1,FILE_TYPE *f2)
  607. {
  608.     if (f1->date > f2->date)    /* If first file date is later, return TRUE. */
  609.         return(1);
  610.     if (f1->date < f2->date)    /* If first file date is earlier, FALSE. */
  611.         return(0);
  612. /* The dates were the same, so try the time. */
  613.     if (f1->time > f2->time)    /* If first file time is later, return TRUE. */
  614.         return(1);
  615. /* The first file is the same as or earlier than the second. In either case,
  616.    we don't want to bother swapping, so just return FALSE. */
  617.     return(0);
  618. }
  619. #ifdef IBM
  620. #   pragma check_stack+
  621. #endif
  622. /****************************************************************************
  623.       Find highest BAD_ARC.???, rename current file to the next one.
  624. ****************************************************************************/
  625. int ren_bad_arc(char *path,char *bad_name)
  626. {
  627. register int    i;              /* Highest BAD_ARC.### found so far. */
  628. register int    j;              /* Holds results from first/next calls. */
  629. register int    k;              /* Converted BAD_ARC.### value. */
  630. char            filespec[fname_len];    /* Filespec of new name. */
  631.                                         /* Also first/next search pattern. */
  632. char            bad_spec[fname_len];    /* Complete filespec of bad filename. */
  633.  
  634.     sprintf(filespec,"%sBAD_ARC.???",path);     /* Create search pattern. */
  635.     i = -1;                                     /* Highest found so far. */
  636.     j = jjn_findfirst(filespec, 0, &buffer);    /* Find the first one. */
  637.     while (j == 0)                          /* While we keep finding them... */
  638.     {
  639.         /* Convert the extension to its numeric value. */
  640.         k = atoi(strchr(buffer.bf_name,'.') + 1);
  641.         if (k > i)          /* Is it higher than all the previous found? */
  642.             i = k;          /* If so, save this one as the highest. */
  643.         j = jjn_findnext(&buffer);  /* Find the next one, if you can! */
  644.     }
  645. /* Gets here when no more can be found. */
  646. /* Create a filespec including the path and BAD_ARC.(i+1). */
  647. #ifdef AMIGA
  648.     sprintf(filespec,"%sBAD_ARC.%0.3d",path,i + 1);
  649. #else
  650.     sprintf(filespec,"%sBAD_ARC.%.3d",path,i + 1);
  651. #endif
  652. /* Create a filespec including the path and the original filename. */
  653.     sprintf(bad_spec,"%s%s",path,bad_name);
  654. /* Tell the operator what is happening. */
  655.     printf("Renaming %s to %s.\n",bad_spec,filespec);
  656. /* Rename the file to BAD_ARC.###. */
  657.     rename(bad_spec,filespec);
  658.     return(i);
  659. }
  660.  
  661. /****************************************************************************
  662.        Find all .SU?, .MO?, .TU?, .WE?, .TH?, .FR?, and .SA? files.
  663. ****************************************************************************/
  664. int get_files(char *path,int do_bundles)
  665. {
  666. char            *p;
  667. register int    i;
  668. register int    j;
  669. register int    k;
  670. int             found;
  671. int             ok;
  672. char            filespec[64];
  673. static char bundles[7][6] =
  674.     {
  675.         "*.SU?",
  676.         "*.MO?",
  677.         "*.TU?",
  678.         "*.WE?",
  679.         "*.TH?",
  680.         "*.FR?",
  681.         "*.SA?"
  682.     };
  683. FILE_TYPE       f;
  684.  
  685.  
  686.     strcpy(filespec,path);      /* Start the filespec out with the path. */
  687.     p = filespec + strlen(filespec);    /* Point to the end of the path.
  688.                                            This lets us use strcpy() instead
  689.                                            of strcat to concatonate, and
  690.                                            relieves us from having to copy the
  691.                                            path back in every time. */
  692.     file_list = (FILE_TYPE *)malloc(sizeof(FILE_TYPE)); /* Allocate 1. */
  693.     if (file_list == NULL)              /* Check to see if it worked. */
  694.         return(-1);                     /* If not, we have a memory problem. */
  695.     i = 0;                              /* Start index/counter at 0. */
  696.     for (j = 0; j < 7; ++j)             /* Run through all the extensions. */
  697.     {
  698.         if (do_bundles)                 /* If doing all bundles, */
  699.             strcpy(p,bundles[j]);       /*  get the search pattern. */
  700.         else                /* Otherwise we're just looking for one file; */
  701.             j = 7;          /*  set index for once through. */
  702.         if (jjn_findfirst(filespec, 0, &buffer) == 0)   /* Find first one. */
  703.         {
  704.             ok = TRUE;
  705.             if (digits_only)
  706.                 if (!isdigit(buffer.bf_name[strlen(buffer.bf_name) - 1]))
  707.                     ok = FALSE;
  708.             if (ok)
  709.             {                   /* If we found one, allocate room for more. */
  710.                 file_list = (FILE_TYPE *)realloc((char *)file_list,(i + 1) * sizeof(FILE_TYPE));
  711.                 if (file_list == NULL)
  712.                     return(-1); /* If allocation didn't work, no more memory. */
  713.                 strcpy(file_list[i].filename,buffer.bf_name);   /* Get filename. */
  714.                 file_list[i].time = buffer.bf_time;             /* Get time. */
  715.                 file_list[i].date = buffer.bf_date;             /* Get date. */
  716.                 file_list[i].size = buffer.bf_size;             /* Get size. */
  717.                 ++i;                                            /* Count up. */
  718.             }
  719.             while (jjn_findnext(&buffer) == 0)  /* We're greedy, look for more. */
  720.             {
  721.                 ok = TRUE;
  722.                 if (digits_only)
  723.                     if (!isdigit(buffer.bf_name[strlen(buffer.bf_name) - 1]))
  724.                         ok = FALSE;
  725.                 if (ok)
  726.                 {               /* If we found one, allocate room for more. */
  727.                     file_list = (FILE_TYPE *)realloc((char *)file_list,(i + 1) * sizeof(FILE_TYPE));
  728.                     if (file_list == NULL)
  729.                         return(-1); /* If allocation didn't work, no more memory. */
  730.                     strcpy(file_list[i].filename,buffer.bf_name);/* Get filename. */
  731.                     file_list[i].time = buffer.bf_time;         /* Get time. */
  732.                     file_list[i].date = buffer.bf_date;         /* Get date. */
  733.                     file_list[i].size = buffer.bf_size;         /* Get size. */
  734.                     ++i;                                         /* Count up. */
  735.                 }
  736.             }
  737.         }
  738.     }
  739. /* We've found all the filenames there are to find. Now we use a bubble sort
  740.    to get them all into order by time/datestamp. I used a bubble sort because
  741.    the quicksort is much larger, and besides, I don't expect there to be
  742.    enough files to make the quicksort time-effective. In fact, I expect that
  743.    the files will usually be in order, in which case the bubble sort is
  744.    faster because it will only require one pass to find that out. */
  745.  
  746.     if (i > 1)                      /* Did we find more than one file? */
  747.     {                               /* Yes, do a bubble sort. */
  748.         j = 0;                      /* Start outside index at 0. */
  749.         do
  750.         {
  751.             found = FALSE;          /* This flag says whether any swaps made. */
  752.  
  753. /* The inside loop starts from the top and goes down to the outside loop
  754.    index. That way the lowest gets sorted to the bottom each time, and we
  755.    can safely ignore it from then on, and so increment the outside counter. */
  756.  
  757.             for (k = i - 2; k >= j; --k)
  758.             {
  759. /* We want the earlier file first. Compare returns TRUE if the earlier one
  760.    is second. If they are the same date, we don't care and leave them alone. */
  761.                 if (compare(&file_list[k],&file_list[k+1]))
  762.                 {                   /* Wrong order, swap the files. */
  763.                     found = TRUE;   /* Trip the flag; forces another pass. */
  764.                     memcpy((char *)&f,(char *)&file_list[k],sizeof(f));
  765.                     memcpy((char *)&file_list[k],(char *)&file_list[k+1],sizeof(f));
  766.                     memcpy((char *)&file_list[k+1],(char *)&f,sizeof(f));
  767.                 }
  768.             }
  769.         } while (++j < (i - 1) && found);   /* Do until they're in order. */
  770.     }
  771.     return(i);                  /* Return the number of files found. */
  772. }
  773.  
  774. /************************************************************************
  775.         Build the command line, based upon template & cmd type
  776.  ***********************************************************************/
  777. int build_cmd (char *extract_spec, char *overwrite_s, char *extract_s,
  778.                     char *template_s, char *filespec, char *cmdline)
  779. {
  780. int i, j, percent;
  781. char c, *t;
  782.  
  783. /* Build the command line according to the template. */
  784.  
  785.     for (i = 0, j = 0, percent = FALSE; template_s[i] != '\0'; ++i)
  786.     {
  787.         c = template_s[i];          /* Get the character. */
  788.         if (percent)                /* Was the last one a '%'? */
  789.         {
  790.             t = NULL;               /* Yup. Init this to NULL for testing. */
  791.             switch(c)               /* Find out which string we want. */
  792.             {
  793.               case '1': t = overwrite ? "" : extract_s;
  794.                         break;          /* Get the extract string. */
  795.               case '2': t = overwrite ? overwrite_s : "";
  796.                         break;          /* Get the overwrite string. */
  797.               case '3': t = filespec;
  798.                         break;          /* Get the file spec. */
  799.               case '4': t = extract_spec;
  800.                         break;          /* Get the extracted file spec. */
  801.               default:  cmdline[j++] = c;
  802.                         break;          /* Neither, just copy the character. */
  803.             }
  804.             if (t != NULL)                  /* If non-null, we got a string. */
  805.             {
  806.                 strcpy(cmdline + j,t);      /* Yup, copy the string in place of the %?. */
  807.                 j = strlen(cmdline);        /* Update the index. */
  808.             }
  809.             percent = FALSE;                /* Reset our '%' flag. */
  810.         }
  811.         else if (c == '%')              /* See if this is a '%'. */
  812.             percent = TRUE;             /* If so, process next character. */
  813.         else
  814.             cmdline[j++] = c;           /* Else just copy this character. */
  815.     }
  816.     cmdline[j] = '\0';                  /* Append a null. It's now a string. */
  817.     return (0);
  818. }
  819.  
  820. /************************************************************************
  821.                      Tokenize the command line.
  822. ************************************************************************/
  823. int tokenize (char *cmdline, int *argc, char *argv[], char **path)
  824. {
  825.     char *t;
  826.  
  827. /* Now we tokenize the command line. Separate everything at the spaces. I
  828.    currently ignore quotes, so this may want some enhancement. */
  829.     t = strtok(cmdline," ");
  830.     if (t == NULL)
  831.     {
  832.         printf("Error: encountered empty command line while attempting to tokenize.\n");
  833.         return(1);          /* No command found! Return an error. */
  834.     }
  835.     *path = t;              /* Store this as the execution path, */
  836.     argv[0] = t;            /*  and as the first argument. */
  837.     *argc = 1;              /* Set the argument counter/index. */
  838.     do
  839.     {
  840.         t = strtok(NULL," ");   /* Get the next token. */
  841.         argv[(*argc)++] = t;    /* Set it as the next argument and count up. */
  842.     } while (t != NULL);        /* Do it until we run out of tokens. */
  843. /* The beauty of that scheme is that the argument array is terminated by a
  844.    NULL address, which that loop will store as the last argument. */
  845.  
  846.     return(0);
  847. }
  848.  
  849. /****************************************************************************
  850. Create and execute a command. Don't use COMMAND.COM, we need the result code!
  851. ****************************************************************************/
  852. int execute(char *overwrite_s, char *extract_s, char *template_s,
  853.                                         char *filespec, char *extract_spec)
  854. {
  855. char    *argv[21];  /* Argument list. Allow 20 arguments + command name. */
  856. char    *path;          /* Command name. Also stored as argv[0]. */
  857. int     argc;           /* Number of arguments found. */
  858. int     i;              /* String index, and result of the spawn. */
  859. char    *t;             /* String pointer, and token pointer. */
  860. int     retval;
  861.  
  862. #ifdef AMIGA
  863. int     offset;         /* offset to just past the archiver name in cmd */
  864. char    justpath[110];
  865. char    justfile[110];
  866. char    buffer[256];    /* buffer for my new CMD string */
  867. char    cmdline[256];   /* The command string */
  868. struct ProcID pid;
  869. #else
  870. char    cmdline[128];   /* The command string. */
  871. #endif
  872.  
  873.     retval = build_cmd (extract_spec, overwrite_s, extract_s, template_s,
  874.                                    filespec, cmdline);
  875.     if (!quiet)
  876.         printf("-> Executing '%s'\n",cmdline);
  877.     if (retval != 0) return (retval);
  878.     retval = tokenize (cmdline, &argc, argv, &path);
  879.     if (retval != 0) return (retval);
  880.  
  881. #ifdef AMIGA
  882.     /*  A Bug in lattice causes the forkv function to NOT search */
  883.     /*  the C: device for commands.  This is why I have to manually */
  884.     /*  try that combination.  Darn irritating! */
  885.  
  886.     i = forkv(path,argv,NULL,&pid);  /* Spawn the task. */
  887.     if (i == -1) {
  888.         path_name (path, justpath, justfile);       /* get archiver name */
  889.         offset = strlen (path);       /* how far past name into cmdline? */
  890.         strcpy (buffer, "C:");                     /* start with C: path */
  891.         strcat (buffer, justfile);           /* and add the name on here */
  892.         retval = build_cmd (extract_spec, overwrite_s, extract_s, template_s,
  893.                             filespec, cmdline);
  894.         if (retval != 0) return (retval);
  895.         strcat (buffer, &cmdline[offset]);           /* move the args in */
  896.         strcpy (cmdline, buffer);  /* now put this all back into cmdline */
  897.         retval = tokenize (cmdline, &argc, argv, &path);
  898.         if (retval != 0) return(retval);
  899.         i = forkv (path, argv, NULL, &pid);
  900.     }
  901. #else
  902.     i = spawnvp(P_WAIT,path,argv);  /* Spawn the task. */
  903. #endif
  904.     if (i == -1)                /* Did we get an error trying to execute? */
  905.     {
  906.         switch (errno)          /* Yup, figure out why. */
  907.         {
  908.             case E2BIG:
  909.                 t = "Argument list too long";
  910.                 break;
  911.             case EINVAL:
  912.                 t = "Invalid argument";
  913.                 break;
  914.             case ENOENT:
  915.                 t = "Path or file name too long";
  916.                 break;
  917.             case ENOEXEC:
  918.                 t = "Exec format error";
  919.                 break;
  920.             case ENOMEM:
  921.                 t = "Not enough memory";
  922.                 break;
  923.  
  924.         /* we must put a default in, as Lattice is not properly
  925.            setting the errno flag!  Thus, I haven't tried to work
  926.            around it, I just admit it isn't specified... */
  927.         /* Actually, that's a good idea anyway. jjn */
  928.             default:
  929.                 t = "Unspecified Error";
  930.                 break;
  931.         }
  932.         printf("Error in execution; reason given: %s.\n",t);
  933.         return(-1);
  934.     }
  935. #ifdef AMIGA
  936.     i = wait(&pid); /* wait for our child process to terminate before
  937.                            we continue our processing.  Ain't multi-tasking
  938.                            nice??? ;^) */
  939.                     /* Whaddya think P_WAIT is for in the spawn command? :) */
  940. #endif
  941.     return(i);      /* No, we managed to execute it. Return the result. */
  942. }
  943.  
  944. /****************************************************************************
  945.       Search through the given file and figure out which type it is.
  946. ****************************************************************************/
  947. int find_type(char *path, char *filename, char *filespec)
  948. {
  949. FILE            *file;  /* File pointer. */
  950. SIGNATURE_TYPE  *s;     /* Pointer into signature list; provides dereferencing. */
  951. long            offset; /* Offset into the file. */
  952. register int    i;      /* Index into the signature list. */
  953. int             l;      /* Length of the signature. */
  954. char            buffer[SIGN_LEN];   /* Read buffer for the signatures. */
  955.  
  956.  
  957.     arc = FALSE;                    /* Note that no .ARC type found. */
  958.     file = fopen(filespec,"rb");    /* Open the file for binary read. */
  959.     if (file == NULL)               /* If can't open it, return with error. */
  960.     {
  961.         printf("Error: cannot open %s.\n",filespec);
  962.         return(1);
  963.     }
  964.     this_arc = -1;                  /* Show that nothing found so far. */
  965.     this_signature = -1;
  966.     i = 0;                          /* Start index at first signature. */
  967.     offset = 0xffffffff;            /* Show a ridiculous offset at first. */
  968.     while (i < signature_count && this_signature == -1)
  969.     {
  970.         s = &signature_list[i];     /* Dereference this signature. */
  971.         l = strlen(s->signature);   /* Get the signature length. */
  972.         if (s->file_offset != offset)   /* See if we already have that spot. */
  973.         {
  974.             offset = s->file_offset;    /* Nope, move to it and read it. */
  975.             fseek(file,offset,(offset < 0) ? 2 : 0);
  976.             fread(buffer,sizeof(buffer),1,file);
  977.         }
  978.         if (strncmp(s->signature,buffer,l) == 0)    /* Are they the same? */
  979.                                                     /* Note: case sensitive! */
  980.             this_signature = i;         /* If so, record it. */
  981.         ++i;                            /* Increment the counter. */
  982.     }   /* Do that until we find a signature or run out. */
  983.     if (this_signature == -1)           /* Did we find a signature? */
  984.     {                                   /* If not, look for an .ARC file. */
  985.         if (offset != 0l)               /* See if we have this in memory. */
  986.         {
  987.             fseek(file,0l,0);           /* If not, seek 0 and read 1 byte. */
  988.             fread(buffer,1,1,file);
  989.         }
  990.         if (buffer[0] == 0x1a)          /* 1A is the .ARC signature. */
  991.             arc = TRUE;                 /* If so, assume it's an .ARC file. */
  992.     }
  993.     fclose(file);                       /* Either way, we're done for now. */
  994.     if (arc)                            /* Is it an .ARC file? */
  995.     {
  996.         i = pak_dosort(path,filename,!nosort);  /* If so, try to sort. */
  997.         printf("Highest ARC level found: %d.\n",highest_type);
  998. /*
  999. Actually, pak_dosort() scans through the .ARC file, finding the highest
  1000. level of compression used. It only sorts if nosort is FALSE.
  1001.  
  1002. Returns 0 if successful, or error:
  1003.    1 = Can't open/read source. (missing pakfile or DOS error)
  1004.    2 = Can't create/write dest. (maybe disk or directory full)
  1005.    3 = Can't delete old source file. (read-only)
  1006.    4 = Can't rename temp file to source name. (DOS error)
  1007.    5 = Out of memory.
  1008.    6 = Invalid pakfile. (Header error)
  1009.  
  1010. If we got 2, print a warning and go on. Otherwise, we quit on any error.
  1011. */
  1012.         if (i == 2)
  1013.         {
  1014.             printf("Warning: sort failed. Attempting extract anyway.\n");
  1015.         }
  1016.         else if (i != 0)
  1017.             return(i);
  1018. /* Did ok, so let's see what we've got. */
  1019.         i = 0;
  1020.         while (i < arc_count && this_arc == -1)
  1021.         {
  1022.             if ((version6 && arc_list[i].version) || !version6)
  1023.                 if ((byte)highest_type <= arc_list[i].type)
  1024.                     this_arc = i;   /* Set this_arc to .ARC type found. */
  1025. /* If the highest .ARC type is higher than we can handle, it never finds it.
  1026.    The calling routine will claim that we couldn't find the archive type.
  1027.    If the archive has version 6 headers, then the extractor must also be
  1028.    capable of version 6 extraction.  */
  1029.             ++i;
  1030.         }
  1031.     }
  1032.     return(0);
  1033. }
  1034.  
  1035. /****************************************************************************
  1036. Converts the first 4 characters from a string from hex to a signed integer.
  1037. If there are any non-digits in those four characters, it returns -65536.
  1038. ****************************************************************************/
  1039. long one_hex(char *name)
  1040. {
  1041. int                 i;      /* Index. */
  1042. register int16      j;      /* Accumulated result. */
  1043. register int16      c;      /* Holding place for the converted character. */
  1044.  
  1045.     j = 0;                      /* Reset accumulated result. */
  1046.     for (i = 0; i < 4; ++i)     /* Go through the first 4 characters. */
  1047.     {
  1048.         c = toupper(name[i]);   /* Get the upper case character. */
  1049.         if (!isxdigit(c))       /* Is it a hex digit? */
  1050.             return -65536;      /* If not, return error. */
  1051.         if (c >= 'A')           /* Change 'A'-'F' into A-F. */
  1052.             c -= 7;
  1053.         j = (j << 4) + c - '0'; /* Subtract ASCII offset and accumulate. */
  1054.     }
  1055.     return (long)j;             /* Return the result. */
  1056. }
  1057.  
  1058. /****************************************************************************
  1059.                          Display address of sender.
  1060. ****************************************************************************/
  1061. void sender_is(char *filename)
  1062. {
  1063. int             net;
  1064. int             node;
  1065. long            i;
  1066.  
  1067.     i = one_hex(filename);      /* Convert first 4 characters of filename. */
  1068.     if (i == -65536)            /* If not hex number, ignore it. */
  1069.         return;
  1070.     net = (int16)i;             /* Assume this is a net difference. */
  1071.     i = one_hex(filename + 4);  /* Convert last 4 characters of filename. */
  1072.     if (i == -65536)            /* If not hex number, ignore it. */
  1073.         return;
  1074.     node = (int16)i;            /* Assume this is a node difference. */
  1075.  
  1076. /* Calculate the net/node address from the filename and your address, and
  1077.    display the result. */
  1078.     printf("Extracting bundle from %u/%u.\n",this_net + net,this_node + node);
  1079. }
  1080.  
  1081. /****************************************************************************
  1082.                           Discombobulate one file.
  1083. ****************************************************************************/
  1084. int discombobulate(char *path,char *filename, char *extract_spec)
  1085. {
  1086. int     i;              /* General purpose variable. */
  1087. char    filespec[fname_len];    /* File specification generated from path and name. */
  1088.  
  1089.     if (show_addresses) /* If we're supposed to show the address, do so. */
  1090.         sender_is(filename);
  1091.     strcpy(filespec,path);      /* Create the filespec from the path */
  1092.     strcat(filespec,filename);  /*  and the filename. */
  1093.     i = find_type(path,filename,filespec);  /* Find the type of file. */
  1094.     if (i)                      /* If can't do it, return with the error. */
  1095.         return(i);
  1096.     if (this_arc != -1)         /* See if it's an .ARC file. */
  1097.     {
  1098.         i = execute(arc_list[this_arc].overwrite,
  1099.                     arc_list[this_arc].extract,
  1100.                     arc_list[this_arc].cmdline,
  1101.                     filespec,
  1102.                     extract_spec);  /* Try to extract. */
  1103.     }
  1104.     else if (this_signature != -1)  /* Nope, see if it's something else. */
  1105.     {
  1106.         i = execute(signature_list[this_signature].overwrite,
  1107.                     signature_list[this_signature].extract,
  1108.                     signature_list[this_signature].cmdline,
  1109.                     filespec,
  1110.                     extract_spec);  /* Try to extract. */
  1111.     }
  1112.     else                        /* Whoops! We couldn't figure it out. */
  1113.     {
  1114.         printf("Error: cannot determine archive type of %s.\n",filespec);
  1115.         if (arc && this_arc == -1)
  1116.             printf("The ARC level was higher than anything defined.\n");
  1117.         return(6);
  1118.     }
  1119.     if (i > 0)          /* This means the archiver ran into trouble. */
  1120.     {
  1121.         printf("Error return %d from archiver.\n",i);
  1122.         i = 8;
  1123.     }
  1124.     else if (i < 0)     /* This means we never got to execute it. */
  1125.     {
  1126.         return(10);
  1127.     }
  1128.     else if (delete_archives)   /* No problems. Erase the evidence. */
  1129.     {
  1130.         printf("Unpack successful: deleting %s.\n",filespec);
  1131.         i = unlink(filespec);
  1132.         if (i)
  1133.         {
  1134.             printf("Error: could not delete %s.",filespec);
  1135. #ifdef OS_2
  1136.             printf("\nERRNO is %d.",errno);
  1137. #endif
  1138.  
  1139.  
  1140.             i = 3;
  1141.         }
  1142.     }
  1143.     printf("\n");
  1144.     return(i);
  1145. }
  1146.  
  1147. /****************************************************************************
  1148.       Discombobulate all bundles (or n bundles if do_n_bundles != 0).
  1149. ****************************************************************************/
  1150. int discombobulate_all(char *path, char *extract_spec, int do_bundles)
  1151. {
  1152. int     numfiles;       /* How many files we found. */
  1153. int     count;          /* Index counter. */
  1154. int     i;              /* General purpose register. */
  1155.  
  1156.     numfiles = get_files(path,do_bundles);  /* Collect filenames. */
  1157.     if (numfiles < 0)       /*  < 0 means we got an error in allocation. */
  1158.         return(5);
  1159.  
  1160. /* Not having anything to discombobulate with the -F switch isn't _really_ an
  1161.    error condition. Having PolyXarc return an error under these circumstances
  1162.    made me and Peter Stern spend several days beating our heads against the
  1163.    wall. From now on we'll just return 0 if this happens. -jjn */
  1164.  
  1165.     if (numfiles == 0)      /* == 0 means no files found. */
  1166.         return(do_all_bundles ? 0 : 1);
  1167.     if (do_n_bundles)                       /* If limited, */
  1168.         if (numfiles > do_n_bundles)        /*  and if past the limit, */
  1169.             numfiles = do_n_bundles;        /*  limit the file count. */
  1170.  
  1171. /* If we're not doing bundles, then path was actually a filespec. In that case
  1172.    we need to throw away the filename.ext and keep the path. The filename.ext
  1173.    will be drawn from the list of files that we got from get_files(). */
  1174.     if (!do_bundles)
  1175.         path_name(path,path,NULL);
  1176.  
  1177.     for (count = 0; count < numfiles; ++count)  /* Do all the files. */
  1178.     {
  1179.         if (file_list[count].size == 0l)        /* Is this an empty file? */
  1180.         {
  1181.             if (do_bundles)                     /* Are we doing bundles? */
  1182.             {
  1183.                 unlink(file_list[count].filename);  /* Yes; just delete it. */
  1184.                 printf("Zero-length file %s deleted.",file_list[count].filename);
  1185.             }
  1186.             else                            /* No, consider this an error. */
  1187.             {
  1188.                 printf("Error: file %s is length 0.",file_list[count].filename);
  1189.                 return(9);
  1190.             }
  1191.         }
  1192.         else    /* The file is not zero length. */
  1193.         {
  1194.             i = discombobulate(path,file_list[count].filename,extract_spec);
  1195.                                     /* Extract. */
  1196.             if (do_bundles)         /* Are we doing bundles? */
  1197.             {
  1198.                 switch (i)          /* If so, look at the return value. */
  1199.                 {
  1200.                     case 0:         /* Nothing went wrong, do nothing. */
  1201.                         break;
  1202.                     case 1:
  1203.                     case 2:         /* Fatal error, return error code. */
  1204.                     case 4:
  1205.                     case 5:
  1206.                     case 7:
  1207.                         return(i);
  1208.                     default:        /* Non-fatal, rename file and continue. */
  1209.                         ren_bad_arc(path,file_list[count].filename);
  1210.                 }
  1211.             }
  1212.             else    /* Not doing bundles. If we got an error, just return it. */
  1213.             {
  1214.                 if (i == 8 && ignore_archiver_errors)
  1215.                     i = 0;
  1216.                 else
  1217.                     if (i)
  1218.                         return(i);
  1219.             }
  1220.         }
  1221.     }
  1222.     return(0);  /* No fatal errors. Return. */
  1223. }
  1224.  
  1225. /****************************************************************************
  1226.                      Find "PENGUIN=" in environment
  1227.  
  1228.  Unfortunately, under Amiga Lattice the 'getenv()' function only returns
  1229.  Commodore's Environment variables, *NOT* the more common Manx/ARP/Rockiki
  1230.  style variables...  I will try to remedy this in the future.
  1231. ****************************************************************************/
  1232. int p_env(void)
  1233. {
  1234. char    *t;
  1235.  
  1236.     t = getenv("PENGUIN");              /* Try to find a PENGUIN file. */
  1237.  
  1238.     if (t != NULL)                      /* See if "PENGUIN=" in environment. */
  1239.     {
  1240.         strcpy(config_name,strupr(t));  /* Get the name of the file. */
  1241.         return(1);                      /* Return TRUE. */
  1242.     }
  1243.     return(0);                          /* Nothing found, return FALSE. */
  1244. }
  1245.  
  1246. /****************************************************************************
  1247.                      Process the configuration file.
  1248.  
  1249. The configuration file consists of one or more blocks that start with
  1250. BEGIN POLYXARC and end with END POLYXARC (case insensitive). Between the
  1251. delimiting statements are one or more keywords, one per line. Most keywords
  1252. will have parameters sharing the line. Keywords are:
  1253.  
  1254. ARC level overwrite extract extract_command_template
  1255.  
  1256.     %1: extraction string
  1257.     %2: overwrite string
  1258.     %3: archive file spec
  1259.     %4: extracted file spec
  1260.  
  1261. SIGNATURE offset signature overwrite extract extract_command_template
  1262.  
  1263.     %1: extraction string
  1264.     %2: overwrite string
  1265.     %3: archive file spec
  1266.     %4: extracted file spec
  1267.  
  1268. NOSORT
  1269.  
  1270. ****************************************************************************/
  1271. int get_config(char *argv0)
  1272. {
  1273. FILE            *config=NULL;   /* Config file. */
  1274. char            *f;             /* Scratch string */
  1275. char            *g;             /* Scratch string */
  1276. char            *s1;            /* Pointer to signature token. */
  1277. char            *s2;            /* Pointer to overwrite token. */
  1278. char            *s3;            /* Pointer to extract token. */
  1279. char            oneline[132];   /* Holds one line from file. */
  1280. register int    i;              /* scratch integer */
  1281. int             quit;
  1282. int             arc6;           /* True if found version 6 definition. */
  1283. long            l;
  1284.  
  1285.     if (config_name_set || !(config_name == NULL))
  1286.         config = fopen(config_name,"rt");   /* Open the config file. */
  1287.     if (config == NULL && !config_name_set) /* Did it work? */
  1288.     {                                       /* Nope. */
  1289.         path_name(argv0,config_name,NULL);  /* Get path of POLYXARC.EXE. */
  1290.         strcat(config_name,DEFAULT_NAME);   /* Add the default .CFG name. */
  1291.         config = fopen(config_name,"rt");   /* Now try to open it. */
  1292.         if (config == NULL)                 /* Did that work? */
  1293.         {                                   /* Nope. */
  1294.  
  1295. /* Set up the config name to default to the default name in the current
  1296.    directory, then try to find a PENGUIN file. If there is a penguin file,
  1297.    it overrides the default. Otherwise, we'll try the default. */
  1298.             strcpy(config_name,DEFAULT_NAME);    /* Restore the default. */
  1299.             if (p_env())                         /* Get PENGUIN file, if any. */
  1300.                 config = fopen(config_name,"rt");/* Try to open it. */
  1301.         }
  1302.     }
  1303.     if (config == NULL)                     /* Nothing worked! */
  1304.     {
  1305.         printf("Cannot open configuration file %s.\n",config_name);
  1306.         return(1);
  1307.     }
  1308.     arc_list =                              /* Pre-allocate 1. */
  1309.             (ARC_TYPE *)malloc(sizeof(ARC_TYPE));
  1310.     signature_list =                        /* Pre-allocate 1. */
  1311.             (SIGNATURE_TYPE *)malloc(sizeof(SIGNATURE_TYPE));
  1312.     do  /* Do until we run out of file. */
  1313.     {
  1314.         i = TRUE;                           /* Initialize this flag. */
  1315.         do                                  /* Do until i == FALSE. */
  1316.         {
  1317.             f = fgets(oneline,sizeof(oneline),config);  /* Get one line. */
  1318.             if (f == NULL)                  /* Did it work? */
  1319.                 i = FALSE;                  /* If not, drop through. */
  1320.             else
  1321.             {
  1322.                 if ((g = parmtok(oneline," \t\n")) != NULL)/* Tokenize the line. */
  1323.                 {
  1324.                     if (stricmp(g,"BEGIN") == 0)/* First word BEGIN? */
  1325.                     {
  1326.                         g = parmtok(NULL," \t\n");      /* If so, tokenize again. */
  1327.                         if (stricmp(g,"POLYXARC") == 0) /* Second word POLYXARC? */
  1328.                             i = FALSE;          /* If so, drop through. */
  1329.                     }
  1330.                 }
  1331.             }
  1332.         } while (i);                        /* Do this until i == FALSE. */
  1333.         quit = 0;                           /* Don't quit yet! */
  1334.         do                                  /* Do until quit. */
  1335.         {
  1336.             f = fgets(oneline,sizeof(oneline),config);  /* Get a line. */
  1337.             if (f != NULL)                              /* Did it work? */
  1338.             {                                           /* Yup. */
  1339.                 if ((g = parmtok(oneline," \t\n")) != NULL)/* Tokenize. */
  1340.                 {
  1341. /* ARC level command_template */
  1342.                     if (strnicmp(g,"ARC",3) == 0)           /* First word ARC? */
  1343.                     {                                       /* Yup. */
  1344.                         arc6 = ('6' == g[3]);
  1345.                         i = atoi(parmtok(NULL," \t\n"));/* Get ARC level. */
  1346.                         s2 = parmtok(NULL," \t\n");     /* Get overwrite switch. */
  1347.                         s3 = parmtok(NULL," \t\n");     /* Get extract switch. */
  1348.                         g = parmtok(NULL,"\n");         /* Get the template. */
  1349.                         if (g == NULL)          /* Did we get all those fields? */
  1350.                         {                       /* Nope, something was left out. */
  1351.                             printf("Syntax error in config file.\n");
  1352.                             return(7);
  1353.                         }
  1354.                         while (*g == ' ' || *g == '\t') /* Remove leading spaces. */
  1355.                             ++g;
  1356.                         arc_list =                      /* Allocate room for more. */
  1357.                                 (ARC_TYPE *)realloc(arc_list,
  1358.                                         (arc_count + 1) * sizeof(ARC_TYPE));
  1359.                         arc_list[arc_count].type = (byte)i;     /* Save ARC level. */
  1360.                         arc_list[arc_count].version = (byte)arc6;/* Record if version 6. */
  1361.                         strcpy(arc_list[arc_count].overwrite,   /* Save overwrite. */
  1362.                                                 strtrunc(s2,OVER_LEN - 1));
  1363.                         strcpy(arc_list[arc_count].extract, /* Save extract. */
  1364.                                                 strtrunc(s3,EXTR_LEN - 1));
  1365.                         arc_list[arc_count].cmdline =   /* Allocate for template. */
  1366.                                                 malloc(strlen(g) + 1);
  1367.                         strcpy(arc_list[arc_count].cmdline,g);  /* Save template. */
  1368.                         ++arc_count;                            /* Count up. */
  1369.                     }
  1370. /* SIGNATURE offset signature command_template */
  1371.                     else if (stricmp(g,"SIGNATURE") == 0)   /* First word SIGNATURE? */
  1372.                     {                                       /* Yup. */
  1373.                         l = atol(parmtok(NULL," \t\n"));/* Get ARC level. */
  1374.                         s1 = parmtok(NULL," \t\n");     /* Get signature string. */
  1375.                         s2 = parmtok(NULL," \t\n");     /* Get overwrite switch. */
  1376.                         s3 = parmtok(NULL," \t\n");     /* Get extract switch. */
  1377.                         g = parmtok(NULL,"\n");         /* Get the template. */
  1378.                         if (g == NULL)          /* Did we get all those fields? */
  1379.                         {                       /* Nope, something was left out. */
  1380.                             printf("Syntax error in config file.\n");
  1381.                             return(7);
  1382.                         }
  1383.                         while (*g == ' ' || *g == '\t') /* Remove leading spaces. */
  1384.                             ++g;
  1385.                         signature_list =                /* Allocate room for more. */
  1386.                                 (SIGNATURE_TYPE *)realloc(signature_list,
  1387.                                 (signature_count + 1) * sizeof(SIGNATURE_TYPE));
  1388.                         signature_list[signature_count].file_offset = l;/* Save offset. */
  1389.                         strcpy(signature_list[signature_count].signature,/* Save signature. */
  1390.                                                 strtrunc(s1,SIGN_LEN - 1));
  1391.                         strcpy(signature_list[signature_count].overwrite,/* Save overwrite. */
  1392.                                                 strtrunc(s2,OVER_LEN - 1));
  1393.                         strcpy(signature_list[signature_count].extract, /* Save extract. */
  1394.                                                 strtrunc(s3,EXTR_LEN - 1));
  1395.                         signature_list[signature_count].cmdline =   /* Allocate for template. */
  1396.                                                 malloc(strlen(g) + 1);
  1397.                         strcpy(signature_list[signature_count].cmdline,g);  /* Save template. */
  1398.                         ++signature_count;                      /* Count up. */
  1399.                     }
  1400.                     else if (stricmp(g,"NOSORT") == 0)  /* First word NOSORT? */
  1401.                     {                                   /* Yup. */
  1402.                         nosort = TRUE;              /* Override sort directive. */
  1403.                     }
  1404.                     else if (stricmp(g,"END") == 0)     /* First word END? */
  1405.                     {                                   /* Yup. */
  1406.                         g = parmtok(NULL," \t\n");      /* Tokenize again. */
  1407.                         if (stricmp(g,"POLYXARC") == 0) /* Second word POLYXARC? */
  1408.                             quit = 1;                   /* Yup. Ignore everything
  1409.                                                        until end of file or
  1410.                                                        another BEGIN POLYXARC. */
  1411.                     }
  1412.                 }
  1413.             }
  1414.             else
  1415.                 quit = 2;   /* Reached end of file, really quit now. */
  1416.         } while (!quit);    /* Do until quit. */
  1417.     } while (quit < 2);     /* If quit == 1, not end of file, just end of
  1418.                                BEGIN/END block. Keep looking. */
  1419.     fclose(config);         /* End of file, close it. */
  1420.     return(0);              /* No errors, return 0. */
  1421. }
  1422.  
  1423. /****************************************************************************
  1424.                     This sorts the .ARC list by type.
  1425. ****************************************************************************/
  1426. void sort_arc_list(void)
  1427. {
  1428. ARC_TYPE local_arc_list;
  1429. register int i;
  1430. register int j;
  1431. register int k;
  1432. register int swapped;
  1433.  
  1434.     k = arc_count - 1;
  1435.     do
  1436.     {
  1437.         swapped = 0;
  1438.         for (i = 0; i < k; ++i)
  1439.         {
  1440.             j = arc_list[i].version - arc_list[i+1].version;
  1441.             if (j > 0 || (j == 0 && arc_list[i].type > arc_list[i+1].type))
  1442.             {
  1443.                 memcpy((char *)&local_arc_list,(char *)&arc_list[i],sizeof(ARC_TYPE));
  1444.                 memcpy((char *)&arc_list[i],(char *)&arc_list[i+1],sizeof(ARC_TYPE));
  1445.                 memcpy((char *)&arc_list[i+1],(char *)&local_arc_list,sizeof(ARC_TYPE));
  1446.                 swapped = 1;
  1447.             }
  1448.         }
  1449.         --k;
  1450.     } while (swapped);
  1451. }
  1452.  
  1453. /****************************************************************************
  1454.                     Process command-line parameters
  1455.  
  1456.   -#       Does not recognize a .MO? - .SU? file unless it ends
  1457.            with a decimal digit. Used only with the -F flag.
  1458.   -Cconf   Specify configuration file. Default is POLYXARC.CFG.
  1459.   -D       Will delete the archive if the extract was successful.
  1460.   -F[n]    Will process all Compressed Mail bundles found in Dir.
  1461.   -Maddr   Will calculate Compressed Mail bundle name to show the
  1462.            sending Net Address.  "addr" is YOUR Net/Node address.
  1463.   -N       Will NOT attempt to sort the archive prior to extract.
  1464.   -O       Overwrite.  Will NOT prompt if existing file is found.
  1465.   -R       Same as -O, included for ARCE syntax compatibility.
  1466.   -Q       QuietMode. Will NOT display the runtime configuration.
  1467.  
  1468. If -F is used then "Archive" MUST be a Path ONLY, not a Filename.
  1469. Use of -F forces -D and -O to be set TRUE and -N to be set False.
  1470. (The NOSORT verb in the configuration file overrides the -F parameter
  1471. and forces -N to be set True.) If a number is specified with the
  1472. -F parameter, then PolyXarc will only process that number of archives
  1473. (as a maximum).
  1474. ****************************************************************************/
  1475. void process_args(char *arg)
  1476. {
  1477. char    *tok;
  1478.  
  1479.     tok = strtok(arg,"\n");
  1480.     if (tok == NULL)
  1481.         return;
  1482.     if (*tok == '/' || *tok == '-')
  1483.     {
  1484.         ++tok;
  1485.         switch(toupper(*tok))
  1486.         {
  1487.           case '#': digits_only = TRUE;
  1488.                     break;
  1489.           case 'C': strcpy(config_name,strupr(++tok));
  1490.                     config_name_set = TRUE;
  1491.                     break;
  1492.           case 'D': delete_archives = TRUE;
  1493.                     break;
  1494.           case 'F': do_all_bundles = TRUE;
  1495.                     do_n_bundles = atoi(++tok);
  1496.                     break;
  1497.           case 'I': ignore_archiver_errors = TRUE;
  1498.                     break;
  1499.           case 'M': show_addresses = TRUE;
  1500.                     this_net = (unsigned int)atol(strtok(++tok,"/."));
  1501.                     this_node = (unsigned int)atol(strtok(NULL,"/."));
  1502.                     break;
  1503.           case 'N': nosort = TRUE;
  1504.                     break;
  1505.           case 'O':
  1506.           case 'R': overwrite = TRUE;
  1507.                     break;
  1508.           case 'Q': quiet = TRUE;
  1509.                     break;
  1510.         }
  1511.     }
  1512.     else
  1513.     {
  1514.         switch(name_count++)
  1515.         {
  1516.           case 0:   strcpy(archive_name,strupr(tok));   /* Get archive filespec. */
  1517.                     archive_name_set = TRUE;
  1518.                     break;
  1519.           case 1:   strcpy(extract_name,tok);           /* Get extract name filespec. */
  1520.                     break;
  1521.           default:  strcat(extract_name," ");           /* Add a space for parameter separation. */
  1522.                     strcat(extract_name,tok);           /* Get another extract name filespec. */
  1523.                     break;
  1524.         }
  1525.     }
  1526. }
  1527.  
  1528. /****************************************************************************
  1529.                     Display the run-time configuration.
  1530. ****************************************************************************/
  1531. void display_configuration(void)
  1532. {
  1533.     printf("Archive %s is %s.\n",
  1534.             do_all_bundles ? "path" : "name",
  1535.             archive_name_set ? (char *)archive_name : "the current directory");
  1536.     printf("Using configuration file %s.\n",config_name);
  1537.     printf("%s delete archives after extraction.\n",
  1538.                                             delete_archives ? "Will" : "Will not");
  1539.     if (do_all_bundles)
  1540.     {
  1541.         if (do_n_bundles)
  1542.             printf("Will process up to %d mail archives.\n",do_n_bundles);
  1543.         else
  1544.             printf("Will process all mail archives.\n");
  1545.     }
  1546.     printf("%s show source addresses.\n",show_addresses ? "Will" : "Will not");
  1547.     if (show_addresses)
  1548.         printf("This node's address is %u/%u.\n",this_net,this_node);
  1549.     printf("%s sort .ARC format archives.\n",nosort ? "Will not" : "Will");
  1550.     printf("%s automatically overwrite existing files.\n\n",
  1551.                                                 overwrite ? "Will" : "Will not");
  1552.     if (ignore_archiver_errors)
  1553.         printf("Will ignore errors from the archiver(s).\n");
  1554. }
  1555.  
  1556. /****************************************************************************
  1557.                               Main function.
  1558.  
  1559. Returns 0 if successful, or errorlevel for DOS on error:
  1560.    1 = Can't open/read source. (missing or invalid file)
  1561.    2 = Can't create/write dest (maybe disk or directory full)
  1562.    3 = Can't delete old source file. (read-only)
  1563.    4 = Can't rename temp file to source name.
  1564.    5 = Out of memory.
  1565.    6 = Cannot determine archive type.
  1566.    7 = Configuration file syntax error.
  1567.    8 = Non-0 error return from archive extractor.
  1568.    9 = Zero-length file.
  1569.   10 = Error while attempting to execute the archiver.
  1570. ****************************************************************************/
  1571. int main(int argc,char **argv)
  1572. {
  1573. int     i;
  1574.  
  1575.     printf("\nPolyXarc v" R_VERS " " R_PORT "  " R_DATE "; Public Domain.\n");
  1576.     printf("Written by Jeffrey Nonken of 1:273/715@Fidonet (215)279-9799.\n\n");
  1577. #ifdef AMIGA
  1578.     printf("Ported to the Amiga by Steven M. Palm.  1:11/16 @ FidoNet\n");
  1579.     printf("Subject to change without notice.  No support implied.\n");
  1580.     printf("Just a reminder:  This uses MS-DOS style wildcards.\n\n");
  1581. #endif
  1582. #ifdef OS_2
  1583.     printf("Ported to OS/2 by Bill Andrus of 1:109/301@Fidonet.\n\n");
  1584. #endif
  1585.  
  1586.  
  1587.     if (argc == 2) if (stricmp(argv[1],"?") == 0)
  1588.     {
  1589.         printf("PolyXarc archive [-Cconf] [-D] [-F[n]] [-#] [-Maddr] [-N]\n"
  1590.                "                 [-O|R] [-Q] [-I] [filename [filename...]]\n"
  1591.                "See POLYXARC.DOC for more details.\n");
  1592.         quit(0);
  1593.     }
  1594.     for (i = 1; i < argc; ++i)      /* Process command-line arguments. */
  1595.         process_args(argv[i]);
  1596.     if (do_all_bundles)             /* If -f, override some settings. */
  1597.     {
  1598.         delete_archives = TRUE;     /* Delete archives when done. */
  1599.         overwrite = TRUE;           /* Overwrite existing files. */
  1600.         nosort = FALSE;             /* Don't sort. */
  1601.         slash(archive_name);        /* Add trailing backslash to path. */
  1602.     }
  1603. #ifndef AMIGA
  1604.     else  /* I said we don't do default extensions under AmigaDOS... ;^) */
  1605.         default_ext(archive_name,"*");  /* If no extension, add ".*". */
  1606. #endif
  1607.     i = get_config(argv[0]);        /* Get the configuration file. */
  1608.     if (!i)                         /* If it worked, keep going. */
  1609.     {
  1610.         sort_arc_list();            /* Sort the .ARC list by level. */
  1611.         if (!do_all_bundles         /* Doing bundles? */
  1612.             && !archive_name_set)   /* If not, needs a filename. */
  1613.         {                           /* No file name specified! Return error. */
  1614.             printf("Error: archive name not specified. Use 'PolyXarc ?' for help.\n");
  1615.             quit(1);
  1616.         }
  1617.         if (!quiet)                 /* If no -q, display runtime config. */
  1618.             display_configuration();
  1619.         i = discombobulate_all(archive_name,extract_name,do_all_bundles);
  1620.     }
  1621.     fcloseall();                    /* Close all files. */
  1622.  
  1623. #ifdef AMIGA
  1624.     quit(i);  /* for some reason, return() will not function as the */
  1625.           /* exit the main function prperly under Lattice 5.05. */
  1626.           /* It always gives 0.  I don't s'pose it would hurt to */
  1627.           /* do this on the IBM set as well.... */
  1628. #endif
  1629.  
  1630. /* Actually, you get a warning from the MSC compiler if you don't have
  1631.    a return statement in a function. I decided to leave the return in for
  1632.    MSC and TURBOC. jjn */
  1633.  
  1634. #ifdef IBM
  1635.     quit(i);
  1636.     return(i);
  1637. #endif
  1638. }
  1639.