home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / pbmplus / libtiff / tif_apple.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-28  |  5.3 KB  |  224 lines  |  [TEXT/CWIE]
  1. #ifndef lint
  2. static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_apple.c,v 1.13 93/08/25 09:15:36 sam Exp $";
  3. #endif
  4.  
  5. /*
  6.  * Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
  7.  * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
  8.  *
  9.  * Permission to use, copy, modify, distribute, and sell this software and 
  10.  * its documentation for any purpose is hereby granted without fee, provided
  11.  * that (i) the above copyright notices and this permission notice appear in
  12.  * all copies of the software and related documentation, and (ii) the names of
  13.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  14.  * publicity relating to the software without the specific, prior written
  15.  * permission of Sam Leffler and Silicon Graphics.
  16.  * 
  17.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  18.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  19.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  20.  * 
  21.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  25.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  26.  * OF THIS SOFTWARE.
  27.  */
  28.  
  29. /*
  30.  * TIFF Library Macintosh-specific routines.
  31.  *
  32.  * These routines use only Toolbox and high-level File Manager traps.
  33.  * They make no calls to the THINK C "unix" compatibility library.  Also,
  34.  * malloc is not used directly but it is still referenced internally by
  35.  * the ANSI library in rare cases.  Heap fragmentation by the malloc ring
  36.  * buffer is therefore minimized.
  37.  *
  38.  * O_RDONLY and O_RDWR are treated identically here.  The tif_mode flag is
  39.  * checked in TIFFWriteCheck().
  40.  *
  41.  * Create below fills in a blank creator signature and sets the file type
  42.  * to 'TIFF'.  It is much better for the application to do this by Create'ing
  43.  * the file first and TIFFOpen'ing it later.
  44.  */
  45.  
  46. #include "tiffiop.h"
  47. #include <Errors.h>
  48. #include <Files.h>
  49. #include <Memory.h>
  50.  
  51. #ifdef __MWERKS__
  52. #include <Strings.h>
  53. #endif
  54.  
  55. #if defined(applec) || defined(__MWERKS__)
  56. #define    CtoPstr    c2pstr
  57. #endif
  58.  
  59. static tsize_t
  60. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  61. {
  62.     return (FSRead((short) fd, (long*) &size, (char*) buf) == noErr ?
  63.         size : (tsize_t) -1);
  64. }
  65.  
  66. static tsize_t
  67. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  68. {
  69.     return (FSWrite((short) fd, (long*) &size, (char*) buf) == noErr ?
  70.         size : (tsize_t) -1);
  71. }
  72.  
  73. static toff_t
  74. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  75. {
  76.     long fpos, size;
  77.  
  78.     if (GetEOF((short) fd, &size) != noErr)
  79.         return EOF;
  80.     (void) GetFPos((short) fd, &fpos);
  81.  
  82.     switch (whence) {
  83.     case SEEK_CUR:
  84.         if (off + fpos > size)
  85.             SetEOF((short) fd, off + fpos);
  86.         if (SetFPos((short) fd, fsFromMark, off) != noErr)
  87.             return EOF;
  88.         break;
  89.     case SEEK_END:
  90.         if (off > 0)
  91.             SetEOF((short) fd, off + size);
  92.         if (SetFPos((short) fd, fsFromStart, off + size) != noErr)
  93.             return EOF;
  94.         break;
  95.     case SEEK_SET:
  96.         if (off > size)
  97.             SetEOF((short) fd, off);
  98.         if (SetFPos((short) fd, fsFromStart, off) != noErr)
  99.             return EOF;
  100.         break;
  101.     }
  102.  
  103.     return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF);
  104. }
  105.  
  106. static int
  107. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  108. {
  109.     return (0);
  110. }
  111.  
  112. static void
  113. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  114. {
  115. }
  116.  
  117. static int
  118. _tiffCloseProc(thandle_t fd)
  119. {
  120.     return (FSClose((short) fd));
  121. }
  122.  
  123. static toff_t
  124. _tiffSizeProc(thandle_t fd)
  125. {
  126.     long size;
  127.  
  128.     if (GetEOF((short) fd, &size) != noErr) {
  129.         TIFFError("_tiffSizeProc", "%s: Cannot get file size");
  130.         return (-1L);
  131.     }
  132.     return ((toff_t) size);
  133. }
  134.  
  135. void *
  136. _TIFFmalloc(size_t s)
  137. {
  138.     return (NewPtr(s));
  139. }
  140.  
  141. void
  142. _TIFFfree(void* p)
  143. {
  144.     DisposePtr(p);
  145. }
  146.  
  147. void *
  148. _TIFFrealloc(void* p, size_t s)
  149. {
  150.     Ptr n = p;
  151.  
  152.     SetPtrSize(p, s);
  153.     if (MemError() && (n = NewPtr(s)) != NULL) {
  154.         BlockMove(p, n, GetPtrSize(p));
  155.         DisposePtr(p);
  156.     }
  157.     return (n);
  158. }
  159.  
  160. /*
  161.  * Open a TIFF file descriptor for read/writing.
  162.  */
  163. TIFF*
  164. TIFFFdOpen(int fd, const char* name, const char* mode)
  165. {
  166.     TIFF* tif;
  167.  
  168.     tif = TIFFClientOpen(name, mode, (thandle_t) fd,
  169.         _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
  170.         _tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
  171.     if (tif)
  172.         tif->tif_fd = fd;
  173.     return (tif);
  174. }
  175.  
  176. /*
  177.  * Open a TIFF file for read/writing.
  178.  */
  179. TIFF*
  180. TIFFOpen(const char* name, const char* mode)
  181. {
  182.     static const char module[] = "TIFFOpen";
  183.     Str255 pname;
  184.     FInfo finfo;
  185.     short fref;
  186.     OSErr err;
  187.  
  188.     strcpy((char*) pname, name);
  189.     CtoPstr((char*) pname);
  190.  
  191.     switch (_TIFFgetMode(mode, module)) {
  192.     default:
  193.         return ((TIFF*) 0);
  194.     case O_RDWR | O_CREAT | O_TRUNC:
  195.         if (GetFInfo(pname, 0, &finfo) == noErr)
  196.             FSDelete(pname, 0);
  197.         /* fall through */
  198.     case O_RDWR | O_CREAT:
  199.         if ((err = GetFInfo(pname, 0, &finfo)) == fnfErr) {
  200.             if (Create(pname, 0, '    ', 'TIFF') != noErr)
  201.                 goto badCreate;
  202.             if (FSOpen(pname, 0, &fref) != noErr)
  203.                 goto badOpen;
  204.         } else if (err == noErr) {
  205.             if (FSOpen(pname, 0, &fref) != noErr)
  206.                 goto badOpen;
  207.         } else
  208.             goto badOpen;
  209.         break;
  210.     case O_RDONLY:
  211.     case O_RDWR:
  212.         if (FSOpen(pname, 0, &fref) != noErr)
  213.             goto badOpen;
  214.         break;
  215.     }
  216.     return (TIFFFdOpen((int) fref, name, mode));
  217. badCreate:
  218.     TIFFError(module, "%s: Cannot create", name);
  219.     return ((TIFF*) 0);
  220. badOpen:
  221.     TIFFError(module, "%s: Cannot open", name);
  222.     return ((TIFF*) 0);
  223. }
  224.