cheng/libtiff
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Obsoleted portability stuff removed.

Browse Source
This commit is contained in:
Andrey Kiselev 2007-07-03 16:05:49 +00:00
parent 1c81bc514c
commit 47588d8839
6 changed files with 0 additions and 1477 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libtiff/Makefile.am
View File

@ -94,12 +94,7 @@ SRCSXX = \
tif_stream.cxx
EXTRA_SRCS = \
tif_acorn.c \
tif_apple.c \
tif_atari.c \
tif_msdos.c \
tif_next.c \
tif_win3.c \
tif_win32.c
libtiffincludedir = $(includedir)

524
libtiff/tif_acorn.c
View File

@ -1,524 +0,0 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/Attic/tif_acorn.c,v 1.4 2007-06-26 10:41:27 joris Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library RISC OS specific Routines.
* Developed out of the Unix version.
* Peter Greenham, May 1995
*/
#include "tiffiop.h"
#include <stdio.h>
#include <stdlib.h>
/*
Low-level file handling
~~~~~~~~~~~~~~~~~~~~~~~
The functions in osfcn.h are unavailable when compiling under C, as it's a
C++ header. Therefore they have been implemented here.
Now, why have I done it this way?
The definitive API library for RISC OS is Jonathan Coxhead's OSLib, which
uses heavily optimised ARM assembler or even plain inline SWI calls for
maximum performance and minimum runtime size. However, I don't want to make
LIBTIFF need that to survive. Therefore I have also emulated the functions
using macros to _swi() and _swix() defined in the swis.h header, and
borrowing types from kernel.h, which is less efficient but doesn't need any
third-party libraries.
*/
COMPILATION SHOULD FAIL
This file is not yet updated to reflect changes in LibTiff 4.0. If you have
the opportunity to update and test this file, please contact LibTiff folks
for all assistance you may require and contribute the results
#ifdef INCLUDE_OSLIB
#include "osfile.h"
#include "osgbpb.h"
#include "osargs.h"
#include "osfind.h"
#else
/* OSLIB EMULATION STARTS */
#include "kernel.h"
#include "swis.h"
/* From oslib:types.h */
typedef unsigned int bits;
typedef unsigned char byte;
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#ifndef NULL
#define NULL 0
#endif
#ifndef SKIP
#define SKIP 0
#endif
/* From oslib:os.h */
typedef _kernel_oserror os_error;
typedef byte os_f;
/* From oslib:osfile.h */
#undef OS_File
#define OS_File 0x8
/* From oslib:osgbpb.h */
#undef OS_GBPB
#define OS_GBPB 0xC
#undef OSGBPB_Write
#define OSGBPB_Write 0x2
#undef OSGBPB_Read
#define OSGBPB_Read 0x4
extern os_error *xosgbpb_write (os_f file,
byte *data,
int size,
int *unwritten);
extern int osgbpb_write (os_f file,
byte *data,
int size);
#define xosgbpb_write(file, data, size, unwritten) \
(os_error*) _swix(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_IN(4)|_OUT(3), \
OSGBPB_WriteAt, \
file, \
data, \
size, \
unwritten)
#define osgbpb_write(file, data, size) \
_swi(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_RETURN(3), \
OSGBPB_Write, \
file, \
data, \
size)
extern os_error *xosgbpb_read (os_f file,
byte *buffer,
int size,
int *unread);
extern int osgbpb_read (os_f file,
byte *buffer,
int size);
#define xosgbpb_read(file, buffer, size, unread) \
(os_error*) _swix(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_OUT(3), \
OSGBPB_Read, \
file, \
buffer, \
size, \
unread)
#define osgbpb_read(file, buffer, size) \
_swi(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_RETURN(3), \
OSGBPB_Read, \
file, \
buffer, \
size)
/* From oslib:osfind.h */
#undef OS_Find
#define OS_Find 0xD
#undef OSFind_Openin
#define OSFind_Openin 0x40
#undef OSFind_Openout
#define OSFind_Openout 0x80
#undef OSFind_Openup
#define OSFind_Openup 0xC0
#undef OSFind_Close
#define OSFind_Close 0x0
#define xosfind_open(reason, file_name, path, file) \
(os_error*) _swix(OS_Find, _IN(0)|_IN(1)|_IN(2)|_OUT(0), \
reason, file_name, path, file)
#define osfind_open(reason, file_name, path) \
(os_f) _swi(OS_Find, _IN(0)|_IN(1)|_IN(2)|_RETURN(0), \
reason, file_name, path)
extern os_error *xosfind_openin (bits flags,
char *file_name,
char *path,
os_f *file);
extern os_f osfind_openin (bits flags,
char *file_name,
char *path);
#define xosfind_openin(flags, file_name, path, file) \
xosfind_open(flags | OSFind_Openin, file_name, path, file)
#define osfind_openin(flags, file_name, path) \
osfind_open(flags | OSFind_Openin, file_name, path)
extern os_error *xosfind_openout (bits flags,
char *file_name,
char *path,
os_f *file);
extern os_f osfind_openout (bits flags,
char *file_name,
char *path);
#define xosfind_openout(flags, file_name, path, file) \
xosfind_open(flags | OSFind_Openout, file_name, path, file)
#define osfind_openout(flags, file_name, path) \
osfind_open(flags | OSFind_Openout, file_name, path)
extern os_error *xosfind_openup (bits flags,
char *file_name,
char *path,
os_f *file);
extern os_f osfind_openup (bits flags,
char *file_name,
char *path);
#define xosfind_openup(flags, file_name, path, file) \
xosfind_open(flags | OSFind_Openup, file_name, path, file)
#define osfind_openup(flags, file_name, path) \
osfind_open(flags | OSFind_Openup, file_name, path)
extern os_error *xosfind_close (os_f file);
extern void osfind_close (os_f file);
#define xosfind_close(file) \
(os_error*) _swix(OS_Find, _IN(0)|_IN(1), \
OSFind_Close, \
file)
#define osfind_close(file) \
(void) _swi(OS_Find, _IN(0)|_IN(1), \
OSFind_Close, \
file)
/* From oslib:osargs.h */
#undef OS_Args
#define OS_Args 0x9
#undef OSArgs_ReadPtr
#define OSArgs_ReadPtr 0x0
#undef OSArgs_SetPtr
#define OSArgs_SetPtr 0x1
#undef OSArgs_ReadExt
#define OSArgs_ReadExt 0x2
extern os_error *xosargs_read_ptr (os_f file,
int *ptr);
extern int osargs_read_ptr (os_f file);
#define xosargs_read_ptr(file, ptr) \
(os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_OUT(2), \
OSArgs_ReadPtr, \
file, \
ptr)
#define osargs_read_ptr(file) \
_swi(OS_Args, _IN(0)|_IN(1)|_RETURN(2), \
OSArgs_ReadPtr, \
file)
extern os_error *xosargs_set_ptr (os_f file,
int ptr);
extern void osargs_set_ptr (os_f file,
int ptr);
#define xosargs_set_ptr(file, ptr) \
(os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_IN(2), \
OSArgs_SetPtr, \
file, \
ptr)
#define osargs_set_ptr(file, ptr) \
(void) _swi(OS_Args, _IN(0)|_IN(1)|_IN(2), \
OSArgs_SetPtr, \
file, \
ptr)
extern os_error *xosargs_read_ext (os_f file,
int *ext);
extern int osargs_read_ext (os_f file);
#define xosargs_read_ext(file, ext) \
(os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_OUT(2), \
OSArgs_ReadExt, \
file, \
ext)
#define osargs_read_ext(file) \
_swi(OS_Args, _IN(0)|_IN(1)|_RETURN(2), \
OSArgs_ReadExt, \
file)
/* OSLIB EMULATION ENDS */
#endif
#ifndef __osfcn_h
/* Will be set or not during tiffcomp.h */
/* You get this to compile under C++? Please say how! */
extern int open(const char* name, int flags, int mode)
{
/* From what I can tell, should return <0 for failure */
os_error* e = (os_error*) 1; /* Cheeky way to use a pointer eh? :-) */
os_f file = (os_f) -1;
flags = flags;
switch(mode)
{
case O_RDONLY:
{
e = xosfind_openin(SKIP, name, SKIP, &file);
break;
}
case O_WRONLY:
case O_RDWR|O_CREAT:
case O_RDWR|O_CREAT|O_TRUNC:
{
e = xosfind_openout(SKIP, name, SKIP, &file);
break;
}
case O_RDWR:
{
e = xosfind_openup(SKIP, name, SKIP, &file);
break;
}
}
if (e)
{
file = (os_f) -1;
}
return (file);
}
extern int close(int fd)
{
return ((int) xosfind_close((os_f) fd));
}
extern int write(int fd, const char *buf, int nbytes)
{
/* Returns number of bytes written */
return (nbytes - osgbpb_write((os_f) fd, (const byte*) buf, nbytes));
}
extern int read(int fd, char *buf, int nbytes)
{
/* Returns number of bytes read */
return (nbytes - osgbpb_read((os_f) fd, (byte*) buf, nbytes));
}
extern off_t lseek(int fd, off_t offset, int whence)
{
int absolute = 0;
switch (whence)
{
case SEEK_SET:
{
absolute = (int) offset;
break;
}
case SEEK_CUR:
{
absolute = osargs_read_ptr((os_f) fd) + (int) offset;
break;
}
case SEEK_END:
{
absolute = osargs_read_ext((os_f) fd) + (int) offset;
break;
}
}
osargs_set_ptr((os_f) fd, absolute);
return ((off_t) osargs_read_ptr((os_f) fd));
}
#endif
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return ((tsize_t) read((int) fd, buf, (size_t) size));
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return ((tsize_t) write((int) fd, buf, (size_t) size));
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
return ((toff_t) lseek((int) fd, (off_t) off, whence));
}
static int
_tiffCloseProc(thandle_t fd)
{
return (close((int) fd));
}
static toff_t
_tiffSizeProc(thandle_t fd)
{
return (lseek((int) fd, SEEK_END, SEEK_SET));
}
#ifdef HAVE_MMAP
#error "I didn't know Acorn had that!"
#endif
/* !HAVE_MMAP */
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
(void) fd; (void) pbase; (void) psize;
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
(void) fd; (void) base; (void) size;
}
/*
* Open a TIFF file descriptor for read/writing.
*/
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
TIFF* tif;
tif = TIFFClientOpen(name, mode, ddd
(thandle_t) fd,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc);
if (tif)
{
tif->tif_fd = fd;
}
return (tif);
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int m, fd;
m = _TIFFgetMode(mode, module);
if (m == -1)
{
return ((TIFF*) 0);
}
fd = open(name, 0, m);
if (fd < 0)
{
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF *)0);
}
return (TIFFFdOpen(fd, name, mode));
}
void*
_TIFFmalloc(tsize_t s)
{
return (malloc((size_t) s));
}
void
_TIFFfree(tdata_t p)
{
free(p);
}
void*
_TIFFrealloc(tdata_t p, tsize_t s)
{
return (realloc(p, (size_t) s));
}
void
_TIFFmemset(tdata_t p, int v, tsize_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
static void
acornWarningHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
{
fprintf(stderr, "%s: ", module);
}
fprintf(stderr, "Warning, ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFwarningHandler = acornWarningHandler;
static void
acornErrorHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
{
fprintf(stderr, "%s: ", module);
}
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFerrorHandler = acornErrorHandler;

279
libtiff/tif_apple.c
View File

@ -1,279 +0,0 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/Attic/tif_apple.c,v 1.5 2007-06-26 10:41:28 joris Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library Macintosh-specific routines.
*
* These routines use only Toolbox and high-level File Manager traps.
* They make no calls to the THINK C "unix" compatibility library. Also,
* malloc is not used directly but it is still referenced internally by
* the ANSI library in rare cases. Heap fragmentation by the malloc ring
* buffer is therefore minimized.
*
* O_RDONLY and O_RDWR are treated identically here. The tif_mode flag is
* checked in TIFFWriteCheck().
*
* Create below fills in a blank creator signature and sets the file type
* to 'TIFF'. It is much better for the application to do this by Create'ing
* the file first and TIFFOpen'ing it later.
* ---------
* This code has been "Carbonized", and may not work with older MacOS versions.
* If so, grab the tif_apple.c out of an older libtiff distribution, like
* 3.5.5 from www.libtiff.org.
*/
#include "tiffiop.h"
#include <Errors.h>
#include <Files.h>
#include <Memory.h>
#include <Script.h>
#if defined(__PPCC__) || defined(__SC__) || defined(__MRC__) || defined(applec)
#define CtoPstr c2pstr
#endif
COMPILATION SHOULD FAIL
This file is not yet updated to reflect changes in LibTiff 4.0. If you have
the opportunity to update and test this file, please contact LibTiff folks
for all assistance you may require and contribute the results
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (FSRead((short) fd, (long*) &size, (char*) buf) == noErr ?
size : (tsize_t) -1);
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (FSWrite((short) fd, (long*) &size, (char*) buf) == noErr ?
size : (tsize_t) -1);
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
long fpos, size;
if (GetEOF((short) fd, &size) != noErr)
return EOF;
(void) GetFPos((short) fd, &fpos);
switch (whence) {
case SEEK_CUR:
if (off + fpos > size)
SetEOF((short) fd, off + fpos);
if (SetFPos((short) fd, fsFromMark, off) != noErr)
return EOF;
break;
case SEEK_END:
if (off > 0)
SetEOF((short) fd, off + size);
if (SetFPos((short) fd, fsFromStart, off + size) != noErr)
return EOF;
break;
case SEEK_SET:
if (off > size)
SetEOF((short) fd, off);
if (SetFPos((short) fd, fsFromStart, off) != noErr)
return EOF;
break;
}
return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF);
}
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
}
static int
_tiffCloseProc(thandle_t fd)
{
return (FSClose((short) fd));
}
static toff_t
_tiffSizeProc(thandle_t fd)
{
long size;
if (GetEOF((short) fd, &size) != noErr) {
TIFFErrorExt(fd, "_tiffSizeProc", "%s: Cannot get file size");
return (-1L);
}
return ((toff_t) size);
}
/*
* Open a TIFF file descriptor for read/writing.
*/
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
TIFF* tif;
tif = TIFFClientOpen(name, mode, (thandle_t) fd, ddd
_tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
_tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
if (tif)
tif->tif_fd = fd;
return (tif);
}
static void ourc2pstr( char* inString )
{
int sLen = strlen( inString );
BlockMoveData( inString, &inString[1], sLen );
inString[0] = sLen;
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
Str255 pname;
FInfo finfo;
short fref;
OSErr err;
FSSpec fSpec;
strcpy((char*) pname, name);
ourc2pstr((char*) pname);
err = FSMakeFSSpec( 0, 0, pname, &fSpec );
switch (_TIFFgetMode(mode, module)) {
default:
return ((TIFF*) 0);
case O_RDWR | O_CREAT | O_TRUNC:
if (FSpGetFInfo(&fSpec, &finfo) == noErr)
FSpDelete(&fSpec);
/* fall through */
case O_RDWR | O_CREAT:
if ((err = FSpGetFInfo(&fSpec, &finfo)) == fnfErr) {
if (FSpCreate(&fSpec, ' ', 'TIFF', smSystemScript) != noErr)
goto badCreate;
if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr)
goto badOpen;
} else if (err == noErr) {
if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr)
goto badOpen;
} else
goto badOpen;
break;
case O_RDONLY:
if (FSpOpenDF(&fSpec, fsRdPerm, &fref) != noErr)
goto badOpen;
break;
case O_RDWR:
if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr)
goto badOpen;
break;
}
return (TIFFFdOpen((int) fref, name, mode));
badCreate:
TIFFErrorExt(0, module, "%s: Cannot create", name);
return ((TIFF*) 0);
badOpen:
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF*) 0);
}
void
_TIFFmemset(tdata_t p, int v, tsize_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
tdata_t
_TIFFmalloc(tsize_t s)
{
return (NewPtr((size_t) s));
}
void
_TIFFfree(tdata_t p)
{
DisposePtr(p);
}
tdata_t
_TIFFrealloc(tdata_t p, tsize_t s)
{
Ptr n = p;
SetPtrSize(p, (size_t) s);
if (MemError() && (n = NewPtr((size_t) s)) != NULL) {
BlockMove(p, n, GetPtrSize(p));
DisposePtr(p);
}
return ((tdata_t) n);
}
static void
appleWarningHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
fprintf(stderr, "Warning, ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFwarningHandler = appleWarningHandler;
static void
appleErrorHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFerrorHandler = appleErrorHandler;

248
libtiff/tif_atari.c
View File

@ -1,248 +0,0 @@
/* "$Header: /cvs/maptools/cvsroot/libtiff/libtiff/Attic/tif_atari.c,v 1.4 2007-06-26 10:41:28 joris Exp $" */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library ATARI-specific Routines.
*/
#include "tiffiop.h"
#if defined(__TURBOC__)
#include <tos.h>
#include <stdio.h>
#else
#include <osbind.h>
#include <fcntl.h>
#endif
#ifndef O_ACCMODE
#define O_ACCMODE 3
#endif
#include <errno.h>
#define AEFILNF -33
COMPILATION SHOULD FAIL
This file is not yet updated to reflect changes in LibTiff 4.0. If you have
the opportunity to update and test this file, please contact LibTiff folks
for all assistance you may require and contribute the results
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
long r;
r = Fread((int) fd, size, buf);
if (r < 0) {
errno = (int)-r;
r = -1;
}
return r;
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
long r;
r = Fwrite((int) fd, size, buf);
if (r < 0) {
errno = (int)-r;
r = -1;
}
return r;
}
static toff_t
_tiffSeekProc(thandle_t fd, off_t off, int whence)
{
char buf[256];
long current_off, expected_off, new_off;
if (whence == SEEK_END || off <= 0)
return Fseek(off, (int) fd, whence);
current_off = Fseek(0, (int) fd, SEEK_CUR); /* find out where we are */
if (whence == SEEK_SET)
expected_off = off;
else
expected_off = off + current_off;
new_off = Fseek(off, (int) fd, whence);
if (new_off == expected_off)
return new_off;
/* otherwise extend file -- zero filling the hole */
if (new_off < 0) /* error? */
new_off = Fseek(0, (int) fd, SEEK_END); /* go to eof */
_TIFFmemset(buf, 0, sizeof(buf));
while (expected_off > new_off) {
off = expected_off - new_off;
if (off > sizeof(buf))
off = sizeof(buf);
if ((current_off = Fwrite((int) fd, off, buf)) != off)
return (current_off > 0) ?
new_off + current_off : new_off;
new_off += off;
}
return new_off;
}
static int
_tiffCloseProc(thandle_t fd)
{
long r;
r = Fclose((int) fd);
if (r < 0) {
errno = (int)-r;
r = -1;
}
return (int)r;
}
static toff_t
_tiffSizeProc(thandle_t fd)
{
long pos, eof;
pos = Fseek(0, (int) fd, SEEK_CUR);
eof = Fseek(0, (int) fd, SEEK_END);
Fseek(pos, (int) fd, SEEK_SET);
return eof;
}
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
}
/*
* Open a TIFF file descriptor for read/writing.
*/
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
TIFF* tif;
tif = TIFFClientOpen(name, mode, ddd
(thandle_t) fd,
_tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
_tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
if (tif)
tif->tif_fd = fd;
return (tif);
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int m;
long fd;
m = _TIFFgetMode(mode, module);
if (m == -1)
return ((TIFF*)0);
if (m & O_TRUNC) {
fd = Fcreate(name, 0);
} else {
fd = Fopen(name, m & O_ACCMODE);
if (fd == AEFILNF && m & O_CREAT)
fd = Fcreate(name, 0);
}
if (fd < 0)
errno = (int)fd;
if (fd < 0) {
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF*)0);
}
return (TIFFFdOpen(fd, name, mode));
}
#include <stdlib.h>
tdata_t
_TIFFmalloc(tsize_t s)
{
return (malloc((size_t) s));
}
void
_TIFFfree(tdata_t p)
{
free(p);
}
tdata_t
_TIFFrealloc(tdata_t p, tsize_t s)
{
return (realloc(p, (size_t) s));
}
void
_TIFFmemset(tdata_t p, int v, size_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, size_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
static void
atariWarningHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
fprintf(stderr, "Warning, ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFwarningHandler = atariWarningHandler;
static void
atariErrorHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFerrorHandler = atariErrorHandler;

191
libtiff/tif_msdos.c
View File

@ -1,191 +0,0 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/Attic/tif_msdos.c,v 1.5 2007-06-26 10:41:28 joris Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library MSDOS-specific Routines.
*/
#if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER)
#include <io.h> /* for open, close, etc. function prototypes */
#include <stdio.h>
#endif
#include "tiffiop.h"
COMPILATION SHOULD FAIL
This file is not yet updated to reflect changes in LibTiff 4.0. If you have
the opportunity to update and test this file, please contact LibTiff folks
for all assistance you may require and contribute the results
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (read((int) fd, buf, size));
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (write((int) fd, buf, size));
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
return (lseek((int) fd, (off_t) off, whence));
}
static int
_tiffCloseProc(thandle_t fd)
{
return (close((int) fd));
}
#include <sys/stat.h>
static toff_t
_tiffSizeProc(thandle_t fd)
{
struct stat sb;
return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
}
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
}
/*
* Open a TIFF file descriptor for read/writing.
*/
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
TIFF* tif;
tif = TIFFClientOpen(name, mode, ddd
(void*) fd,
_tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
_tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
if (tif)
tif->tif_fd = fd;
return (tif);
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int m, fd;
TIFF *ret;
m = _TIFFgetMode(mode, module);
if (m == -1)
return ((TIFF*)0);
fd = open(name, m|O_BINARY, 0666);
if (fd < 0) {
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF*)0);
}
return (TIFFFdOpen(fd, name, mode));
ret = TIFFFdOpen(fd, name, mode);
if (ret == NULL) close(fd);
return ret;
}
#ifdef __GNUC__
extern char* malloc();
extern char* realloc();
#else
#include <malloc.h>
#endif
tdata_t
_TIFFmalloc(tsize_t s)
{
return (malloc((size_t) s));
}
void
_TIFFfree(tdata_t p)
{
free(p);
}
tdata_t
_TIFFrealloc(tdata_t p, tsize_t s)
{
return (realloc(p, (size_t) s));
}
void
_TIFFmemset(tdata_t p, int v, tsize_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
static void
msdosWarningHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
fprintf(stderr, "Warning, ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFwarningHandler = msdosWarningHandler;
static void
msdosErrorHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFerrorHandler = msdosErrorHandler;

230
libtiff/tif_win3.c
View File

@ -1,230 +0,0 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/Attic/tif_win3.c,v 1.4 2007-06-26 10:41:28 joris Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library Windows 3.x-specific Routines.
*/
#include "tiffiop.h"
#if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER)
#include <io.h> /* for open, close, etc. function prototypes */
#endif
#include <windows.h>
#include <windowsx.h>
#include <memory.h>
COMPILATION SHOULD FAIL
This file is not yet updated to reflect changes in LibTiff 4.0. If you have
the opportunity to update and test this file, please contact LibTiff folks
for all assistance you may require and contribute the results
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (_hread(fd, buf, size));
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (_hwrite(fd, buf, size));
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
return (_llseek(fd, (off_t) off, whence));
}
static int
_tiffCloseProc(thandle_t fd)
{
return (_lclose(fd));
}
#include <sys/stat.h>
static toff_t
_tiffSizeProc(thandle_t fd)
{
struct stat sb;
return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
}
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
}
/*
* Open a TIFF file descriptor for read/writing.
*/
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
TIFF* tif;
tif = TIFFClientOpen(name, mode, ddd
(thandle_t) fd,
_tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
_tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
if (tif)
tif->tif_fd = fd;
return (tif);
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int m, fd;
OFSTRUCT of;
int mm = 0;
m = _TIFFgetMode(mode, module);
if (m == -1)
return ((TIFF*)0);
if (m & O_CREAT) {
if ((m & O_TRUNC) || OpenFile(name, &of, OF_EXIST) != HFILE_ERROR)
mm |= OF_CREATE;
}
if (m & O_WRONLY)
mm |= OF_WRITE;
if (m & O_RDWR)
mm |= OF_READWRITE;
fd = OpenFile(name, &of, mm);
if (fd < 0) {
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF*)0);
}
return (TIFFFdOpen(fd, name, mode));
}
tdata_t
_TIFFmalloc(tsize_t s)
{
return (tdata_t) GlobalAllocPtr(GHND, (DWORD) s);
}
void
_TIFFfree(tdata_t p)
{
GlobalFreePtr(p);
}
tdata_t
_TIFFrealloc(tdata_t p, tsize_t s)
{
return (tdata_t) GlobalReAllocPtr(p, (DWORD) s, GHND);
}
void
_TIFFmemset(tdata_t p, int v, tsize_t c)
{
char* pp = (char*) p;
while (c > 0) {
tsize_t chunk = 0x10000 - ((uint32) pp & 0xffff);/* What's left in segment */
if (chunk > 0xff00) /* No more than 0xff00 */
chunk = 0xff00;
if (chunk > c) /* No more than needed */
chunk = c;
memset(pp, v, chunk);
pp = (char*) (chunk + (char huge*) pp);
c -= chunk;
}
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
{
if (c > 0xFFFF)
hmemcpy((void _huge*) d, (void _huge*) s, c);
else
(void) memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t d, const tdata_t s, tsize_t c)
{
char* dd = (char*) d;
char* ss = (char*) s;
tsize_t chunks, chunkd, chunk;
int result;
while (c > 0) {
chunks = 0x10000 - ((uint32) ss & 0xffff); /* What's left in segment */
chunkd = 0x10000 - ((uint32) dd & 0xffff); /* What's left in segment */
chunk = c; /* Get the largest of */
if (chunk > chunks) /* c, chunks, chunkd, */
chunk = chunks; /* 0xff00 */
if (chunk > chunkd)
chunk = chunkd;
if (chunk > 0xff00)
chunk = 0xff00;
result = memcmp(dd, ss, chunk);
if (result != 0)
return (result);
dd = (char*) (chunk + (char huge*) dd);
ss = (char*) (chunk + (char huge*) ss);
c -= chunk;
}
return (0);
}
static void
win3WarningHandler(const char* module, const char* fmt, va_list ap)
{
char e[512] = { '\0' };
if (module != NULL)
strcat(strcpy(e, module), ":");
vsprintf(e+strlen(e), fmt, ap);
strcat(e, ".");
MessageBox(GetActiveWindow(), e, "LibTIFF Warning",
MB_OK|MB_ICONEXCLAMATION);
}
TIFFErrorHandler _TIFFwarningHandler = win3WarningHandler;
static void
win3ErrorHandler(const char* module, const char* fmt, va_list ap)
{
char e[512] = { '\0' };
if (module != NULL)
strcat(strcpy(e, module), ":");
vsprintf(e+strlen(e), fmt, ap);
strcat(e, ".");
MessageBox(GetActiveWindow(), e, "LibTIFF Error", MB_OK|MB_ICONSTOP);
}
TIFFErrorHandler _TIFFerrorHandler = win3ErrorHandler;