home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / util / zoo-2.1.lha / zoo / amiga.c < prev    next >
C/C++ Source or Header  |  1992-05-02  |  16KB  |  732 lines
  1. #ifndef LINT
  2. static char    amigaid[] = "@(#) amiga.c 1.1 91/08/03 23:21:00";
  3.  
  4. #endif                /* LINT */
  5.  
  6. /*
  7.  * machine.c for Amiga.
  8.  *
  9.  * This file is (C) Copyright 1991 by Olaf Seibert. All rights reserved. May
  10.  * be used and distributed under the same conditions as the other
  11.  * non-public-domain files that are part of Zoo.
  12.  */
  13.  
  14. #undef TEXT            /* typedef in exec/types.h */
  15. #include <assert.h>
  16. #include <exec/types.h>
  17. #include <libraries/dos.h>
  18. #include <signal.h>
  19.  
  20. #ifdef __STDC__
  21. #define __args
  22. #include <functions.h>
  23. #else
  24. BPTR        Lock(), CreateDir(), ParentDir();
  25. long        Examine(), ExNext();
  26. void           *AllocMem();
  27. struct MsgPort *DeviceProc();
  28. long        SetSignal();
  29.  
  30. #endif
  31.  
  32. int iswild    PARMS((char *));
  33. void endfile    PARMS((int));
  34. void fcbpath    PARMS((char *, char *));
  35. void ToDateStamp PARMS((struct DateStamp * datestamp, unsigned date, unsigned time));
  36. void ToMSDate    PARMS((unsigned *date, unsigned *time, struct DateStamp * datestamp));
  37. void _abort    PARMS((void));
  38. long Chk_Abort    PARMS((void));
  39.  
  40. /*
  41.  * WARNING:  This file assumes that ZOOFILE is a standard buffered file.
  42.  * It will have to be modified if ZOOFILE is changed to be an unbuffered
  43.  * file descriptor or to any other kind of file.
  44.  */
  45.  
  46. #ifdef UNBUF_IO
  47. /*
  48.  * Function tell() returns the current seek position for a file
  49.  * descriptor. 4.3BSD on VAX-11/785 has an undocumented tell() function
  50.  * but it may not exist on all implementations, so we code one here to be
  51.  * on the safe side.  It is needed for unbuffered I/O only.
  52.  */
  53. long lseek    PARMS((int, long, int));
  54. long
  55. tell(fd)
  56. int        fd;
  57. {
  58.     return lseek(fd, 0L, 1);
  59. }
  60.  
  61. #endif
  62.  
  63.  
  64. /*
  65.  * Function zootrunc() truncates a file.
  66.  */
  67.  
  68. int
  69. zootrunc(f)
  70. ZOOFILE     f;
  71. {
  72.     fflush(f);                  /* just in case it matters */
  73.     /* Cannot truncate on AmigaOS < 2.0 */
  74. }
  75.  
  76. /*
  77.  * Function fixfname() converts the supplied filename to a syntax legal
  78.  * for the host system.  It is used during extraction.
  79.  */
  80.  
  81. char           *
  82. fixfname(fname)
  83. char           *fname;
  84. {
  85.     return fname;        /* default is no-op */
  86. }
  87.  
  88. /*
  89.  * Function isuadir() returns 1 if the supplied name is a directory, else
  90.  * it returns 0.
  91.  */
  92.  
  93. int
  94. isuadir(path)
  95. char           *path;
  96. {
  97.     struct FileInfoBlock *fib;
  98.     int         its_a_dir;
  99.  
  100.     its_a_dir = 0;
  101.     if (fib = malloc(sizeof (*fib))) {
  102.     BPTR        lock;
  103.  
  104.     if (lock = Lock(path, ACCESS_READ)) {
  105.         Examine(lock, fib);
  106.         its_a_dir = (fib->fib_DirEntryType > 0);
  107.         UnLock(lock);
  108.     }
  109.     free(fib);
  110.     }
  111.     return its_a_dir;
  112. }
  113.  
  114. /* No standard UNIX-compatible time routines */
  115.  
  116. /*
  117.  * Function getutime() gets the date and time of the file name supplied.
  118.  * Date and time is in MSDOS format.
  119.  */
  120. int
  121. getutime(path, date, time)
  122. char           *path;
  123. unsigned       *date,
  124.            *time;
  125. {
  126.     struct FileInfoBlock *fib;
  127.  
  128.     *date = 0;
  129.     *time = 0;
  130.  
  131.     if (fib = malloc(sizeof (*fib))) {
  132.     BPTR        lock;
  133.  
  134.     if (lock = Lock(path, ACCESS_READ)) {
  135.         Examine(lock, fib);
  136.  
  137.         ToMSDate(date, time, &fib->fib_Date);
  138.         UnLock(lock);
  139.     }
  140.     free(fib);
  141.     }
  142.     return 0;
  143. }
  144.  
  145. /*
  146.  * Function setutime() sets the date and time of the filename supplied.
  147.  * Date and time is in MSDOS format.
  148.  */
  149.  
  150. int
  151. setutime(path, date, time)
  152. char           *path;
  153. unsigned int    date,
  154.         time;
  155. {
  156.     struct DateStamp DateStamp;
  157.     extern int SetFileDate PARMS((char *file, struct DateStamp * date));
  158.  
  159.     ToDateStamp(&DateStamp, date, time);
  160.  
  161.     return !SetFileDate(path, &DateStamp);
  162. }
  163.  
  164. #ifdef AZTEC_C
  165. # ifndef  EXEC_MEMORY_H
  166. #    include <exec/memory.h>
  167. # endif
  168. # ifndef ACTION_SET_DATE
  169. #    define ACTION_SET_DATE        34L
  170. # endif
  171.  
  172. int
  173. SetFileDate(path, date)
  174. char           *path;
  175. struct DateStamp *date;
  176. {
  177.     struct MsgPort *task;
  178.     BPTR        lock,
  179.             plock;
  180.     UBYTE       *bcplstring;
  181.     int         result;
  182.  
  183.     if (!(bcplstring = (UBYTE *) AllocMem(64L, (long) MEMF_PUBLIC)))
  184.     return 0;
  185.     result = 0;
  186.     if (!(task = DeviceProc(path))) {
  187.     goto abort;
  188.     }
  189.     if (!(lock = Lock(path, SHARED_LOCK))) {
  190.     goto abort;
  191.     }
  192.     plock = ParentDir(lock);
  193.     UnLock(lock);
  194.  
  195.     /* Strip pathnames first */
  196.     strcpy((char *) (bcplstring + 1), nameptr(path));
  197.     *bcplstring = strlen((char *) (bcplstring + 1));
  198.  
  199.     result = dos_packet(task, ACTION_SET_DATE, NULL, plock,
  200.               (ULONG) bcplstring >> 2, (ULONG) date, 0L, 0L, 0L);
  201.  
  202.     UnLock(plock);
  203. abort:
  204.     FreeMem((void *) bcplstring, 64L);
  205.     return result;
  206. }
  207.  
  208. #endif
  209.  
  210.  
  211. /* No standard UNIX-specific file attribute routines */
  212.  
  213. /*
  214.  * Get file attributes.  Currently only the lowest nine of the *IX mode
  215.  * bits are used.  Also we return bit 23=0 and bit 22=1, which means use
  216.  * portable attribute format, and use attribute value instead of using
  217.  * default at extraction time.
  218.  */
  219.  
  220. unsigned long
  221. getfattr(f)
  222. ZOOFILE     f;
  223. {
  224.     return NO_FATTR;        /* inaccessible -- no attributes */
  225. }
  226.  
  227. /*
  228.  * Set file attributes.  Only the lowest nine bits are used.
  229.  */
  230.  
  231. int
  232. setfattr(f, a)
  233. char           *f;        /* filename */
  234. unsigned long    a;        /* atributes to set */
  235. {
  236.     return 0;            /* cannot do */
  237. }
  238.  
  239. int
  240. iswild(name)
  241. char           *name;
  242. {
  243.     return (strchr(name, '*') != NULL) || (strchr(name, '?') != NULL);
  244. }
  245.  
  246. #define FMAX    3        /* Number of different filename patterns */
  247.  
  248.  
  249. /* #include "various.h" */
  250. /* #include "zoo.h" *//* solely to define PATHSIZE */
  251.  
  252. #ifdef SPECNEXT
  253. /*-
  254.  
  255. nextfile() returns the name of the next source file matching a filespec.
  256.  
  257. INPUT
  258.    what: A flag specifying what to do. If "what" is 0, nextfile()
  259.       initializes itself.     If "what" is 1, nextfile() returns the next
  260.       matching filename.
  261.    filespec:  The filespec, usually containing wildcard characters, that
  262.       specifies which files are needed.  If "what" is 0, filespec must be
  263.       the filespec for which matching filenames are needed.  If "what" is 1,
  264.       nextfile() does not use "filespec" and "filespec" should be NULL to
  265.       avoid an assertion error during debugging.
  266.    fileset:  nextfile() can keep track of more than one set of filespecs.
  267.       The fileset specifies which filespec is being matched and therefore
  268.       which set of files is being considered.  "fileset" can be in the
  269.       range 0:FMAX.   Initialization of one fileset does not affect the
  270.       other filesets.
  271.  
  272. OUTPUT
  273.    IF what == 0 THEN
  274.       return value is NULL
  275.    ELSE IF what == 1 THEN
  276.       IF a matching filename is found THEN
  277.      return value is pointer to matching filename including supplied path
  278.       ELSE
  279.      IF at least one file matched previously but no more match THEN
  280.         return value is NULL
  281.      ELSE IF supplied filespec never matched any filename THEN
  282.         IF this is the first call with what == 1 THEN
  283.            return value is pointer to original filespec
  284.         ELSE
  285.         return value is NULL
  286.         END IF
  287.      END IF
  288.        END IF
  289.    END IF
  290.  
  291. NOTE
  292.  
  293.    Initialization done when "what"=0 is not dependent on the correctness
  294.    of the supplied filespec but simply initializes internal variables
  295.    and makes a local copy of the supplied filespec.  If the supplied
  296.    filespec was illegal, the only effect is that the first time that
  297.    nextfile() is called with "what"=1, it will return the original
  298.    filespec instead of a matching filename.       That the filespec was
  299.    illegal will become obvious when the caller attempts to open the
  300.    returned filename for input/output and the open attempt fails.
  301.  
  302. USAGE HINTS
  303.  
  304. nextfile() can be used in the following manner:
  305.  
  306.       char *filespec;              -- will point to filespec
  307.       char *this_file;              -- will point to matching filename
  308.       filespec = parse_command_line();    -- may contain wildcards
  309.       FILE *stream;
  310.  
  311.       nextfile (0, filespec, 0);          -- initialize fileset 0
  312.       while ((this_file = nextfile(1, (char *) NULL, 0)) != NULL) {
  313.      stream = fopen (this_file, "whatever");
  314.      if (stream == NULL)
  315.         printf ("could not open %s\n", this_file);
  316.      else
  317.          perform_operations (stream);
  318.       }
  319. */
  320.  
  321. static int    first_time[FMAX + 1];
  322. static BPTR    filelock[FMAX + 1];
  323. static struct FileInfoBlock *fib[FMAX + 1];
  324.  
  325. char           *
  326. nextfile(what, filespec, fileset)
  327. int        what;        /* whether to initialize or match     */
  328. register char  *filespec;    /* filespec to match if initializing     */
  329. register int    fileset;    /* which set of files             */
  330. {
  331.     static char     pathholder[FMAX + 1][PATHSIZE];    /* holds a pathname to
  332.                              * return */