diff options
Diffstat (limited to 'src/H5Flow.c')
| -rw-r--r-- | src/H5Flow.c | 643 |
1 files changed, 323 insertions, 320 deletions
diff --git a/src/H5Flow.c b/src/H5Flow.c index f29b7d3..5074815 100644 --- a/src/H5Flow.c +++ b/src/H5Flow.c @@ -1,14 +1,14 @@ /* * Copyright (C) 1997 NCSA - * All rights reserved. + * All rights reserved. * * Programmer: Robb Matzke <matzke@viper.llnl.gov> - * Wednesday, October 22, 1997 + * 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,8 +20,8 @@ #define addr_defined(X) (((uint64)(-1)!=(X)->offset) ? TRUE : FALSE) -#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 @@ -36,7 +36,7 @@ static hbool_t interface_initialize_g = FALSE; * Failure: NULL * * Programmer: Robb Matzke - * Wednesday, February 18, 1998 + * Wednesday, February 18, 1998 * * Modifications: * @@ -86,43 +86,43 @@ H5F_low_class (H5F_driver_t driver) /*------------------------------------------------------------------------- - * 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 - * Wednesday, October 22, 1997 + * Programmer: Robb Matzke + * Wednesday, October 22, 1997 * * Modifications: * @@ -133,7 +133,7 @@ H5F_low_open(const H5F_low_class_t *type, const char *name, const H5F_access_t *access_parms, uintn flags, H5F_search_t *key/*out*/) { - H5F_low_t *lf = NULL; + H5F_low_t *lf = NULL; FUNC_ENTER(H5F_low_open, NULL); @@ -141,7 +141,7 @@ H5F_low_open(const H5F_low_class_t *type, const char *name, assert(name && *name); if (NULL == (lf = (type->open) (name, access_parms, flags, key))) { - HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed"); + HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed"); } lf->type = type; @@ -149,28 +149,28 @@ H5F_low_open(const H5F_low_class_t *type, const char *name, } /*------------------------------------------------------------------------- - * 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 - * Wednesday, October 22, 1997 + * Programmer: Robb Matzke + * Wednesday, October 22, 1997 * * Modifications: * @@ -182,36 +182,36 @@ H5F_low_close(H5F_low_t *lf, const H5F_access_t *access_parms) FUNC_ENTER(H5F_low_close, NULL); if (lf) { - if ((lf->type->close) (lf, access_parms) < 0) { - H5MM_xfree(lf); - HRETURN_ERROR(H5E_IO, H5E_CLOSEERROR, NULL, "close failed"); - } - H5MM_xfree(lf); + if ((lf->type->close) (lf, access_parms) < 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 - * Wednesday, October 22, 1997 + * Programmer: Robb Matzke + * Wednesday, October 22, 1997 * * Modifications: * @@ -221,7 +221,7 @@ herr_t H5F_low_read(H5F_low_t *lf, const H5F_access_t *access_parms, const haddr_t *addr, size_t size, uint8 *buf/*out*/) { - herr_t ret_value = FAIL; + herr_t ret_value = FAIL; FUNC_ENTER(H5F_low_read, FAIL); @@ -230,37 +230,37 @@ H5F_low_read(H5F_low_t *lf, const H5F_access_t *access_parms, assert(buf); if (lf->type->read) { - if ((ret_value = (lf->type->read) (lf, access_parms, addr, size, + if ((ret_value = (lf->type->read) (lf, access_parms, addr, size, buf)) < 0) { - HRETURN_ERROR(H5E_IO, H5E_READERROR, ret_value, "read failed"); - } + HRETURN_ERROR(H5E_IO, H5E_READERROR, ret_value, "read failed"); + } } else { - HRETURN_ERROR(H5E_IO, H5E_UNSUPPORTED, FAIL, "no read method"); + 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 - * Wednesday, October 22, 1997 + * Programmer: Robb Matzke + * Wednesday, October 22, 1997 * * Modifications: * @@ -270,8 +270,8 @@ herr_t H5F_low_write(H5F_low_t *lf, const H5F_access_t *access_parms, const haddr_t *addr, size_t size, const uint8 *buf) { - herr_t ret_value = FAIL; - haddr_t tmp_addr; + herr_t ret_value = FAIL; + haddr_t tmp_addr; FUNC_ENTER(H5F_low_write, FAIL); @@ -281,43 +281,45 @@ H5F_low_write(H5F_low_t *lf, const H5F_access_t *access_parms, /* Extend the file eof marker if we write past it */ tmp_addr = *addr; - H5F_addr_inc(&tmp_addr, size); + H5F_addr_inc(&tmp_addr, (hsize_t)size); if (H5F_addr_gt(&tmp_addr, &(lf->eof))) { - fprintf(stderr, "H5F: extending file w/o allocation\n"); - lf->eof = tmp_addr; + fprintf(stderr, "H5F: extending file w/o allocation\n"); + lf->eof = tmp_addr; } + /* Write the data */ if (lf->type->write) { - if ((ret_value = (lf->type->write) (lf, access_parms, addr, size, + if ((ret_value = (lf->type->write) (lf, access_parms, addr, size, buf)) < 0) { - HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, ret_value, "write failed"); - } + HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, ret_value, "write failed"); + } } else { - HRETURN_ERROR(H5E_IO, H5E_UNSUPPORTED, FAIL, "no write method"); + 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 - * Monday, November 10, 1997 + * Programmer: Robb Matzke + * Monday, November 10, 1997 * * Modifications: * @@ -326,8 +328,8 @@ H5F_low_write(H5F_low_t *lf, const H5F_access_t *access_parms, herr_t H5F_low_flush(H5F_low_t *lf, const H5F_access_t *access_parms) { - haddr_t last_byte; - uint8 buf[1]; + haddr_t last_byte; + uint8 buf[1]; FUNC_ENTER(H5F_low_flush, FAIL); @@ -336,58 +338,59 @@ H5F_low_flush(H5F_low_t *lf, const H5F_access_t *access_parms) /* 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, access_parms, &last_byte, 1, buf) >= 0) { - H5F_low_write(lf, access_parms, &last_byte, 1, buf); - } + last_byte = lf->eof; + last_byte.offset -= 1; + if (H5F_low_read(lf, access_parms, &last_byte, 1, buf) >= 0) { + H5F_low_write(lf, access_parms, &last_byte, 1, buf); + } } /* Invoke the subclass the flush method */ if (lf->type->flush) { - if ((lf->type->flush) (lf, access_parms) < 0) { - HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, - "low level flush failed"); - } + if ((lf->type->flush) (lf, access_parms) < 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 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 - * Wednesday, October 22, 1997 + * Programmer: Robb Matzke + * Wednesday, October 22, 1997 * * Modifications: * *------------------------------------------------------------------------- */ -size_t -H5F_low_size(H5F_low_t *lf, haddr_t *eof /*out */ ) +hsize_t +H5F_low_size(H5F_low_t *lf, haddr_t *eof/*out*/) { - size_t size = (size_t) (-1); /*max possible size */ + hsize_t size = (hsize_t)(-1); /*max possible size */ FUNC_ENTER(H5F_low_size, 0); @@ -395,41 +398,41 @@ H5F_low_size(H5F_low_t *lf, haddr_t *eof /*out */ ) assert(eof); *eof = lf->eof; - if (eof->offset < size) - size = eof->offset; + 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 - * Friday, October 24, 1997 + * Programmer: Robb Matzke + * Friday, October 24, 1997 * * Modifications: * @@ -438,45 +441,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, const H5F_access_t *access_parms, int mode, - H5F_search_t *key/*out*/) + H5F_search_t *key/*out*/) { - hbool_t ret_value; - struct stat sb; + hbool_t ret_value; + struct stat sb; FUNC_ENTER(H5F_low_size, FAIL); assert(type); if (type->access) { - ret_value = (type->access) (name, access_parms, mode, key /*out*/); + ret_value = (type->access) (name, access_parms, mode, key /*out*/); } else { - ret_value = (0 == access(name, mode) ? TRUE : FALSE); - if (key) { - stat(name, &sb); - key->dev = sb.st_dev; - key->ino = sb.st_ino; - } + ret_value = (0 == access(name, mode) ? TRUE : FALSE); + 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 - * Thursday, November 13, 1997 + * Programmer: Robb Matzke + * Thursday, November 13, 1997 * * Modifications: * @@ -484,7 +487,7 @@ H5F_low_access(const H5F_low_class_t *type, const char *name, */ herr_t H5F_low_extend(H5F_low_t *lf, const H5F_access_t *access_parms, intn op, - size_t size, haddr_t *addr/*out*/) + hsize_t size, haddr_t *addr/*out*/) { FUNC_ENTER(H5F_low_alloc, FAIL); @@ -493,29 +496,29 @@ H5F_low_extend(H5F_low_t *lf, const H5F_access_t *access_parms, intn op, assert(addr); if (lf->type->extend) { - if ((lf->type->extend) (lf, access_parms, op, size, addr/*out*/) < 0) { - HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "unable to extend file"); - } + if ((lf->type->extend) (lf, access_parms, 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); + *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 - * Thursday, November 13, 1997 + * Programmer: Robb Matzke + * Thursday, November 13, 1997 * * Modifications: * @@ -535,18 +538,18 @@ H5F_low_seteof(H5F_low_t *lf, const haddr_t *addr) } /*------------------------------------------------------------------------- - * 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -561,22 +564,22 @@ H5F_addr_cmp(const haddr_t *a1, const haddr_t *a2) assert(a2 && addr_defined(a2)); if (a1->offset < a2->offset) - HRETURN(-1); + HRETURN(-1); if (a1->offset > a2->offset) - HRETURN(1); + 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -591,16 +594,16 @@ H5F_addr_undef(haddr_t *addr /*out */ ) } /*------------------------------------------------------------------------- - * 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -614,14 +617,14 @@ H5F_addr_defined(const haddr_t *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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -635,16 +638,16 @@ H5F_addr_reset(haddr_t *addr/*out*/) } /*------------------------------------------------------------------------- - * 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -658,16 +661,16 @@ H5F_addr_zerop(const haddr_t *addr) } /*------------------------------------------------------------------------- - * 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -676,42 +679,42 @@ H5F_addr_zerop(const haddr_t *addr) void H5F_addr_encode(H5F_t *f, uint8 **pp, const haddr_t *addr) { - uint i; - haddr_t tmp; + uint 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)++ = (uint8)(tmp.offset & 0xff); - tmp.offset >>= 8; - } - assert("overflow" && 0 == tmp.offset); + tmp = *addr; + for (i=0; i<H5F_SIZEOF_ADDR(f); i++) { + *(*pp)++ = (uint8)(tmp.offset & 0xff); + tmp.offset >>= 8; + } + assert("overflow" && 0 == tmp.offset); } else { - for (i=0; i<H5F_SIZEOF_ADDR(f); i++) { - *(*pp)++ = 0xff; - } + 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -720,10 +723,10 @@ 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*/) { - uint i; - haddr_t tmp; - uint8 c; - hbool_t all_zero = TRUE; + uint i; + haddr_t tmp; + uint8 c; + hbool_t all_zero = TRUE; assert(f); assert(pp && *pp); @@ -732,29 +735,29 @@ H5F_addr_decode(H5F_t *f, const uint8 **pp, haddr_t *addr/*out*/) 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 */ - } + 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -769,35 +772,35 @@ H5F_addr_print(FILE *stream, const haddr_t *addr) 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)); - } + /* + * 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"); + 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -814,21 +817,21 @@ H5F_addr_pow2(uintn n, haddr_t *addr /*out */ ) } /*------------------------------------------------------------------------- - * 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * *------------------------------------------------------------------------- */ void -H5F_addr_inc(haddr_t *addr/*in,out */, size_t inc) +H5F_addr_inc(haddr_t *addr/*in,out*/, hsize_t inc) { assert(addr && addr_defined(addr)); assert(addr->offset <= addr->offset + inc); @@ -845,14 +848,14 @@ H5F_addr_inc(haddr_t *addr/*in,out */, size_t inc) * Return: void * * Programmer: Robb Matzke - * Monday, April 6, 1998 + * Monday, April 6, 1998 * * Modifications: * *------------------------------------------------------------------------- */ void -H5F_addr_adj(haddr_t *addr/*in,out */, ssize_t adj) +H5F_addr_adj(haddr_t *addr/*in,out */, hssize_t adj) { #ifndef NDEBUG assert(addr && addr_defined(addr)); @@ -868,14 +871,14 @@ H5F_addr_adj(haddr_t *addr/*in,out */, ssize_t adj) /*------------------------------------------------------------------------- - * 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * @@ -890,17 +893,17 @@ H5F_addr_add(haddr_t *a1 /*in,out */ , const haddr_t *a2) } /*------------------------------------------------------------------------- - * 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 - * Friday, November 7, 1997 + * Programmer: Robb Matzke + * Friday, November 7, 1997 * * Modifications: * |