summaryrefslogtreecommitdiffstats
path: root/src/H5Flow.c
diff options
context:
space:
mode:
authorQuincey Koziol <koziol@hdfgroup.org>1998-01-16 22:23:43 (GMT)
committerQuincey Koziol <koziol@hdfgroup.org>1998-01-16 22:23:43 (GMT)
commitc2c94c31878dc42926661c9cb7e71be620196fc1 (patch)
treeee9ce2ae309882348dc1eafc1d105b5e6646605e /src/H5Flow.c
parent903e677366a86ea385d5cfe1241f3f53132941de (diff)
downloadhdf5-c2c94c31878dc42926661c9cb7e71be620196fc1.zip
hdf5-c2c94c31878dc42926661c9cb7e71be620196fc1.tar.gz
hdf5-c2c94c31878dc42926661c9cb7e71be620196fc1.tar.bz2
[svn-r157] Reformatted code with indent...
Diffstat (limited to 'src/H5Flow.c')
-rw-r--r--src/H5Flow.c944
1 files changed, 462 insertions, 482 deletions
diff --git a/src/H5Flow.c b/src/H5Flow.c
index 3871aca..e61d087 100644
--- a/src/H5Flow.c
+++ b/src/H5Flow.c
@@ -5,10 +5,10 @@
* Programmer: Robb Matzke <matzke@viper.llnl.gov>
* Wednesday, October 22, 1997
*
- * Purpose: This file contains virtual functions for the H5F_low
- * class. These are functions that operate on various kinds
- * of files at a level where the file is just a one-dimensional
- * array of bytes.
+ * Purpose: This file contains virtual functions for the H5F_low
+ * class. These are functions that operate on various kinds
+ * of files at a level where the file is just a one-dimensional
+ * array of bytes.
*/
#include <H5private.h>
#include <H5Eprivate.h>
@@ -20,139 +20,135 @@
#define addr_defined(X) (-1!=(X)->offset && (X)->offset>=0)
-#define PABLO_MASK H5F_low
-static hbool_t interface_initialize_g = FALSE;
+#define PABLO_MASK H5F_low
+static hbool_t interface_initialize_g = FALSE;
#define INTERFACE_INIT NULL
-
/*-------------------------------------------------------------------------
- * Function: H5F_low_open
+ * Function: H5F_low_open
*
- * Purpose: Opens a file of type TYPE with name NAME according to the
- * field of bit flags FLAGS which are:
- *
- * H5F_ACC_WRITE: The file is open for read/write access.
- * Without this bit set, the file would be open
- * for read-only access.
+ * Purpose: Opens a file of type TYPE with name NAME according to the
+ * field of bit flags FLAGS which are:
+ *
+ * H5F_ACC_WRITE: The file is open for read/write access.
+ * Without this bit set, the file would be open
+ * for read-only access.
*
- * H5F_ACC_CREAT: The file is created if it doesn't already
- * exist. On unix, the file permissions are set
- * to 0666 modified by the umask.
+ * H5F_ACC_CREAT: The file is created if it doesn't already
+ * exist. On unix, the file permissions are set
+ * to 0666 modified by the umask.
*
- * H5F_ACC_EXCL: This function will fail if the file already
- * exists.
+ * H5F_ACC_EXCL: This function will fail if the file already
+ * exists.
*
- * H5F_ACC_TRUNC: Truncate the file to a zero-length file as it
- * is opened. This allows existing files to be
- * overwritten.
+ * H5F_ACC_TRUNC: Truncate the file to a zero-length file as it
+ * is opened. This allows existing files to be
+ * overwritten.
*
- * The KEY argument is initialized with data which is unique to
- * this file. Opening the same file (even by a different name)
- * should return the same key.
+ * The KEY argument is initialized with data which is unique to
+ * this file. Opening the same file (even by a different name)
+ * should return the same key.
*
- * This is a virtual function only; the actual open operation is
- * performed by the subclass. This function will fail if the
- * subclass hasn't defined an open method.
+ * This is a virtual function only; the actual open operation is
+ * performed by the subclass. This function will fail if the
+ * subclass hasn't defined an open method.
*
* Errors:
- * IO CANTOPENFILE Open failed.
+ * IO CANTOPENFILE Open failed.
*
- * Return: Success: Pointer to the new file descriptor.
+ * Return: Success: Pointer to the new file descriptor.
*
- * Failure: NULL
+ * Failure: NULL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
-H5F_low_t *
-H5F_low_open (const H5F_low_class_t *type, const char *name, uintn flags,
- H5F_search_t *key/*out*/)
+H5F_low_t *
+H5F_low_open(const H5F_low_class_t *type, const char *name, uintn flags,
+ H5F_search_t *key /*out */ )
{
- H5F_low_t *lf = NULL;
-
- FUNC_ENTER (H5F_low_open, NULL);
+ H5F_low_t *lf = NULL;
- assert (type && type->open);
- assert (name && *name);
+ FUNC_ENTER(H5F_low_open, NULL);
- if (NULL==(lf=(type->open)(name, flags, key))) {
- HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
- }
- lf->type = type;
+ assert(type && type->open);
+ assert(name && *name);
- FUNC_LEAVE (lf);
-}
+ if (NULL == (lf = (type->open) (name, flags, key))) {
+ HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
+ }
+ lf->type = type;
+ FUNC_LEAVE(lf);
+}
/*-------------------------------------------------------------------------
- * Function: H5F_low_close
+ * Function: H5F_low_close
*
- * Purpose: Closes a low-level file. The subclass should free all
- * resources used by the file descriptor but should not free the
- * file descriptor itself. The close method in the subclass is
- * optional; lack of a close method results in only the file
- * descriptor being freed.
+ * Purpose: Closes a low-level file. The subclass should free all
+ * resources used by the file descriptor but should not free the
+ * file descriptor itself. The close method in the subclass is
+ * optional; lack of a close method results in only the file
+ * descriptor being freed.
*
- * It is safe to call this function with a null pointer for the
- * file descriptor. This function returns a null pointer that
- * the caller can assign to the file descriptor pointer as it's
- * closed like `desc=H5F_low_close(desc)'.
+ * It is safe to call this function with a null pointer for the
+ * file descriptor. This function returns a null pointer that
+ * the caller can assign to the file descriptor pointer as it's
+ * closed like `desc=H5F_low_close(desc)'.
*
* Errors:
- * IO CLOSEERROR Close failed.
+ * IO CLOSEERROR Close failed.
*
- * Return: Success: NULL
+ * Return: Success: NULL
*
- * Failure: NULL
+ * Failure: NULL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
-H5F_low_t *
-H5F_low_close (H5F_low_t *lf)
+H5F_low_t *
+H5F_low_close(H5F_low_t *lf)
{
- FUNC_ENTER (H5F_low_close, NULL);
-
- if (lf) {
- if ((lf->type->close)(lf)<0) {
- H5MM_xfree (lf);
- HRETURN_ERROR (H5E_IO, H5E_CLOSEERROR, NULL, "close failed");
- }
- H5MM_xfree (lf);
- }
-
- FUNC_LEAVE (NULL);
+ FUNC_ENTER(H5F_low_close, NULL);
+
+ if (lf) {
+ if ((lf->type->close) (lf) < 0) {
+ H5MM_xfree(lf);
+ HRETURN_ERROR(H5E_IO, H5E_CLOSEERROR, NULL, "close failed");
+ }
+ H5MM_xfree(lf);
+ }
+ FUNC_LEAVE(NULL);
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_low_read
+ * Function: H5F_low_read
*
- * Purpose: Reads SIZE bytes of data beginning at address ADDR of the
- * file LF and puts the result in BUF. Behavior when reading
- * past the logical or physical end of file is to return zeros
- * for that part of the request.
+ * Purpose: Reads SIZE bytes of data beginning at address ADDR of the
+ * file LF and puts the result in BUF. Behavior when reading
+ * past the logical or physical end of file is to return zeros
+ * for that part of the request.
*
- * This is only a virtual function; the subclass must define a
- * read method or this function will fail.
+ * This is only a virtual function; the subclass must define a
+ * read method or this function will fail.
*
* Errors:
- * IO READERROR Read failed.
- * IO UNSUPPORTED No read method.
+ * IO READERROR Read failed.
+ * IO UNSUPPORTED No read method.
*
- * Return: Success: SUCCEED
+ * Return: Success: SUCCEED
*
- * Failure: FAIL
+ * Failure: FAIL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
@@ -160,48 +156,47 @@ H5F_low_close (H5F_low_t *lf)
*-------------------------------------------------------------------------
*/
herr_t
-H5F_low_read (H5F_low_t *lf, const haddr_t *addr, size_t size,
- uint8 *buf/*out*/)
+H5F_low_read(H5F_low_t *lf, const haddr_t *addr, size_t size,
+ uint8 *buf /*out */ )
{
- herr_t ret_value = FAIL;
-
- FUNC_ENTER (H5F_low_read, FAIL);
-
- assert (lf && lf->type);
- assert (addr && addr_defined (addr));
- assert (buf);
-
- if (lf->type->read) {
- if ((ret_value = (lf->type->read)(lf, addr, size, buf))<0) {
- HRETURN_ERROR (H5E_IO, H5E_READERROR, ret_value, "read failed");
- }
- } else {
- HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "no read method");
- }
-
- FUNC_LEAVE (ret_value);
-}
+ herr_t ret_value = FAIL;
+
+ FUNC_ENTER(H5F_low_read, FAIL);
+
+ assert(lf && lf->type);
+ assert(addr && addr_defined(addr));
+ assert(buf);
+
+ if (lf->type->read) {
+ if ((ret_value = (lf->type->read) (lf, addr, size, buf)) < 0) {
+ HRETURN_ERROR(H5E_IO, H5E_READERROR, ret_value, "read failed");
+ }
+ } else {
+ HRETURN_ERROR(H5E_IO, H5E_UNSUPPORTED, FAIL, "no read method");
+ }
+ FUNC_LEAVE(ret_value);
+}
/*-------------------------------------------------------------------------
- * Function: H5F_low_write
+ * Function: H5F_low_write
*
- * Purpose: Writes SIZE bytes of data from BUF into the file LF beginning
- * at address ADDR of the file. Writing past the logical or
- * physical end of file causes the file to be extended.
+ * Purpose: Writes SIZE bytes of data from BUF into the file LF beginning
+ * at address ADDR of the file. Writing past the logical or
+ * physical end of file causes the file to be extended.
*
- * This is a virtual function only; if the subclass doesn't
- * define a write method then this function will fail.
+ * This is a virtual function only; if the subclass doesn't
+ * define a write method then this function will fail.
*
* Errors:
- * IO UNSUPPORTED No write method.
- * IO WRITEERROR Write failed.
+ * IO UNSUPPORTED No write method.
+ * IO WRITEERROR Write failed.
*
- * Return: Success: SUCCEED
+ * Return: Success: SUCCEED
*
- * Failure: FAIL
+ * Failure: FAIL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
@@ -209,57 +204,55 @@ H5F_low_read (H5F_low_t *lf, const haddr_t *addr, size_t size,
*-------------------------------------------------------------------------
*/
herr_t
-H5F_low_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
- const uint8 *buf)
+H5F_low_write(H5F_low_t *lf, const haddr_t *addr, size_t size,
+ const uint8 *buf)
{
- herr_t ret_value = FAIL;
- haddr_t tmp_addr;
-
- FUNC_ENTER (H5F_low_write, FAIL);
-
- assert (lf && lf->type);
- assert (addr && addr_defined (addr));
- assert (buf);
-
- /* Extend the file eof marker if we write past it */
- tmp_addr = *addr;
- H5F_addr_inc (&tmp_addr, size);
- if (H5F_addr_gt (&tmp_addr, &(lf->eof))) {
- fprintf (stderr, "HDF5-DIAG: extending file w/o allocation\n");
- lf->eof = tmp_addr;
- }
-
- /* Write the data */
- if (lf->type->write) {
- if ((ret_value = (lf->type->write)(lf, addr, size, buf))<0) {
- HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, ret_value, "write failed");
- }
- } else {
- HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "no write method");
- }
-
- FUNC_LEAVE (ret_value);
+ herr_t ret_value = FAIL;
+ haddr_t tmp_addr;
+
+ FUNC_ENTER(H5F_low_write, FAIL);
+
+ assert(lf && lf->type);
+ assert(addr && addr_defined(addr));
+ assert(buf);
+
+ /* Extend the file eof marker if we write past it */
+ tmp_addr = *addr;
+ H5F_addr_inc(&tmp_addr, size);
+ if (H5F_addr_gt(&tmp_addr, &(lf->eof))) {
+ fprintf(stderr, "HDF5-DIAG: extending file w/o allocation\n");
+ lf->eof = tmp_addr;
+ }
+ /* Write the data */
+ if (lf->type->write) {
+ if ((ret_value = (lf->type->write) (lf, addr, size, buf)) < 0) {
+ HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, ret_value, "write failed");
+ }
+ } else {
+ HRETURN_ERROR(H5E_IO, H5E_UNSUPPORTED, FAIL, "no write method");
+ }
+
+ FUNC_LEAVE(ret_value);
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_low_flush
+ * Function: H5F_low_flush
*
- * Purpose: Flushes file buffers to disk. For instance, the stdio.h
- * driver would call fflush(). Flushing also insures that the
- * file exists to the current logical EOF (the library maintains
- * a notion of EOF which is independent of the physical EOF) by
- * reading and writing the last byte. On some systems, this
- * allocates a single block at the end of the file while on
- * other systems it allocates all blocks up to the end of the
- * file. Extending the physical file is necessary because
- * H5F_open() checks for truncated files.
+ * Purpose: Flushes file buffers to disk. For instance, the stdio.h
+ * driver would call fflush(). Flushing also insures that the
+ * file exists to the current logical EOF (the library maintains
+ * a notion of EOF which is independent of the physical EOF) by
+ * reading and writing the last byte. On some systems, this
+ * allocates a single block at the end of the file while on
+ * other systems it allocates all blocks up to the end of the
+ * file. Extending the physical file is necessary because
+ * H5F_open() checks for truncated files.
*
- * Return: Success: SUCCEED
+ * Return: Success: SUCCEED
*
- * Failure: FAIL
+ * Failure: FAIL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Monday, November 10, 1997
*
* Modifications:
@@ -267,63 +260,60 @@ H5F_low_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
*-------------------------------------------------------------------------
*/
herr_t
-H5F_low_flush (H5F_low_t *lf)
+H5F_low_flush(H5F_low_t *lf)
{
- haddr_t last_byte;
- uint8 buf[1];
-
- FUNC_ENTER (H5F_low_flush, FAIL);
-
- assert (lf && lf->type);
-
- /* Make sure the last block of the file has been allocated on disk */
- H5F_addr_reset (&last_byte);
- if (addr_defined (&(lf->eof)) && H5F_addr_gt (&(lf->eof), &last_byte)) {
- last_byte = lf->eof;
- last_byte.offset -= 1;
- if (H5F_low_read (lf, &last_byte, 1, buf)>=0) {
- H5F_low_write (lf, &last_byte, 1, buf);
- }
- }
-
- /* Invoke the subclass the flush method */
- if (lf->type->flush) {
- if ((lf->type->flush)(lf)<0) {
- HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
- "low level flush failed");
- }
- }
-
- FUNC_LEAVE (SUCCEED);
+ haddr_t last_byte;
+ uint8 buf[1];
+
+ FUNC_ENTER(H5F_low_flush, FAIL);
+
+ assert(lf && lf->type);
+
+ /* Make sure the last block of the file has been allocated on disk */
+ H5F_addr_reset(&last_byte);
+ if (addr_defined(&(lf->eof)) && H5F_addr_gt(&(lf->eof), &last_byte)) {
+ last_byte = lf->eof;
+ last_byte.offset -= 1;
+ if (H5F_low_read(lf, &last_byte, 1, buf) >= 0) {
+ H5F_low_write(lf, &last_byte, 1, buf);
+ }
+ }
+ /* Invoke the subclass the flush method */
+ if (lf->type->flush) {
+ if ((lf->type->flush) (lf) < 0) {
+ HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,
+ "low level flush failed");
+ }
+ }
+ FUNC_LEAVE(SUCCEED);
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_low_size
- *
- * Purpose: Returns the current logical size of the file in bytes. This
- * may differ from the physical size of the file (most
- * subclasses extend the physical file size during the write
- * operation instead of the alloc operation).
- *
- * The next absolute file address is returned through the
- * EOF argument. This is the address of the logical end of
- * file (that is, the address of the first byte past the last
- * byte which is logically in the file).
- *
- * Warning: The return value type (size_t) may not be large enough to
- * represent the true size of the file. In such cases, the
- * maximum possible size is returned. It is better to look at
- * the EOF output argument to determine the total size.
+ * Function: H5F_low_size
+ *
+ * Purpose: Returns the current logical size of the file in bytes. This
+ * may differ from the physical size of the file (most
+ * subclasses extend the physical file size during the write
+ * operation instead of the alloc operation).
+ *
+ * The next absolute file address is returned through the
+ * EOF argument. This is the address of the logical end of
+ * file (that is, the address of the first byte past the last
+ * byte which is logically in the file).
+ *
+ * Warning: The return value type (size_t) may not be large enough to
+ * represent the true size of the file. In such cases, the
+ * maximum possible size is returned. It is better to look at
+ * the EOF output argument to determine the total size.
*
* Errors:
- * IO UNSUPPORTED No size method.
+ * IO UNSUPPORTED No size method.
*
- * Return: Success: Current size of file
+ * Return: Success: Current size of file
*
- * Failure: 0
+ * Failure: 0
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
@@ -331,50 +321,50 @@ H5F_low_flush (H5F_low_t *lf)
*-------------------------------------------------------------------------
*/
size_t
-H5F_low_size (H5F_low_t *lf, haddr_t *eof/*out*/)
+H5F_low_size(H5F_low_t *lf, haddr_t *eof /*out */ )
{
- size_t size = (size_t)(-1); /*max possible size*/
-
- FUNC_ENTER (H5F_low_size, 0);
+ size_t size = (size_t) (-1); /*max possible size */
- assert (lf && lf->type);
- assert (eof);
+ FUNC_ENTER(H5F_low_size, 0);
- *eof = lf->eof;
- if (eof->offset < size) size = eof->offset;
+ assert(lf && lf->type);
+ assert(eof);
- FUNC_LEAVE (size);
-}
+ *eof = lf->eof;
+ if (eof->offset < size)
+ size = eof->offset;
+ FUNC_LEAVE(size);
+}
/*-------------------------------------------------------------------------
- * Function: H5F_low_access
+ * Function: H5F_low_access
*
- * Purpose: Determines if a file can be accessed in a particular way by a
- * particular subclass. The access modes for a file are the
- * same as those of access(2), namely
+ * Purpose: Determines if a file can be accessed in a particular way by a
+ * particular subclass. The access modes for a file are the
+ * same as those of access(2), namely
*
- * F_OK: determines if the file (or all parts of a multi-part
- * file) exists.
+ * F_OK: determines if the file (or all parts of a multi-part
+ * file) exists.
*
- * R_OK: determines if the file (or all parts of a multi-part
- * file) are readable.
+ * R_OK: determines if the file (or all parts of a multi-part
+ * file) are readable.
*
- * W_OK: determines if the file (or all parts of a multi-part
- * file) are writable.
+ * W_OK: determines if the file (or all parts of a multi-part
+ * file) are writable.
*
- * If a subclass doesn't define an access method, then we treat
- * the name as if it were a local Unix file and test
- * accessibility with the access(2) function. The KEY is
- * returned as a device number and i-node pair.
+ * If a subclass doesn't define an access method, then we treat
+ * the name as if it were a local Unix file and test
+ * accessibility with the access(2) function. The KEY is
+ * returned as a device number and i-node pair.
*
- * Return: Success: TRUE or FALSE. If TRUE, then KEY is
- * initialized with data that makes this file
- * unique (same value as H5F_low_open).
+ * Return: Success: TRUE or FALSE. If TRUE, then KEY is
+ * initialized with data that makes this file
+ * unique (same value as H5F_low_open).
*
- * Failure: FAIL, KEY is undefined.
+ * Failure: FAIL, KEY is undefined.
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, October 24, 1997
*
* Modifications:
@@ -382,46 +372,45 @@ H5F_low_size (H5F_low_t *lf, haddr_t *eof/*out*/)
*-------------------------------------------------------------------------
*/
hbool_t
-H5F_low_access (const H5F_low_class_t *type, const char *name, int mode,
- H5F_search_t *key/*out*/)
+H5F_low_access(const H5F_low_class_t *type, const char *name, int mode,
+ H5F_search_t *key /*out */ )
{
- hbool_t ret_value;
- struct stat sb;
-
- FUNC_ENTER (H5F_low_size, 0);
- assert (type);
-
- if (type->access) {
- ret_value = (type->access)(name, mode, key/*out*/);
-
- } else {
- ret_value = (0==access (name, mode));
- if (key) {
- stat (name, &sb);
- key->dev = sb.st_dev;
- key->ino = sb.st_ino;
- }
- }
-
- FUNC_LEAVE (ret_value);
-}
+ hbool_t ret_value;
+ struct stat sb;
+
+ FUNC_ENTER(H5F_low_size, 0);
+ assert(type);
+
+ if (type->access) {
+ ret_value = (type->access) (name, mode, key /*out */ );
+
+ } else {
+ ret_value = (0 == access(name, mode));
+ if (key) {
+ stat(name, &sb);
+ key->dev = sb.st_dev;
+ key->ino = sb.st_ino;
+ }
+ }
+ FUNC_LEAVE(ret_value);
+}
/*-------------------------------------------------------------------------
- * Function: H5F_low_extend
+ * Function: H5F_low_extend
*
- * Purpose: Increases the logical size of a file by moving the logical
- * end of file marker. A subclass can override this function by
- * providing its own allocation method.
+ * Purpose: Increases the logical size of a file by moving the logical
+ * end of file marker. A subclass can override this function by
+ * providing its own allocation method.
*
- * Return: Success: SUCCEED, the address of the old end-of-file
- * is returned through the ADDR argument and the
- * logical size of the file has been extended by
- * SIZE bytes.
+ * Return: Success: SUCCEED, the address of the old end-of-file
+ * is returned through the ADDR argument and the
+ * logical size of the file has been extended by
+ * SIZE bytes.
*
- * Failure: FAIL
+ * Failure: FAIL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Thursday, November 13, 1997
*
* Modifications:
@@ -429,38 +418,37 @@ H5F_low_access (const H5F_low_class_t *type, const char *name, int mode,
*-------------------------------------------------------------------------
*/
herr_t
-H5F_low_extend (H5F_low_t *lf, intn op, size_t size, haddr_t *addr/*out*/)
+H5F_low_extend(H5F_low_t *lf, intn op, size_t size, haddr_t *addr /*out */ )
{
- FUNC_ENTER (H5F_low_alloc, FAIL);
-
- assert (lf);
- assert (size>0);
- assert (addr);
-
- if (lf->type->extend) {
- if ((lf->type->extend)(lf, op, size, addr/*out*/)<0) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "unable to extend file");
- }
- } else {
- *addr = lf->eof;
- H5F_addr_inc (&(lf->eof), size);
- }
-
- FUNC_LEAVE (SUCCEED);
+ FUNC_ENTER(H5F_low_alloc, FAIL);
+
+ assert(lf);
+ assert(size > 0);
+ assert(addr);
+
+ if (lf->type->extend) {
+ if ((lf->type->extend) (lf, op, size, addr /*out */ ) < 0) {
+ HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ "unable to extend file");
+ }
+ } else {
+ *addr = lf->eof;
+ H5F_addr_inc(&(lf->eof), size);
+ }
+
+ FUNC_LEAVE(SUCCEED);
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_low_seteof
+ * Function: H5F_low_seteof
*
- * Purpose: Sets the logical end-of-file to the specified address.
+ * Purpose: Sets the logical end-of-file to the specified address.
*
- * Return: Success: SUCCEED
+ * Return: Success: SUCCEED
*
- * Failure: FAIL
+ * Failure: FAIL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Thursday, November 13, 1997
*
* Modifications:
@@ -468,31 +456,30 @@ H5F_low_extend (H5F_low_t *lf, intn op, size_t size, haddr_t *addr/*out*/)
*-------------------------------------------------------------------------
*/
herr_t
-H5F_low_seteof (H5F_low_t *lf, const haddr_t *addr)
+H5F_low_seteof(H5F_low_t *lf, const haddr_t *addr)
{
- FUNC_ENTER (H5F_low_seteof, FAIL);
+ FUNC_ENTER(H5F_low_seteof, FAIL);
- assert (lf);
- assert (addr && addr_defined (addr));
+ assert(lf);
+ assert(addr && addr_defined(addr));
- lf->eof = *addr;
+ lf->eof = *addr;
- FUNC_LEAVE (SUCCEED);
+ FUNC_LEAVE(SUCCEED);
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_cmp
+ * Function: H5F_addr_cmp
*
- * Purpose: Compares two addresses.
+ * Purpose: Compares two addresses.
*
- * Return: Success: <0 if A1<A2
- * =0 if A1=A2
- * >0 if A1>A2
+ * Return: Success: <0 if A1<A2
+ * =0 if A1=A2
+ * >0 if A1>A2
*
- * Failure: never fails
+ * Failure: never fails
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -500,28 +487,29 @@ H5F_low_seteof (H5F_low_t *lf, const haddr_t *addr)
*-------------------------------------------------------------------------
*/
intn
-H5F_addr_cmp (const haddr_t *a1, const haddr_t *a2)
+H5F_addr_cmp(const haddr_t *a1, const haddr_t *a2)
{
- FUNC_ENTER (H5F_addr_cmp, FAIL);
-
- assert (a1 && addr_defined (a1));
- assert (a2 && addr_defined (a2));
+ FUNC_ENTER(H5F_addr_cmp, FAIL);
- if (a1->offset<a2->offset) HRETURN (-1);
- if (a1->offset>a2->offset) HRETURN (1);
+ assert(a1 && addr_defined(a1));
+ assert(a2 && addr_defined(a2));
- FUNC_LEAVE (0);
-}
+ if (a1->offset < a2->offset)
+ HRETURN(-1);
+ if (a1->offset > a2->offset)
+ HRETURN(1);
+ FUNC_LEAVE(0);
+}
/*-------------------------------------------------------------------------
- * Function: H5F_addr_undef
+ * Function: H5F_addr_undef
*
- * Purpose: Cause an address to become undefined.
+ * Purpose: Cause an address to become undefined.
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -529,24 +517,23 @@ H5F_addr_cmp (const haddr_t *a1, const haddr_t *a2)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_undef (haddr_t *addr/*out*/)
+H5F_addr_undef(haddr_t *addr /*out */ )
{
- assert (addr);
-
- addr->offset = -1;
-}
+ assert(addr);
+ addr->offset = -1;
+}
/*-------------------------------------------------------------------------
- * Function: H5F_addr_defined
+ * Function: H5F_addr_defined
*
- * Purpose: Determines if an address has a defined value.
+ * Purpose: Determines if an address has a defined value.
*
- * Return: Success: TRUE or FALSE
+ * Return: Success: TRUE or FALSE
*
- * Failure: FAIL
+ * Failure: FAIL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -554,21 +541,20 @@ H5F_addr_undef (haddr_t *addr/*out*/)
*-------------------------------------------------------------------------
*/
hbool_t
-H5F_addr_defined (const haddr_t *addr)
+H5F_addr_defined(const haddr_t *addr)
{
- FUNC_ENTER (H5F_addr_defined, FAIL);
- FUNC_LEAVE (addr_defined (addr));
+ FUNC_ENTER(H5F_addr_defined, FAIL);
+ FUNC_LEAVE(addr_defined(addr));
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_reset
+ * Function: H5F_addr_reset
*
- * Purpose: Reset the address to zero.
+ * Purpose: Reset the address to zero.
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -576,23 +562,22 @@ H5F_addr_defined (const haddr_t *addr)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_reset (haddr_t *addr/*out*/)
+H5F_addr_reset(haddr_t *addr /*out */ )
{
- assert (addr);
- addr->offset = 0;
+ assert(addr);
+ addr->offset = 0;
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_zerop
+ * Function: H5F_addr_zerop
*
- * Purpose: Determines if an address is zero.
+ * Purpose: Determines if an address is zero.
*
- * Return: Success: TRUE or FALSE
+ * Return: Success: TRUE or FALSE
*
- * Failure: FAIL
+ * Failure: FAIL
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -600,23 +585,22 @@ H5F_addr_reset (haddr_t *addr/*out*/)
*-------------------------------------------------------------------------
*/
hbool_t
-H5F_addr_zerop (const haddr_t *addr)
+H5F_addr_zerop(const haddr_t *addr)
{
- FUNC_ENTER (H5F_addr_zerop, FAIL);
- FUNC_LEAVE (0==addr->offset);
+ FUNC_ENTER(H5F_addr_zerop, FAIL);
+ FUNC_LEAVE(0 == addr->offset);
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_encode
+ * Function: H5F_addr_encode
*
- * Purpose: Encodes an address into the buffer pointed to by *PP and
- * then increments the pointer to the first byte after the
- * address. An undefined value is stored as all 1's.
+ * Purpose: Encodes an address into the buffer pointed to by *PP and
+ * then increments the pointer to the first byte after the
+ * address. An undefined value is stored as all 1's.
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -624,44 +608,43 @@ H5F_addr_zerop (const haddr_t *addr)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_encode (H5F_t *f, uint8 **pp, const haddr_t *addr)
+H5F_addr_encode(H5F_t *f, uint8 **pp, const haddr_t *addr)
{
- int i;
- haddr_t tmp;
-
- assert (f);
- assert (pp && *pp);
- assert (addr);
-
- if (addr_defined (addr)) {
- tmp = *addr;
- for (i=0; i<H5F_SIZEOF_ADDR (f); i++) {
- *(*pp)++ = tmp.offset & 0xff;
- tmp.offset >>= 8;
- }
- assert ("overflow" && 0==tmp.offset);
-
- } else {
- for (i=0; i<H5F_SIZEOF_ADDR (f); i++) {
- *(*pp)++ = 0xff;
- }
- }
+ int i;
+ haddr_t tmp;
+
+ assert(f);
+ assert(pp && *pp);
+ assert(addr);
+
+ if (addr_defined(addr)) {
+ tmp = *addr;
+ for (i = 0; i < H5F_SIZEOF_ADDR(f); i++) {
+ *(*pp)++ = tmp.offset & 0xff;
+ tmp.offset >>= 8;
+ }
+ assert("overflow" && 0 == tmp.offset);
+
+ } else {
+ for (i = 0; i < H5F_SIZEOF_ADDR(f); i++) {
+ *(*pp)++ = 0xff;
+ }
+ }
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_decode
+ * Function: H5F_addr_decode
*
- * Purpose: Decodes an address from the buffer pointed to by *PP and
- * updates the pointer to point to the next byte after the
- * address.
+ * Purpose: Decodes an address from the buffer pointed to by *PP and
+ * updates the pointer to point to the next byte after the
+ * address.
*
- * If the value read is all 1's then the address is returned
- * with an undefined value.
+ * If the value read is all 1's then the address is returned
+ * with an undefined value.
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -669,43 +652,44 @@ H5F_addr_encode (H5F_t *f, uint8 **pp, const haddr_t *addr)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_decode (H5F_t *f, const uint8 **pp, haddr_t *addr/*out*/)
+H5F_addr_decode(H5F_t *f, const uint8 **pp, haddr_t *addr /*out */ )
{
- int i;
- haddr_t tmp;
- uint8 c;
- hbool_t all_zero = TRUE;
-
- assert (f);
- assert (pp && *pp);
- assert (addr);
-
- addr->offset = 0;
-
- for (i=0; i<H5F_SIZEOF_ADDR (f); i++) {
- c = *(*pp)++;
- if (c!=0xff) all_zero = FALSE;
-
- if (i<sizeof(addr->offset)) {
- tmp.offset = c;
- tmp.offset <<= i*8; /*use tmp to get casting right*/
- addr->offset |= tmp.offset;
- } else if (!all_zero) {
- assert (0==**pp); /*overflow*/
- }
- }
- if (all_zero) H5F_addr_undef (addr);
+ int i;
+ haddr_t tmp;
+ uint8 c;
+ hbool_t all_zero = TRUE;
+
+ assert(f);
+ assert(pp && *pp);
+ assert(addr);
+
+ addr->offset = 0;
+
+ for (i = 0; i < H5F_SIZEOF_ADDR(f); i++) {
+ c = *(*pp)++;
+ if (c != 0xff)
+ all_zero = FALSE;
+
+ if (i < sizeof(addr->offset)) {
+ tmp.offset = c;
+ tmp.offset <<= i * 8; /*use tmp to get casting right */
+ addr->offset |= tmp.offset;
+ } else if (!all_zero) {
+ assert(0 == **pp); /*overflow */
+ }
+ }
+ if (all_zero)
+ H5F_addr_undef(addr);
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_print
+ * Function: H5F_addr_print
*
- * Purpose: Print an address
+ * Purpose: Print an address
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -713,43 +697,42 @@ H5F_addr_decode (H5F_t *f, const uint8 **pp, haddr_t *addr/*out*/)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_print (FILE *stream, const haddr_t *addr)
+H5F_addr_print(FILE * stream, const haddr_t *addr)
{
- haddr_t tmp;
-
- assert (stream);
- assert (addr);
-
- if (addr_defined (addr)) {
- /*
- * It would be nice if we could use the `%Lu', `%llu', or `%qu', but
- * we don't know which is supported. So we split the address into a
- * low 4-bytes and a high 4-bytes. If the high 4-bytes are non-zero
- * then we print the address in hexadecimal, otherwise we use decimal.
- */
- tmp = *addr;
- tmp.offset >>= 32;
- if (tmp.offset) {
- fprintf (stream, "0x%08lx%08lx",
- (unsigned long)(tmp.offset),
- (unsigned long)(addr->offset & 0xffffffff));
- } else {
- fprintf (stream, "%lu", (unsigned long)(addr->offset));
- }
- } else {
- fprintf (stream, "UNDEF");
- }
+ haddr_t tmp;
+
+ assert(stream);
+ assert(addr);
+
+ if (addr_defined(addr)) {
+ /*
+ * It would be nice if we could use the `%Lu', `%llu', or `%qu', but
+ * we don't know which is supported. So we split the address into a
+ * low 4-bytes and a high 4-bytes. If the high 4-bytes are non-zero
+ * then we print the address in hexadecimal, otherwise we use decimal.
+ */
+ tmp = *addr;
+ tmp.offset >>= 32;
+ if (tmp.offset) {
+ fprintf(stream, "0x%08lx%08lx",
+ (unsigned long) (tmp.offset),
+ (unsigned long) (addr->offset & 0xffffffff));
+ } else {
+ fprintf(stream, "%lu", (unsigned long) (addr->offset));
+ }
+ } else {
+ fprintf(stream, "UNDEF");
+ }
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_pow2
+ * Function: H5F_addr_pow2
*
- * Purpose: Returns an address which is a power of two.
+ * Purpose: Returns an address which is a power of two.
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -757,25 +740,24 @@ H5F_addr_print (FILE *stream, const haddr_t *addr)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_pow2 (uintn n, haddr_t *addr/*out*/)
+H5F_addr_pow2(uintn n, haddr_t *addr /*out */ )
{
- assert (n>=0);
- assert (addr);
- assert (n<8*sizeof(addr->offset));
+ assert(n >= 0);
+ assert(addr);
+ assert(n < 8 * sizeof(addr->offset));
- addr->offset = 1;
- addr->offset <<= n;
+ addr->offset = 1;
+ addr->offset <<= n;
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_inc
+ * Function: H5F_addr_inc
*
- * Purpose: Increments an address by some number of bytes.
+ * Purpose: Increments an address by some number of bytes.
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -783,22 +765,21 @@ H5F_addr_pow2 (uintn n, haddr_t *addr/*out*/)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_inc (haddr_t *addr/*in,out*/, size_t inc)
+H5F_addr_inc(haddr_t *addr /*in,out */ , size_t inc)
{
- assert (addr && addr_defined (addr));
- assert (addr->offset<=addr->offset+inc);
- addr->offset += inc;
+ assert(addr && addr_defined(addr));
+ assert(addr->offset <= addr->offset + inc);
+ addr->offset += inc;
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_add
+ * Function: H5F_addr_add
*
- * Purpose: Adds two addresses and puts the result in the first argument.
+ * Purpose: Adds two addresses and puts the result in the first argument.
*
- * Return: void
+ * Return: void
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -806,25 +787,24 @@ H5F_addr_inc (haddr_t *addr/*in,out*/, size_t inc)
*-------------------------------------------------------------------------
*/
void
-H5F_addr_add (haddr_t *a1/*in,out*/, const haddr_t *a2)
+H5F_addr_add(haddr_t *a1 /*in,out */ , const haddr_t *a2)
{
- assert (a1 && addr_defined (a1));
- assert (a2 && addr_defined (a2));
- a1->offset += a2->offset;
+ assert(a1 && addr_defined(a1));
+ assert(a2 && addr_defined(a2));
+ a1->offset += a2->offset;
}
-
/*-------------------------------------------------------------------------
- * Function: H5F_addr_hash
+ * Function: H5F_addr_hash
*
- * Purpose: Computes a hash value of an address between 0 and MOD-1,
- * inclusive.
+ * Purpose: Computes a hash value of an address between 0 and MOD-1,
+ * inclusive.
*
- * Return: Success: The hash value
+ * Return: Success: The hash value
*
- * Failure: never fails
+ * Failure: never fails
*
- * Programmer: Robb Matzke
+ * Programmer: Robb Matzke
* Friday, November 7, 1997
*
* Modifications:
@@ -832,10 +812,10 @@ H5F_addr_add (haddr_t *a1/*in,out*/, const haddr_t *a2)
*-------------------------------------------------------------------------
*/
uintn
-H5F_addr_hash (const haddr_t *addr, uintn mod)
+H5F_addr_hash(const haddr_t *addr, uintn mod)
{
- assert (addr && addr_defined (addr));
- assert (mod>0);
+ assert(addr && addr_defined(addr));
+ assert(mod > 0);
- return addr->offset % mod; /*ignore file number*/
+ return addr->offset % mod; /*ignore file number */
}