diff options
Diffstat (limited to 'src/H5Flow.c')
| -rw-r--r-- | src/H5Flow.c | 944 |
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 */ } |