/src/FreeImage/Source/LibTIFF/tif_msdos.c

https://bitbucket.org/cabalistic/ogredeps/ · C · 193 lines · 127 code · 26 blank · 40 comment · 12 complexity · 8d26eb7bf0f6707d12e1f842811c7e7f MD5 · raw file

  1. /* $Header: /cvsroot/freeimage/FreeImage/Source/LibTIFF/tif_msdos.c,v 1.35 2011/04/10 17:14:09 drolon Exp $ */
  2. /*
  3. * Copyright (c) 1988-1997 Sam Leffler
  4. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  5. *
  6. * Permission to use, copy, modify, distribute, and sell this software and
  7. * its documentation for any purpose is hereby granted without fee, provided
  8. * that (i) the above copyright notices and this permission notice appear in
  9. * all copies of the software and related documentation, and (ii) the names of
  10. * Sam Leffler and Silicon Graphics may not be used in any advertising or
  11. * publicity relating to the software without the specific, prior written
  12. * permission of Sam Leffler and Silicon Graphics.
  13. *
  14. * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  15. * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  16. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  17. *
  18. * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  19. * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  20. * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21. * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  22. * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  23. * OF THIS SOFTWARE.
  24. */
  25. /*
  26. * TIFF Library MSDOS-specific Routines.
  27. */
  28. #if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER)
  29. #include <io.h> /* for open, close, etc. function prototypes */
  30. #include <stdio.h>
  31. #endif
  32. #include "tiffiop.h"
  33. static tsize_t
  34. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  35. {
  36. return (read((int) fd, buf, size));
  37. }
  38. static tsize_t
  39. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  40. {
  41. return (write((int) fd, buf, size));
  42. }
  43. static toff_t
  44. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  45. {
  46. return (lseek((int) fd, (off_t) off, whence));
  47. }
  48. static int
  49. _tiffCloseProc(thandle_t fd)
  50. {
  51. return (close((int) fd));
  52. }
  53. #include <sys/stat.h>
  54. static toff_t
  55. _tiffSizeProc(thandle_t fd)
  56. {
  57. struct stat sb;
  58. return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
  59. }
  60. static int
  61. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  62. {
  63. return (0);
  64. }
  65. static void
  66. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  67. {
  68. }
  69. /*
  70. * Open a TIFF file descriptor for read/writing.
  71. */
  72. TIFF*
  73. TIFFFdOpen(int fd, const char* name, const char* mode)
  74. {
  75. TIFF* tif;
  76. tif = TIFFClientOpen(name, mode,
  77. (void*) fd,
  78. _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
  79. _tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
  80. if (tif)
  81. tif->tif_fd = fd;
  82. return (tif);
  83. }
  84. /*
  85. * Open a TIFF file for read/writing.
  86. */
  87. TIFF*
  88. TIFFOpen(const char* name, const char* mode)
  89. {
  90. static const char module[] = "TIFFOpen";
  91. int m, fd;
  92. TIFF *ret;
  93. m = _TIFFgetMode(mode, module);
  94. if (m == -1)
  95. return ((TIFF*)0);
  96. fd = open(name, m|O_BINARY, 0666);
  97. if (fd < 0) {
  98. TIFFErrorExt(0, module, "%s: Cannot open", name);
  99. return ((TIFF*)0);
  100. }
  101. return (TIFFFdOpen(fd, name, mode));
  102. ret = TIFFFdOpen(fd, name, mode);
  103. if (ret == NULL) close(fd);
  104. return ret;
  105. }
  106. #ifdef __GNUC__
  107. extern char* malloc();
  108. extern char* realloc();
  109. #else
  110. #include <malloc.h>
  111. #endif
  112. tdata_t
  113. _TIFFmalloc(tsize_t s)
  114. {
  115. return (malloc((size_t) s));
  116. }
  117. void
  118. _TIFFfree(tdata_t p)
  119. {
  120. free(p);
  121. }
  122. tdata_t
  123. _TIFFrealloc(tdata_t p, tsize_t s)
  124. {
  125. return (realloc(p, (size_t) s));
  126. }
  127. void
  128. _TIFFmemset(tdata_t p, int v, tsize_t c)
  129. {
  130. memset(p, v, (size_t) c);
  131. }
  132. void
  133. _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
  134. {
  135. memcpy(d, s, (size_t) c);
  136. }
  137. int
  138. _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
  139. {
  140. return (memcmp(p1, p2, (size_t) c));
  141. }
  142. static void
  143. msdosWarningHandler(const char* module, const char* fmt, va_list ap)
  144. {
  145. if (module != NULL)
  146. fprintf(stderr, "%s: ", module);
  147. fprintf(stderr, "Warning, ");
  148. vfprintf(stderr, fmt, ap);
  149. fprintf(stderr, ".\n");
  150. }
  151. TIFFErrorHandler _TIFFwarningHandler = msdosWarningHandler;
  152. static void
  153. msdosErrorHandler(const char* module, const char* fmt, va_list ap)
  154. {
  155. if (module != NULL)
  156. fprintf(stderr, "%s: ", module);
  157. vfprintf(stderr, fmt, ap);
  158. fprintf(stderr, ".\n");
  159. }
  160. TIFFErrorHandler _TIFFerrorHandler = msdosErrorHandler;
  161. /*
  162. * Local Variables:
  163. * mode: c
  164. * c-basic-offset: 8
  165. * fill-column: 78
  166. * End:
  167. */