[svn-r2611] Purpose:

    Rearrange code
Description:
    The data sieve buffering code for contiguously stored datasets was
    wedged in the H5F_arr_read/H5F_arr_write routines.
Solution:
    Created a new H5Fcontig.c to hold I/O routines for contiguously stored
    datasets (like H5Fistore.c for chunked dataset I/O routines) and moved
    data sieving code into those routines.
Platforms tested:
    Solaris 2.6 (i.e. baldric)

7 files changed, 700 insertions, 254 deletions

diff --git a/MANIFEST b/MANIFEST
index 62d8f1b..3eab89d 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -444,6 +444,7 @@
 ./src/H5Epublic.h
 ./src/H5F.c
 ./src/H5Farray.c
+./src/H5Fcontig.c
 ./src/H5Fistore.c
 ./src/H5Fprivate.h
 ./src/H5Fpublic.h
diff --git a/src/H5Dcontig.c b/src/H5Dcontig.c
new file mode 100644
index 0000000..a051b12
--- /dev/null
+++ b/src/H5Dcontig.c
@@ -0,0 +1,340 @@
+/*
+ * Copyright (C) 2000 NCSA
+ *		      All rights reserved.
+ *
+ * Programmer: 	Quincey Koziol <koziol@ncsa.uiuc.edu>
+ *	       	Thursday, September 28, 2000
+ *
+ * Purpose:	Contiguous dataset I/O functions.  These routines are similar
+ *      to the H5F_istore_* routines and really only abstract away dealing
+ *      with the data sieve buffer from the H5F_arr_read/write and
+ *      H5F_seg_read/write.
+ *
+ */
+#include <H5private.h>
+#include <H5Eprivate.h>
+#include <H5Fprivate.h>
+#include <H5FDprivate.h>	/*file driver				  */
+#include <H5MMprivate.h>
+
+/* Interface initialization */
+#define PABLO_MASK	H5Fcontig_mask
+static intn		interface_initialize_g = 0;
+#define INTERFACE_INIT NULL
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5F_contig_read
+ *
+ * Purpose:	Reads some data from a dataset into a buffer.
+ *		The data is contiguous.	 The address is relative to the base
+ *		address for the file.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Thursday, September 28, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5F_contig_read(H5F_t *f, haddr_t addr, hsize_t size, hid_t dxpl_id,
+	       void *_buf/*out*/)
+{
+    uint8_t	*buf = (uint8_t*)_buf;		/*cast for arithmetic	*/
+    haddr_t	eof;		        /*end of file address		*/
+   
+    FUNC_ENTER(H5F_contig_read, FAIL);
+
+    /* Check args */
+    assert(f);
+    assert(size<SIZET_MAX);
+    assert(buf);
+
+    /* Check if data sieving is enabled */
+    if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+        /* Try reading from the data sieve buffer */
+        if(f->shared->sieve_buf) {
+            /* If entire read is within the sieve buffer, read it from the buffer */
+            if((addr>=f->shared->sieve_loc && addr<(f->shared->sieve_loc+f->shared->sieve_size))
+                    && ((addr+size-1)>=f->shared->sieve_loc && (addr+size-1)<(f->shared->sieve_loc+f->shared->sieve_size))) {
+                /* Grab the data out of the buffer */
+                HDmemcpy(buf,f->shared->sieve_buf+(addr-f->shared->sieve_loc),size);
+            } /* end if */
+            /* Entire request is not within this data sieve buffer */
+            else {
+                /* Check if we can actually hold the I/O request in the sieve buffer */
+                if(size>f->shared->sieve_buf_size) {
+                    /* Check for any overlap with the current sieve buffer */
+                    if((f->shared->sieve_loc>=addr && f->shared->sieve_loc<(addr+size))
+                            || ((f->shared->sieve_loc+f->shared->sieve_size-1)>=addr && (f->shared->sieve_loc+f->shared->sieve_size-1)<(addr+size))) {
+                        /* Flush the sieve buffer, if it's dirty */
+                        if(f->shared->sieve_dirty) {
+                            /* Write to file */
+                            if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                                HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                                  "block write failed");
+                            }
+
+                            /* Reset sieve buffer dirty flag */
+                            f->shared->sieve_dirty=0;
+                        } /* end if */
+                    } /* end if */
+
+                    /* Read directly into the user's buffer */
+                    if (H5F_block_read(f, addr, size, dxpl_id, buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                                  "block read failed");
+                    }
+                } /* end if */
+                /* Element size fits within the buffer size */
+                else {
+                    /* Flush the sieve buffer if it's dirty */
+                    if(f->shared->sieve_dirty) {
+                        /* Write to file */
+                        if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                              "block write failed");
+                        }
+
+                        /* Reset sieve buffer dirty flag */
+                        f->shared->sieve_dirty=0;
+                    } /* end if */
+
+                    /* Determine the new sieve buffer size & location */
+                    f->shared->sieve_loc=addr;
+
+                    /* Make certain we don't read off the end of the file */
+                    if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                        HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                            "unable to determine file size");
+                    }
+                    f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                    /* Read the new sieve buffer */
+                    if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                                  "block read failed");
+                    }
+
+                    /* Reset sieve buffer dirty flag */
+                    f->shared->sieve_dirty=0;
+
+                    /* Grab the data out of the buffer (must be first piece of data in buffer ) */
+                    HDmemcpy(buf,f->shared->sieve_buf,size);
+                } /* end else */
+            } /* end else */
+        } /* end if */
+        /* No data sieve buffer yet, go allocate one */
+        else {
+            /* Check if we can actually hold the I/O request in the sieve buffer */
+            if(size>f->shared->sieve_buf_size) {
+                if (H5F_block_read(f, addr, size, dxpl_id, buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                              "block read failed");
+                }
+            } /* end if */
+            else {
+                /* Allocate room for the data sieve buffer */
+                if (NULL==(f->shared->sieve_buf=H5MM_malloc(f->shared->sieve_buf_size))) {
+                    HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
+                          "memory allocation failed");
+                }
+
+                /* Determine the new sieve buffer size & location */
+                f->shared->sieve_loc=addr;
+
+                /* Make certain we don't read off the end of the file */
+                if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                    HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                        "unable to determine file size");
+                }
+                f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                /* Read the new sieve buffer */
+                if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                              "block read failed");
+                }
+
+                /* Reset sieve buffer dirty flag */
+                f->shared->sieve_dirty=0;
+
+                /* Grab the data out of the buffer (must be first piece of data in buffer ) */
+                HDmemcpy(buf,f->shared->sieve_buf,size);
+            } /* end else */
+        } /* end else */
+    } /* end if */
+    else {
+        if (H5F_block_read(f, addr, size, dxpl_id, buf)<0) {
+            HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                      "block read failed");
+        }
+    } /* end else */
+
+    FUNC_LEAVE(SUCCEED);
+}   /* End H5F_contig_read() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5F_contig_write
+ *
+ * Purpose:	Writes some data from a dataset into a buffer.
+ *		The data is contiguous.	 The address is relative to the base
+ *		address for the file.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Thursday, September 28, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5F_contig_write(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size,
+        hid_t dxpl_id, const void *buf)
+{
+    haddr_t	eof;		        /*end of file address		*/
+
+    FUNC_ENTER(H5F_block_write, FAIL);
+
+    assert (f);
+    assert (size<SIZET_MAX);
+    assert (buf);
+
+    /* Check if data sieving is enabled */
+    if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+        /* Try writing to the data sieve buffer */
+        if(f->shared->sieve_buf) {
+            /* If entire write is within the sieve buffer, write it to the buffer */
+            if((addr>=f->shared->sieve_loc && addr<(f->shared->sieve_loc+f->shared->sieve_size))
+                    && ((addr+size-1)>=f->shared->sieve_loc && (addr+size-1)<(f->shared->sieve_loc+f->shared->sieve_size))) {
+                /* Grab the data out of the buffer */
+                HDmemcpy(f->shared->sieve_buf+(addr-f->shared->sieve_loc),buf,size);
+
+                /* Set sieve buffer dirty flag */
+                f->shared->sieve_dirty=1;
+
+            } /* end if */
+            /* Entire request is not within this data sieve buffer */
+            else {
+                /* Check if we can actually hold the I/O request in the sieve buffer */
+                if(size>f->shared->sieve_buf_size) {
+                    /* Check for any overlap with the current sieve buffer */
+                    if((f->shared->sieve_loc>=addr && f->shared->sieve_loc<(addr+size))
+                            || ((f->shared->sieve_loc+f->shared->sieve_size-1)>=addr && (f->shared->sieve_loc+f->shared->sieve_size-1)<(addr+size))) {
+                        /* Flush the sieve buffer, if it's dirty */
+                        if(f->shared->sieve_dirty) {
+                            /* Write to file */
+                            if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                                HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                                  "block write failed");
+                            }
+
+                            /* Reset sieve buffer dirty flag */
+                            f->shared->sieve_dirty=0;
+                        } /* end if */
+
+                        /* Force the sieve buffer to be re-read the next time */
+                        f->shared->sieve_loc=HADDR_UNDEF;
+                        f->shared->sieve_size=0;
+                    } /* end if */
+
+                    /* Write directly from the user's buffer */
+                    if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                                  "block write failed");
+                    }
+                } /* end if */
+                /* Element size fits within the buffer size */
+                else {
+                    /* Flush the sieve buffer if it's dirty */
+                    if(f->shared->sieve_dirty) {
+                        /* Write to file */
+                        if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                              "block write failed");
+                        }
+
+                        /* Reset sieve buffer dirty flag */
+                        f->shared->sieve_dirty=0;
+                    } /* end if */
+
+                    /* Determine the new sieve buffer size & location */
+                    f->shared->sieve_loc=addr;
+
+                    /* Make certain we don't read off the end of the file */
+                    if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                        HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                            "unable to determine file size");
+                    }
+                    f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                    /* Read the new sieve buffer */
+                    if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                                  "block read failed");
+                    }
+
+                    /* Grab the data out of the buffer (must be first piece of data in buffer) */
+                    HDmemcpy(f->shared->sieve_buf,buf,size);
+
+                    /* Set sieve buffer dirty flag */
+                    f->shared->sieve_dirty=1;
+
+                } /* end else */
+            } /* end else */
+        } /* end if */
+        /* No data sieve buffer yet, go allocate one */
+        else {
+            /* Check if we can actually hold the I/O request in the sieve buffer */
+            if(size>f->shared->sieve_buf_size) {
+                if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                              "block write failed");
+                }
+            } /* end if */
+            else {
+                /* Allocate room for the data sieve buffer */
+                if (NULL==(f->shared->sieve_buf=H5MM_malloc(f->shared->sieve_buf_size))) {
+                    HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
+                          "memory allocation failed");
+                }
+
+                /* Determine the new sieve buffer size & location */
+                f->shared->sieve_loc=addr;
+
+                /* Make certain we don't read off the end of the file */
+                if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                    HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                        "unable to determine file size");
+                }
+                f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                /* Read the new sieve buffer */
+                if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                              "block read failed");
+                }
+
+                /* Grab the data out of the buffer (must be first piece of data in buffer) */
+                HDmemcpy(f->shared->sieve_buf,buf,size);
+
+                /* Set sieve buffer dirty flag */
+                f->shared->sieve_dirty=1;
+            } /* end else */
+        } /* end else */
+    } /* end if */
+    else {
+        if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0) {
+            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                      "block write failed");
+        }
+    } /* end else */
+
+    FUNC_LEAVE(SUCCEED);
+}   /* End H5F_contig_write() */
diff --git a/src/H5FDlog.c b/src/H5FDlog.c
index 9c81125..77464c9 100644
--- a/src/H5FDlog.c
+++ b/src/H5FDlog.c
@@ -40,7 +40,7 @@ static hid_t H5FD_LOG_g = 0;
 
 /* Driver-specific file access properties */
 typedef struct H5FD_log_fapl_t {
-    char *logfile;			/* Allocated log file name */
+    const char *logfile;			/* Allocated log file name */
     intn verbosity;                 /* Verbosity of logging information */
 } H5FD_log_fapl_t;
 
diff --git a/src/H5Farray.c b/src/H5Farray.c
index e581315..a79c4dc 100644
--- a/src/H5Farray.c
+++ b/src/H5Farray.c
@@ -309,126 +309,10 @@ printf("%s: feature_flags=%lx\n",FUNC,(unsigned long)f->shared->lf->feature_flag
                       "external data read failed");
             }
         } else {
-            /* Check if data sieving is enabled */
-            if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
-                /* Try reading from the data sieve buffer */
-                if(f->shared->sieve_buf) {
-                    /* If entire read is within the sieve buffer, read it from the buffer */
-                    if((addr>=f->shared->sieve_loc && addr<(f->shared->sieve_loc+f->shared->sieve_size))
-                            && ((addr+elmt_size-1)>=f->shared->sieve_loc && (addr+elmt_size-1)<(f->shared->sieve_loc+f->shared->sieve_size))) {
-                        /* Grab the data out of the buffer */
-                        HDmemcpy(buf,f->shared->sieve_buf+(addr-f->shared->sieve_loc),elmt_size);
-                    } /* end if */
-                    /* Entire request is not within this data sieve buffer */
-                    else {
-                        /* Check if we can actually hold the I/O request in the sieve buffer */
-                        if(elmt_size>f->shared->sieve_buf_size) {
-                            /* Check for any overlap with the current sieve buffer */
-                            if((f->shared->sieve_loc>=addr && f->shared->sieve_loc<(addr+elmt_size))
-                                    || ((f->shared->sieve_loc+f->shared->sieve_size-1)>=addr && (f->shared->sieve_loc+f->shared->sieve_size-1)<(addr+elmt_size))) {
-                                /* Flush the sieve buffer, if it's dirty */
-                                if(f->shared->sieve_dirty) {
-                                    /* Write to file */
-                                    if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                                        HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
-                                          "block write failed");
-                                    }
-
-                                    /* Reset sieve buffer dirty flag */
-                                    f->shared->sieve_dirty=0;
-                                } /* end if */
-                            } /* end if */
-
-                            /* Read directly into the user's buffer */
-                            if (H5F_block_read(f, addr, elmt_size, dxpl_id, buf)<0) {
-                                HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
-                                          "block read failed");
-                            }
-                        } /* end if */
-                        /* Element size fits within the buffer size */
-                        else {
-                            /* Flush the sieve buffer if it's dirty */
-                            if(f->shared->sieve_dirty) {
-                                /* Write to file */
-                                if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                                    HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
-                                      "block write failed");
-                                }
-
-                                /* Reset sieve buffer dirty flag */
-                                f->shared->sieve_dirty=0;
-                            } /* end if */
-
-                            /* Determine the new sieve buffer size & location */
-                            f->shared->sieve_loc=addr;
-
-                            /* Make certain we don't read off the end of the file */
-                            if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
-                                HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
-                                    "unable to determine file size");
-                            }
-                            f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
-
-                            /* Read the new sieve buffer */
-                            if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                                HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
-                                          "block read failed");
-                            }
-
-                            /* Reset sieve buffer dirty flag */
-                            f->shared->sieve_dirty=0;
-
-                            /* Grab the data out of the buffer (must be first piece of data in buffer ) */
-                            HDmemcpy(buf,f->shared->sieve_buf,elmt_size);
-                        } /* end else */
-                    } /* end else */
-                } /* end if */
-                /* No data sieve buffer yet, go allocate one */
-                else {
-                    /* Check if we can actually hold the I/O request in the sieve buffer */
-                    if(elmt_size>f->shared->sieve_buf_size) {
-                        if (H5F_block_read(f, addr, elmt_size, dxpl_id, buf)<0) {
-                            HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
-                                      "block read failed");
-                        }
-                    } /* end if */
-                    else {
-                        /* Allocate room for the data sieve buffer */
-                        if (NULL==(f->shared->sieve_buf=H5MM_malloc(f->shared->sieve_buf_size))) {
-                            HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                                  "memory allocation failed");
-                        }
-
-                        /* Determine the new sieve buffer size & location */
-                        f->shared->sieve_loc=addr;
-
-                        /* Make certain we don't read off the end of the file */
-                        if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
-                            HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
-                                "unable to determine file size");
-                        }
-                        f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
-
-                        /* Read the new sieve buffer */
-                        if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                            HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
-                                      "block read failed");
-                        }
-
-                        /* Reset sieve buffer dirty flag */
-                        f->shared->sieve_dirty=0;
-
-                        /* Grab the data out of the buffer (must be first piece of data in buffer ) */
-                        HDmemcpy(buf,f->shared->sieve_buf,elmt_size);
-                    } /* end else */
-                } /* end else */
-            } /* end if */
-            else {
-                if (H5F_block_read(f, addr, elmt_size, dxpl_id, buf)<0) {
-                    HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
-                              "block read failed");
-                }
-            } /* end else */
+            if (H5F_contig_read(f, addr, elmt_size, dxpl_id, buf)<0) {
+                HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                          "block read failed");
+            }
         } /* end else */
 
 	    /* Decrement indices and advance pointers */
@@ -671,135 +555,10 @@ H5F_arr_write(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout,
                       "external data write failed");
             }
 	    } else {
-            /* Check if data sieving is enabled */
-            if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
-                /* Try writing to the data sieve buffer */
-                if(f->shared->sieve_buf) {
-                    /* If entire write is within the sieve buffer, write it to the buffer */
-                    if((addr>=f->shared->sieve_loc && addr<(f->shared->sieve_loc+f->shared->sieve_size))
-                            && ((addr+elmt_size-1)>=f->shared->sieve_loc && (addr+elmt_size-1)<(f->shared->sieve_loc+f->shared->sieve_size))) {
-                        /* Grab the data out of the buffer */
-                        HDmemcpy(f->shared->sieve_buf+(addr-f->shared->sieve_loc),buf,elmt_size);
-
-                        /* Set sieve buffer dirty flag */
-                        f->shared->sieve_dirty=1;
-
-                    } /* end if */
-                    /* Entire request is not within this data sieve buffer */
-                    else {
-                        /* Check if we can actually hold the I/O request in the sieve buffer */
-                        if(elmt_size>f->shared->sieve_buf_size) {
-                            /* Check for any overlap with the current sieve buffer */
-                            if((f->shared->sieve_loc>=addr && f->shared->sieve_loc<(addr+elmt_size))
-                                    || ((f->shared->sieve_loc+f->shared->sieve_size-1)>=addr && (f->shared->sieve_loc+f->shared->sieve_size-1)<(addr+elmt_size))) {
-                                /* Flush the sieve buffer, if it's dirty */
-                                if(f->shared->sieve_dirty) {
-                                    /* Write to file */
-                                    if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                                        HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
-                                          "block write failed");
-                                    }
-
-                                    /* Reset sieve buffer dirty flag */
-                                    f->shared->sieve_dirty=0;
-                                } /* end if */
-
-                                /* Force the sieve buffer to be re-read the next time */
-                                f->shared->sieve_loc=HADDR_UNDEF;
-                                f->shared->sieve_size=0;
-                            } /* end if */
-
-                            /* Write directly from the user's buffer */
-                            if (H5F_block_write(f, H5FD_MEM_DRAW, addr, elmt_size, dxpl_id, buf)<0) {
-                                HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
-                                          "block write failed");
-                            }
-                        } /* end if */
-                        /* Element size fits within the buffer size */
-                        else {
-                            /* Flush the sieve buffer if it's dirty */
-                            if(f->shared->sieve_dirty) {
-                                /* Write to file */
-                                if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                                    HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
-                                      "block write failed");
-                                }
-
-                                /* Reset sieve buffer dirty flag */
-                                f->shared->sieve_dirty=0;
-                            } /* end if */
-
-                            /* Determine the new sieve buffer size & location */
-                            f->shared->sieve_loc=addr;
-
-                            /* Make certain we don't read off the end of the file */
-                            if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
-                                HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
-                                    "unable to determine file size");
-                            }
-                            f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
-
-                            /* Read the new sieve buffer */
-                            if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                                HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
-                                          "block read failed");
-                            }
-
-                            /* Grab the data out of the buffer (must be first piece of data in buffer) */
-                            HDmemcpy(f->shared->sieve_buf,buf,elmt_size);
-
-                            /* Set sieve buffer dirty flag */
-                            f->shared->sieve_dirty=1;
-
-                        } /* end else */
-                    } /* end else */
-                } /* end if */
-                /* No data sieve buffer yet, go allocate one */
-                else {
-                    /* Check if we can actually hold the I/O request in the sieve buffer */
-                    if(elmt_size>f->shared->sieve_buf_size) {
-                        if (H5F_block_write(f, H5FD_MEM_DRAW, addr, elmt_size, dxpl_id, buf)<0) {
-                            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
-                                      "block write failed");
-                        }
-                    } /* end if */
-                    else {
-                        /* Allocate room for the data sieve buffer */
-                        if (NULL==(f->shared->sieve_buf=H5MM_malloc(f->shared->sieve_buf_size))) {
-                            HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                                  "memory allocation failed");
-                        }
-
-                        /* Determine the new sieve buffer size & location */
-                        f->shared->sieve_loc=addr;
-
-                        /* Make certain we don't read off the end of the file */
-                        if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
-                            HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
-                                "unable to determine file size");
-                        }
-                        f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
-
-                        /* Read the new sieve buffer */
-                        if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
-                            HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
-                                      "block read failed");
-                        }
-
-                        /* Grab the data out of the buffer (must be first piece of data in buffer) */
-                        HDmemcpy(f->shared->sieve_buf,buf,elmt_size);
-
-                        /* Set sieve buffer dirty flag */
-                        f->shared->sieve_dirty=1;
-                    } /* end else */
-                } /* end else */
-            } /* end if */
-            else {
-                if (H5F_block_write(f, H5FD_MEM_DRAW, addr, elmt_size, dxpl_id, buf)<0) {
-                    HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
-                              "block write failed");
-                }
-            } /* end else */
+            if (H5F_contig_write(f, H5FD_MEM_DRAW, addr, elmt_size, dxpl_id, buf)<0) {
+                HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                          "block write failed");
+            }
 	    } /* end else */
 
 	    /* Decrement indices and advance pointers */
diff --git a/src/H5Fcontig.c b/src/H5Fcontig.c
new file mode 100644
index 0000000..a051b12
--- /dev/null
+++ b/src/H5Fcontig.c
@@ -0,0 +1,340 @@
+/*
+ * Copyright (C) 2000 NCSA
+ *		      All rights reserved.
+ *
+ * Programmer: 	Quincey Koziol <koziol@ncsa.uiuc.edu>
+ *	       	Thursday, September 28, 2000
+ *
+ * Purpose:	Contiguous dataset I/O functions.  These routines are similar
+ *      to the H5F_istore_* routines and really only abstract away dealing
+ *      with the data sieve buffer from the H5F_arr_read/write and
+ *      H5F_seg_read/write.
+ *
+ */
+#include <H5private.h>
+#include <H5Eprivate.h>
+#include <H5Fprivate.h>
+#include <H5FDprivate.h>	/*file driver				  */
+#include <H5MMprivate.h>
+
+/* Interface initialization */
+#define PABLO_MASK	H5Fcontig_mask
+static intn		interface_initialize_g = 0;
+#define INTERFACE_INIT NULL
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5F_contig_read
+ *
+ * Purpose:	Reads some data from a dataset into a buffer.
+ *		The data is contiguous.	 The address is relative to the base
+ *		address for the file.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Thursday, September 28, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5F_contig_read(H5F_t *f, haddr_t addr, hsize_t size, hid_t dxpl_id,
+	       void *_buf/*out*/)
+{
+    uint8_t	*buf = (uint8_t*)_buf;		/*cast for arithmetic	*/
+    haddr_t	eof;		        /*end of file address		*/
+   
+    FUNC_ENTER(H5F_contig_read, FAIL);
+
+    /* Check args */
+    assert(f);
+    assert(size<SIZET_MAX);
+    assert(buf);
+
+    /* Check if data sieving is enabled */
+    if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+        /* Try reading from the data sieve buffer */
+        if(f->shared->sieve_buf) {
+            /* If entire read is within the sieve buffer, read it from the buffer */
+            if((addr>=f->shared->sieve_loc && addr<(f->shared->sieve_loc+f->shared->sieve_size))
+                    && ((addr+size-1)>=f->shared->sieve_loc && (addr+size-1)<(f->shared->sieve_loc+f->shared->sieve_size))) {
+                /* Grab the data out of the buffer */
+                HDmemcpy(buf,f->shared->sieve_buf+(addr-f->shared->sieve_loc),size);
+            } /* end if */
+            /* Entire request is not within this data sieve buffer */
+            else {
+                /* Check if we can actually hold the I/O request in the sieve buffer */
+                if(size>f->shared->sieve_buf_size) {
+                    /* Check for any overlap with the current sieve buffer */
+                    if((f->shared->sieve_loc>=addr && f->shared->sieve_loc<(addr+size))
+                            || ((f->shared->sieve_loc+f->shared->sieve_size-1)>=addr && (f->shared->sieve_loc+f->shared->sieve_size-1)<(addr+size))) {
+                        /* Flush the sieve buffer, if it's dirty */
+                        if(f->shared->sieve_dirty) {
+                            /* Write to file */
+                            if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                                HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                                  "block write failed");
+                            }
+
+                            /* Reset sieve buffer dirty flag */
+                            f->shared->sieve_dirty=0;
+                        } /* end if */
+                    } /* end if */
+
+                    /* Read directly into the user's buffer */
+                    if (H5F_block_read(f, addr, size, dxpl_id, buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                                  "block read failed");
+                    }
+                } /* end if */
+                /* Element size fits within the buffer size */
+                else {
+                    /* Flush the sieve buffer if it's dirty */
+                    if(f->shared->sieve_dirty) {
+                        /* Write to file */
+                        if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                              "block write failed");
+                        }
+
+                        /* Reset sieve buffer dirty flag */
+                        f->shared->sieve_dirty=0;
+                    } /* end if */
+
+                    /* Determine the new sieve buffer size & location */
+                    f->shared->sieve_loc=addr;
+
+                    /* Make certain we don't read off the end of the file */
+                    if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                        HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                            "unable to determine file size");
+                    }
+                    f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                    /* Read the new sieve buffer */
+                    if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                                  "block read failed");
+                    }
+
+                    /* Reset sieve buffer dirty flag */
+                    f->shared->sieve_dirty=0;
+
+                    /* Grab the data out of the buffer (must be first piece of data in buffer ) */
+                    HDmemcpy(buf,f->shared->sieve_buf,size);
+                } /* end else */
+            } /* end else */
+        } /* end if */
+        /* No data sieve buffer yet, go allocate one */
+        else {
+            /* Check if we can actually hold the I/O request in the sieve buffer */
+            if(size>f->shared->sieve_buf_size) {
+                if (H5F_block_read(f, addr, size, dxpl_id, buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                              "block read failed");
+                }
+            } /* end if */
+            else {
+                /* Allocate room for the data sieve buffer */
+                if (NULL==(f->shared->sieve_buf=H5MM_malloc(f->shared->sieve_buf_size))) {
+                    HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
+                          "memory allocation failed");
+                }
+
+                /* Determine the new sieve buffer size & location */
+                f->shared->sieve_loc=addr;
+
+                /* Make certain we don't read off the end of the file */
+                if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                    HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                        "unable to determine file size");
+                }
+                f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                /* Read the new sieve buffer */
+                if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                              "block read failed");
+                }
+
+                /* Reset sieve buffer dirty flag */
+                f->shared->sieve_dirty=0;
+
+                /* Grab the data out of the buffer (must be first piece of data in buffer ) */
+                HDmemcpy(buf,f->shared->sieve_buf,size);
+            } /* end else */
+        } /* end else */
+    } /* end if */
+    else {
+        if (H5F_block_read(f, addr, size, dxpl_id, buf)<0) {
+            HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                      "block read failed");
+        }
+    } /* end else */
+
+    FUNC_LEAVE(SUCCEED);
+}   /* End H5F_contig_read() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5F_contig_write
+ *
+ * Purpose:	Writes some data from a dataset into a buffer.
+ *		The data is contiguous.	 The address is relative to the base
+ *		address for the file.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Thursday, September 28, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5F_contig_write(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size,
+        hid_t dxpl_id, const void *buf)
+{
+    haddr_t	eof;		        /*end of file address		*/
+
+    FUNC_ENTER(H5F_block_write, FAIL);
+
+    assert (f);
+    assert (size<SIZET_MAX);
+    assert (buf);
+
+    /* Check if data sieving is enabled */
+    if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+        /* Try writing to the data sieve buffer */
+        if(f->shared->sieve_buf) {
+            /* If entire write is within the sieve buffer, write it to the buffer */
+            if((addr>=f->shared->sieve_loc && addr<(f->shared->sieve_loc+f->shared->sieve_size))
+                    && ((addr+size-1)>=f->shared->sieve_loc && (addr+size-1)<(f->shared->sieve_loc+f->shared->sieve_size))) {
+                /* Grab the data out of the buffer */
+                HDmemcpy(f->shared->sieve_buf+(addr-f->shared->sieve_loc),buf,size);
+
+                /* Set sieve buffer dirty flag */
+                f->shared->sieve_dirty=1;
+
+            } /* end if */
+            /* Entire request is not within this data sieve buffer */
+            else {
+                /* Check if we can actually hold the I/O request in the sieve buffer */
+                if(size>f->shared->sieve_buf_size) {
+                    /* Check for any overlap with the current sieve buffer */
+                    if((f->shared->sieve_loc>=addr && f->shared->sieve_loc<(addr+size))
+                            || ((f->shared->sieve_loc+f->shared->sieve_size-1)>=addr && (f->shared->sieve_loc+f->shared->sieve_size-1)<(addr+size))) {
+                        /* Flush the sieve buffer, if it's dirty */
+                        if(f->shared->sieve_dirty) {
+                            /* Write to file */
+                            if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                                HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                                  "block write failed");
+                            }
+
+                            /* Reset sieve buffer dirty flag */
+                            f->shared->sieve_dirty=0;
+                        } /* end if */
+
+                        /* Force the sieve buffer to be re-read the next time */
+                        f->shared->sieve_loc=HADDR_UNDEF;
+                        f->shared->sieve_size=0;
+                    } /* end if */
+
+                    /* Write directly from the user's buffer */
+                    if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                                  "block write failed");
+                    }
+                } /* end if */
+                /* Element size fits within the buffer size */
+                else {
+                    /* Flush the sieve buffer if it's dirty */
+                    if(f->shared->sieve_dirty) {
+                        /* Write to file */
+                        if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                              "block write failed");
+                        }
+
+                        /* Reset sieve buffer dirty flag */
+                        f->shared->sieve_dirty=0;
+                    } /* end if */
+
+                    /* Determine the new sieve buffer size & location */
+                    f->shared->sieve_loc=addr;
+
+                    /* Make certain we don't read off the end of the file */
+                    if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                        HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                            "unable to determine file size");
+                    }
+                    f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                    /* Read the new sieve buffer */
+                    if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                        HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                                  "block read failed");
+                    }
+
+                    /* Grab the data out of the buffer (must be first piece of data in buffer) */
+                    HDmemcpy(f->shared->sieve_buf,buf,size);
+
+                    /* Set sieve buffer dirty flag */
+                    f->shared->sieve_dirty=1;
+
+                } /* end else */
+            } /* end else */
+        } /* end if */
+        /* No data sieve buffer yet, go allocate one */
+        else {
+            /* Check if we can actually hold the I/O request in the sieve buffer */
+            if(size>f->shared->sieve_buf_size) {
+                if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                              "block write failed");
+                }
+            } /* end if */
+            else {
+                /* Allocate room for the data sieve buffer */
+                if (NULL==(f->shared->sieve_buf=H5MM_malloc(f->shared->sieve_buf_size))) {
+                    HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
+                          "memory allocation failed");
+                }
+
+                /* Determine the new sieve buffer size & location */
+                f->shared->sieve_loc=addr;
+
+                /* Make certain we don't read off the end of the file */
+                if (HADDR_UNDEF==(eof=H5FD_get_eof(f->shared->lf))) {
+                    HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL,
+                        "unable to determine file size");
+                }
+                f->shared->sieve_size=MIN(eof-addr,f->shared->sieve_buf_size);
+
+                /* Read the new sieve buffer */
+                if (H5F_block_read(f, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0) {
+                    HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                              "block read failed");
+                }
+
+                /* Grab the data out of the buffer (must be first piece of data in buffer) */
+                HDmemcpy(f->shared->sieve_buf,buf,size);
+
+                /* Set sieve buffer dirty flag */
+                f->shared->sieve_dirty=1;
+            } /* end else */
+        } /* end else */
+    } /* end if */
+    else {
+        if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0) {
+            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+                      "block write failed");
+        }
+    } /* end else */
+
+    FUNC_LEAVE(SUCCEED);
+}   /* End H5F_contig_write() */
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index e8e36e4..50d6707 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -503,6 +503,12 @@ __DLL__ herr_t H5F_istore_dump_btree(H5F_t *f, FILE *stream, int ndims,
 				     haddr_t addr);
 
 /* Functions that operate on contiguous storage wrt boot block */
+__DLL__ herr_t H5F_contig_read(H5F_t *f, haddr_t addr, hsize_t size,
+                hid_t dxpl_id, void *_buf/*out*/);
+__DLL__ herr_t H5F_contig_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
+                  hsize_t size, hid_t dxpl_id, const void *buf);
+
+/* Functions that operate on blocks of bytes wrt boot block */
 __DLL__ herr_t H5F_block_read(H5F_t *f, haddr_t addr, hsize_t size,
 			      hid_t dxpl_id, void *buf/*out*/);
 __DLL__ herr_t H5F_block_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
diff --git a/src/Makefile.in b/src/Makefile.in
index c85ad3d..5d975bf 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -19,10 +19,10 @@ LIB=libhdf5.la
 CLEAN=libhdf5.settings
 
 ## Source and object files for the library (lexicographically)...
-LIB_SRC=H5.c H5A.c H5AC.c H5B.c H5D.c H5E.c H5F.c H5Farray.c H5Fistore.c \
-    H5FD.c H5FDsec2.c H5FDfamily.c H5FDmpio.c H5FDcore.c H5FDdpss.c H5FDmulti.c\
-    H5FDgass.c H5FDlog.c H5FDsrb.c H5FDstdio.c H5FDstream.c H5FL.c H5G.c \
-    H5Gent.c H5Gnode.c H5Gstab.c H5HG.c H5HL.c H5I.c H5MF.c H5MM.c H5O.c \
+LIB_SRC=H5.c H5A.c H5AC.c H5B.c H5D.c H5E.c H5F.c H5Farray.c H5Fcontig.c \
+    H5Fistore.c H5FD.c H5FDsec2.c H5FDfamily.c H5FDmpio.c H5FDcore.c H5FDdpss.c \
+    H5FDmulti.c H5FDgass.c H5FDlog.c H5FDsrb.c H5FDstdio.c H5FDstream.c H5FL.c \
+    H5G.c H5Gent.c H5Gnode.c H5Gstab.c H5HG.c H5HL.c H5I.c H5MF.c H5MM.c H5O.c \
     H5Oattr.c H5Ocomp.c H5Ocont.c H5Odtype.c H5Oefl.c H5Ofill.c H5Olayout.c \
     H5Omtime.c H5Oname.c H5Onull.c H5Osdspace.c H5Oshared.c H5Ostab.c H5P.c \
     H5R.c H5RA.c H5S.c H5Sall.c H5Shyper.c H5Smpio.c H5Snone.c H5Spoint.c \