expand tabs

1 files changed, 372 insertions, 372 deletions

diff --git a/contrib/mfs/mfs_file.c b/contrib/mfs/mfs_file.c
index fa408dab..53a7c4c2 100644
--- a/contrib/mfs/mfs_file.c
+++ b/contrib/mfs/mfs_file.c
@@ -1,11 +1,11 @@
 /*
 --------------------------------------------------------------------------------
--	Module		:	mem_file.c
--	Description	:	A general purpose library for manipulating a memory area
+-   Module      :   mem_file.c
+-   Description :   A general purpose library for manipulating a memory area
 -                   as if it were a file.
 -                   mfs_ stands for memory file system.
--	Author		:	Mike Johnson - Banctec AB 03/07/96
--					
+-   Author      :   Mike Johnson - Banctec AB 03/07/96
+-                   
 --------------------------------------------------------------------------------
 */
 
@@ -37,42 +37,42 @@ OF THIS SOFTWARE.
 
 /*
 --------------------------------------------------------------------------------
--	Includes
+-   Includes
 --------------------------------------------------------------------------------
 */
 
-#include	<stdio.h>
-#include	<stdlib.h>
-#include	<string.h>
+#include    <stdio.h>
+#include    <stdlib.h>
+#include    <string.h>
 
 /*
 --------------------------------------------------------------------------------
--	Definitions
+-   Definitions
 --------------------------------------------------------------------------------
 */
 
-#define	MAX_BUFFS	20
-#define FALSE 		0
-#define TRUE		1
+#define MAX_BUFFS   20
+#define FALSE       0
+#define TRUE        1
 
 /*
 --------------------------------------------------------------------------------
--	Globals
+-   Globals
 --------------------------------------------------------------------------------
 */
 
-static char *buf[MAX_BUFFS];		/* Memory for each open buf */
-static long  buf_off[MAX_BUFFS];	/* File pointer for each buf */
-static long  buf_size[MAX_BUFFS];	/* Count of bytes allocated for each buf */
-static long  fds[MAX_BUFFS];		/* File descriptor status */
-static int   buf_mode[MAX_BUFFS];	/* Mode of buffer (r, w, a) */
+static char *buf[MAX_BUFFS];        /* Memory for each open buf */
+static long  buf_off[MAX_BUFFS];    /* File pointer for each buf */
+static long  buf_size[MAX_BUFFS];   /* Count of bytes allocated for each buf */
+static long  fds[MAX_BUFFS];        /* File descriptor status */
+static int   buf_mode[MAX_BUFFS];   /* Mode of buffer (r, w, a) */
 
 static int library_init_done = FALSE;
 
 
 /*
 --------------------------------------------------------------------------------
--	Function prototypes
+-   Function prototypes
 --------------------------------------------------------------------------------
 */
 
@@ -89,491 +89,491 @@ static void mem_init ();
 
 /*
 --------------------------------------------------------------------------------
--	Function code
+-   Function code
 --------------------------------------------------------------------------------
 */
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_open ()
+-   Function    :   mfs_open ()
 -
--	Arguments	:	Pointer to allocated buffer, initial size of buffer, 
--					mode spec (r, w, a)
+-   Arguments   :   Pointer to allocated buffer, initial size of buffer, 
+-                   mode spec (r, w, a)
 -
--	Returns		:	File descriptor or -1 if error.
+-   Returns     :   File descriptor or -1 if error.
 -
--	Description	:	Register this area of memory (which has been allocated
--					and has a file read into it) under the mem_file library.
--					A file descriptor is returned which can the be passed
--					back to TIFFClientOpen and used as if it was a disk
--					based fd.
--					If the call is for mode 'w' then pass (void *)NULL as
--					the buffer and zero size and the library will 
--				    allocate memory for you.
--					If the mode is append then pass (void *)NULL and size
--					zero or with a valid address.
--					
+-   Description :   Register this area of memory (which has been allocated
+-                   and has a file read into it) under the mem_file library.
+-                   A file descriptor is returned which can the be passed
+-                   back to TIFFClientOpen and used as if it was a disk
+-                   based fd.
+-                   If the call is for mode 'w' then pass (void *)NULL as
+-                   the buffer and zero size and the library will 
+-                   allocate memory for you.
+-                   If the mode is append then pass (void *)NULL and size
+-                   zero or with a valid address.
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_open (void *buffer, int size, char *mode)
 {
-	int ret, i;
-	void *tmp;
-
-	if (library_init_done == FALSE)
-	{
-		mem_init ();
-		library_init_done = TRUE;
-	}
-
-	ret = -1;
-
-	/* Find a free fd */
-
-	for (i = 0; i < MAX_BUFFS; i++)
-	{
-		if (fds[i] == -1)
-		{
-			ret = i;
-			break;
-		}
-	}
-
-	if (i == MAX_BUFFS)		/* No more free descriptors */
-	{
-		ret = -1;
-		errno = EMFILE;
-	}
-
-	if (ret >= 0 && *mode == 'r')
-	{
-		if (buffer == (void *)NULL)
-		{
-			ret = -1;
-			errno = EINVAL;
-		}
-		else
-		{
-			buf[ret] = (char *)buffer;
-			buf_size[ret] = size;
-			buf_off[ret] = 0;
-		}
-	}
-	else if (ret >= 0 && *mode == 'w')
-	{
-
-		if (buffer != (void *)NULL)
-		{
-			ret = -1;
-			errno = EINVAL;
-		}
-
-		else
-		{
-			tmp = malloc (0);	/* Get a pointer */
-			if (tmp == (void *)NULL)
-			{
-				ret = -1;
-				errno = EDQUOT;
-			}
-			else
-			{
-				buf[ret] = (char *)tmp;
-				buf_size[ret] = 0;
-				buf_off[ret] = 0;
-			}
-		}
-	}
-	else if (ret >= 0 && *mode == 'a')
-	{
-		if (buffer == (void *) NULL)	/* Create space for client */
-		{
-			tmp = malloc (0);	/* Get a pointer */
-			if (tmp == (void *)NULL)
-			{
-				ret = -1;
-				errno = EDQUOT;
-			}
-			else
-			{
-				buf[ret] = (char *)tmp;
-				buf_size[ret] = 0;
-				buf_off[ret] = 0;
-			}
-		}
-		else							/* Client has file read in already */
-		{
-			buf[ret] = (char *)buffer;
-			buf_size[ret] = size;
-			buf_off[ret] = 0;
-		}
-	}
-	else		/* Some other invalid combination of parameters */
-	{
-		ret = -1;
-		errno = EINVAL;
-	}
-
-	if (ret != -1)
-	{
-		fds[ret] = 0;
-		buf_mode[ret] = *mode;
-	}
-
-	return (ret);
+    int ret, i;
+    void *tmp;
+
+    if (library_init_done == FALSE)
+    {
+        mem_init ();
+        library_init_done = TRUE;
+    }
+
+    ret = -1;
+
+    /* Find a free fd */
+
+    for (i = 0; i < MAX_BUFFS; i++)
+    {
+        if (fds[i] == -1)
+        {
+            ret = i;
+            break;
+        }
+    }
+
+    if (i == MAX_BUFFS)     /* No more free descriptors */
+    {
+        ret = -1;
+        errno = EMFILE;
+    }
+
+    if (ret >= 0 && *mode == 'r')
+    {
+        if (buffer == (void *)NULL)
+        {
+            ret = -1;
+            errno = EINVAL;
+        }
+        else
+        {
+            buf[ret] = (char *)buffer;
+            buf_size[ret] = size;
+            buf_off[ret] = 0;
+        }
+    }
+    else if (ret >= 0 && *mode == 'w')
+    {
+
+        if (buffer != (void *)NULL)
+        {
+            ret = -1;
+            errno = EINVAL;
+        }
+
+        else
+        {
+            tmp = malloc (0);   /* Get a pointer */
+            if (tmp == (void *)NULL)
+            {
+                ret = -1;
+                errno = EDQUOT;
+            }
+            else
+            {
+                buf[ret] = (char *)tmp;
+                buf_size[ret] = 0;
+                buf_off[ret] = 0;
+            }
+        }
+    }
+    else if (ret >= 0 && *mode == 'a')
+    {
+        if (buffer == (void *) NULL)    /* Create space for client */
+        {
+            tmp = malloc (0);   /* Get a pointer */
+            if (tmp == (void *)NULL)
+            {
+                ret = -1;
+                errno = EDQUOT;
+            }
+            else
+            {
+                buf[ret] = (char *)tmp;
+                buf_size[ret] = 0;
+                buf_off[ret] = 0;
+            }
+        }
+        else                            /* Client has file read in already */
+        {
+            buf[ret] = (char *)buffer;
+            buf_size[ret] = size;
+            buf_off[ret] = 0;
+        }
+    }
+    else        /* Some other invalid combination of parameters */
+    {
+        ret = -1;
+        errno = EINVAL;
+    }
+
+    if (ret != -1)
+    {
+        fds[ret] = 0;
+        buf_mode[ret] = *mode;
+    }
+
+    return (ret);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_lseek ()
+-   Function    :   mfs_lseek ()
 -
--	Arguments	:	File descriptor, offset, whence
+-   Arguments   :   File descriptor, offset, whence
 -
--	Returns		:	as per man lseek (2)
+-   Returns     :   as per man lseek (2)
 -
--	Description	:	Does the same as lseek (2) except on a memory based file.
--					Note: the memory area will be extended if the caller
--					attempts to seek past the current end of file (memory).
--					
+-   Description :   Does the same as lseek (2) except on a memory based file.
+-                   Note: the memory area will be extended if the caller
+-                   attempts to seek past the current end of file (memory).
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_lseek (int fd, int offset, int whence)
 {
-	int ret;
-	long test_off;
-
-	if (fds[fd] == -1)	/* Not open */
-	{
-		ret = -1;
-		errno = EBADF;
-	}
-	else if (offset < 0 && whence == SEEK_SET)
-	{
-		ret = -1;
-		errno = EINVAL;
-	}
-	else
-	{
-		switch (whence)
-		{
-			case SEEK_SET:
-				if (offset > buf_size[fd])
-					extend_mem_file (fd, offset);
-				buf_off[fd] = offset;
-				ret = offset;
-				break;
-
-			case SEEK_CUR:
-				test_off = buf_off[fd] + offset;
-
-				if (test_off < 0)
-				{
-					ret = -1;
-					errno = EINVAL;
-				}
-				else
-				{
-					if (test_off > buf_size[fd])
-						extend_mem_file (fd, test_off);
-					buf_off[fd] = test_off;
-					ret = test_off;
-				}
-				break;
-
-			case SEEK_END:
-				test_off = buf_size[fd] + offset;
-
-				if (test_off < 0)
-				{
-					ret = -1;
-					errno = EINVAL;
-				}
-				else
-				{
-					if (test_off > buf_size[fd])
-						extend_mem_file (fd, test_off);
-					buf_off[fd] = test_off;
-					ret = test_off;
-				}
-				break;
-
-			default:
-				errno = EINVAL;
-				ret = -1;
-				break;
-		}
-	}
-
-	return (ret);
-}	
+    int ret;
+    long test_off;
+
+    if (fds[fd] == -1)  /* Not open */
+    {
+        ret = -1;
+        errno = EBADF;
+    }
+    else if (offset < 0 && whence == SEEK_SET)
+    {
+        ret = -1;
+        errno = EINVAL;
+    }
+    else
+    {
+        switch (whence)
+        {
+            case SEEK_SET:
+                if (offset > buf_size[fd])
+                    extend_mem_file (fd, offset);
+                buf_off[fd] = offset;
+                ret = offset;
+                break;
+
+            case SEEK_CUR:
+                test_off = buf_off[fd] + offset;
+
+                if (test_off < 0)
+                {
+                    ret = -1;
+                    errno = EINVAL;
+                }
+                else
+                {
+                    if (test_off > buf_size[fd])
+                        extend_mem_file (fd, test_off);
+                    buf_off[fd] = test_off;
+                    ret = test_off;
+                }
+                break;
+
+            case SEEK_END:
+                test_off = buf_size[fd] + offset;
+
+                if (test_off < 0)
+                {
+                    ret = -1;
+                    errno = EINVAL;
+                }
+                else
+                {
+                    if (test_off > buf_size[fd])
+                        extend_mem_file (fd, test_off);
+                    buf_off[fd] = test_off;
+                    ret = test_off;
+                }
+                break;
+
+            default:
+                errno = EINVAL;
+                ret = -1;
+                break;
+        }
+    }
+
+    return (ret);
+}   
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_read ()
+-   Function    :   mfs_read ()
 -
--	Arguments	:	File descriptor, buffer, size
+-   Arguments   :   File descriptor, buffer, size
 -
--	Returns		:	as per man read (2)
+-   Returns     :   as per man read (2)
 -
--	Description	:	Does the same as read (2) except on a memory based file.
--					Note: An attempt to read past the end of memory currently
--					allocated to the file will return 0 (End Of File)
--					
+-   Description :   Does the same as read (2) except on a memory based file.
+-                   Note: An attempt to read past the end of memory currently
+-                   allocated to the file will return 0 (End Of File)
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_read (int fd, void *clnt_buf, int size)
 {
-	int ret;
-
-	if (fds[fd] == -1 || buf_mode[fd] != 'r')
-	{
-		/* File is either not open, or not opened for read */
-
-		ret = -1;
-		errno = EBADF;
-	}
-	else if (buf_off[fd] + size > buf_size[fd])
-	{
-		ret = 0;		/* EOF */
-	}
-	else
-	{
-		memcpy (clnt_buf, (void *) (buf[fd] + buf_off[fd]), size);
-		buf_off[fd] = buf_off[fd] + size;
-		ret = size;
-	}
-
-	return (ret);
+    int ret;
+
+    if (fds[fd] == -1 || buf_mode[fd] != 'r')
+    {
+        /* File is either not open, or not opened for read */
+
+        ret = -1;
+        errno = EBADF;
+    }
+    else if (buf_off[fd] + size > buf_size[fd])
+    {
+        ret = 0;        /* EOF */
+    }
+    else
+    {
+        memcpy (clnt_buf, (void *) (buf[fd] + buf_off[fd]), size);
+        buf_off[fd] = buf_off[fd] + size;
+        ret = size;
+    }
+
+    return (ret);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_write ()
+-   Function    :   mfs_write ()
 -
--	Arguments	:	File descriptor, buffer, size
+-   Arguments   :   File descriptor, buffer, size
 -
--	Returns		:	as per man write (2)
+-   Returns     :   as per man write (2)
 -
--	Description	:	Does the same as write (2) except on a memory based file.
--					Note: the memory area will be extended if the caller
--					attempts to write past the current end of file (memory).
--					
+-   Description :   Does the same as write (2) except on a memory based file.
+-                   Note: the memory area will be extended if the caller
+-                   attempts to write past the current end of file (memory).
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_write (int fd, void *clnt_buf, int size)
 {
-	int ret;
+    int ret;
 
-	if (fds[fd] == -1 || buf_mode[fd] == 'r')
-	{
-		/* Either the file is not open or it is opened for reading only */
+    if (fds[fd] == -1 || buf_mode[fd] == 'r')
+    {
+        /* Either the file is not open or it is opened for reading only */
 
-		ret = -1;
-		errno = EBADF;
-	}
-	else if (buf_mode[fd] == 'w')
-	{
-		/* Write */
+        ret = -1;
+        errno = EBADF;
+    }
+    else if (buf_mode[fd] == 'w')
+    {
+        /* Write */
 
-		if (buf_off[fd] + size > buf_size[fd])
-		{    	
-			extend_mem_file (fd, buf_off[fd] + size);
-			buf_size[fd] = (buf_off[fd] + size);
-		}
+        if (buf_off[fd] + size > buf_size[fd])
+        {       
+            extend_mem_file (fd, buf_off[fd] + size);
+            buf_size[fd] = (buf_off[fd] + size);
+        }
 
-		memcpy ((buf[fd] + buf_off[fd]), clnt_buf, size);
-		buf_off[fd] = buf_off[fd] + size;
+        memcpy ((buf[fd] + buf_off[fd]), clnt_buf, size);
+        buf_off[fd] = buf_off[fd] + size;
 
-		ret = size;
-	}
-	else
-	{
-		/* Append */
+        ret = size;
+    }
+    else
+    {
+        /* Append */
 
-		if (buf_off[fd] != buf_size[fd])
-			buf_off[fd] = buf_size[fd];
+        if (buf_off[fd] != buf_size[fd])
+            buf_off[fd] = buf_size[fd];
 
-		extend_mem_file (fd, buf_off[fd] + size);
-		buf_size[fd] += size;
+        extend_mem_file (fd, buf_off[fd] + size);
+        buf_size[fd] += size;
 
-		memcpy ((buf[fd] + buf_off[fd]), clnt_buf, size);
-		buf_off[fd] = buf_off[fd] + size;
+        memcpy ((buf[fd] + buf_off[fd]), clnt_buf, size);
+        buf_off[fd] = buf_off[fd] + size;
 
-		ret = size;
-	}
+        ret = size;
+    }
 
-	return (ret);
+    return (ret);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_size ()
+-   Function    :   mfs_size ()
 -
--	Arguments	:	File descriptor
+-   Arguments   :   File descriptor
 -
--	Returns		:	integer file size
+-   Returns     :   integer file size
 -
--	Description	:	This function returns the current size of the file in bytes.
--					
+-   Description :   This function returns the current size of the file in bytes.
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_size (int fd)
 {
-	int ret;
+    int ret;
 
-	if (fds[fd] == -1)	/* Not open */
-	{
-		ret = -1;
-		errno = EBADF;
-	}
-	else
-		ret = buf_size[fd];
+    if (fds[fd] == -1)  /* Not open */
+    {
+        ret = -1;
+        errno = EBADF;
+    }
+    else
+        ret = buf_size[fd];
 
-	return (ret);
+    return (ret);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_map ()
+-   Function    :   mfs_map ()
 -
--	Arguments	:	File descriptor, ptr to address, ptr to length
+-   Arguments   :   File descriptor, ptr to address, ptr to length
 -
--	Returns		:	Map status (succeeded or otherwise)
+-   Returns     :   Map status (succeeded or otherwise)
 -
--	Description	:	This function tells the client where the file is mapped
--					in memory and what size the mapped area is. It is provided
--					to satisfy the MapProc function in libtiff. It pretends
--					that the file has been mmap (2)ped.
--					
+-   Description :   This function tells the client where the file is mapped
+-                   in memory and what size the mapped area is. It is provided
+-                   to satisfy the MapProc function in libtiff. It pretends
+-                   that the file has been mmap (2)ped.
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_map (int fd, char **addr, size_t *len)
 {
-	int ret; 
-
-	if (fds[fd] == -1)	/* Not open */
-	{
-		ret = -1;
-		errno = EBADF;
-	}
-	else
-	{
-		*addr = buf[fd];
-		*len = buf_size[fd];
-		ret = 0;
-	}
-
-	return (ret);
+    int ret; 
+
+    if (fds[fd] == -1)  /* Not open */
+    {
+        ret = -1;
+        errno = EBADF;
+    }
+    else
+    {
+        *addr = buf[fd];
+        *len = buf_size[fd];
+        ret = 0;
+    }
+
+    return (ret);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_unmap ()
+-   Function    :   mfs_unmap ()
 -
--	Arguments	:	File descriptor
+-   Arguments   :   File descriptor
 -
--	Returns		:	UnMap status (succeeded or otherwise)
+-   Returns     :   UnMap status (succeeded or otherwise)
 -
--	Description	:	This function does nothing as the file is always
+-   Description :   This function does nothing as the file is always
 -                   in memory.
--					
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_unmap (int fd)
 {
-	return (0);
+    return (0);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mfs_close ()
+-   Function    :   mfs_close ()
 -
--	Arguments	:	File descriptor
+-   Arguments   :   File descriptor
 -
--	Returns		:	close status (succeeded or otherwise)
+-   Returns     :   close status (succeeded or otherwise)
 -
--	Description	:	Close the open memory file. (Make fd available again.)
--					
+-   Description :   Close the open memory file. (Make fd available again.)
+-                   
 --------------------------------------------------------------------------------
 */
 
 int mfs_close (int fd)
 {
-	int ret; 
-
-	if (fds[fd] == -1)	/* Not open */
-	{
-		ret = -1;
-		errno = EBADF;
-	}
-	else
-	{
-		fds[fd] = -1;
-		ret = 0;
-	}
-
-	return (ret);
+    int ret; 
+
+    if (fds[fd] == -1)  /* Not open */
+    {
+        ret = -1;
+        errno = EBADF;
+    }
+    else
+    {
+        fds[fd] = -1;
+        ret = 0;
+    }
+
+    return (ret);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	extend_mem_file ()
+-   Function    :   extend_mem_file ()
 -
--	Arguments	:	File descriptor, length to extend to.
+-   Arguments   :   File descriptor, length to extend to.
 -
--	Returns		:	0 - All OK, -1 - realloc () failed.
+-   Returns     :   0 - All OK, -1 - realloc () failed.
 -
--	Description	:	Increase the amount of memory allocated to a file.
--					
+-   Description :   Increase the amount of memory allocated to a file.
+-                   
 --------------------------------------------------------------------------------
 */
 
 static int extend_mem_file (int fd, int size)
 {
-	void *new_mem;
-	int ret;
-
-	if ((new_mem = realloc (buf[fd], size)) == (void *) NULL)
-		ret = -1;
-	else
-	{
-		buf[fd] = (char *) new_mem;
-		ret = 0;
-	}
-
-	return (ret);
+    void *new_mem;
+    int ret;
+
+    if ((new_mem = realloc (buf[fd], size)) == (void *) NULL)
+        ret = -1;
+    else
+    {
+        buf[fd] = (char *) new_mem;
+        ret = 0;
+    }
+
+    return (ret);
 }
 
 /*
 --------------------------------------------------------------------------------
--	Function	:	mem_init ()
+-   Function    :   mem_init ()
 -
--	Arguments	:	None
+-   Arguments   :   None
 -
--	Returns		:	void
+-   Returns     :   void
 -
--	Description	:	Initialise the library.
--					
+-   Description :   Initialise the library.
+-                   
 --------------------------------------------------------------------------------
 */
 
 static void mem_init ()
 {
-	int i;
-
-	for (i = 0; i < MAX_BUFFS; i++)
-	{
-		fds[i] = -1;
-		buf[i] = (char *)NULL;
-		buf_size[i] = 0;
-		buf_off[i] = 0;
-	}
+    int i;
+
+    for (i = 0; i < MAX_BUFFS; i++)
+    {
+        fds[i] = -1;
+        buf[i] = (char *)NULL;
+        buf_size[i] = 0;
+        buf_off[i] = 0;
+    }
 }