From 026cd39b227af84bf84f52c40d1910dcd265b93e Mon Sep 17 00:00:00 2001 From: Andre Noll Date: Sat, 31 May 2008 08:32:50 +0200 Subject: [PATCH] Generate osl.h from osl.h.in. We need to export the osl error codes to the applications that link against osl. Prefix these error codes with OSL. --- Makefile | 12 ++- osl.c | 188 +++++++++++++++++++++------------------------- osl.h => osl.h.in | 0 3 files changed, 97 insertions(+), 103 deletions(-) rename osl.h => osl.h.in (100%) diff --git a/Makefile b/Makefile index 70b83c7..4e8b48e 100644 --- a/Makefile +++ b/Makefile @@ -57,5 +57,15 @@ Makefile.deps: $(wildcard *.c *.h) $(dso_filename): $(objects) $(CC) $(dso_opts) -o $@ $(objects) -lcrypto +osl_errors.h: errlist + sed -e 's/\([A-Z_]*\) .*/ E_OSL_\1/' \ + -e '1s/^/enum osl_errors {\n/1' \ + -e '$$!s/$$/,/g' \ + -e '$$s/$$/\n};/1' $< > $@ + +errtab.h: errlist + sed -e 's/^\([A-Z_]*\)\s*\(.*\)/_S(E_OSL_\1, \2)/g' $< > $@ +osl.h: osl.h.in osl_errors.h + cat $^ > $@ clean: - rm -f *.o $(dso_filename) + rm -f *.o $(dso_filename) osl.h osl_errors.h errtab.h diff --git a/osl.c b/osl.c index 3ec2f54..957e9a7 100644 --- a/osl.c +++ b/osl.c @@ -100,14 +100,14 @@ __printf_2_3 void __log(int ll, const char* fmt,...) * contains the resulting offset location as measured in bytes from the * beginning of the file. * - * \return Positive on success. Otherwise, the function returns \p -E_LSEEK. + * \return Positive on success. Otherwise, the function returns \p -E_OSL_LSEEK. * * \sa lseek(2). */ static int __lseek(int fd, off_t *offset, int whence) { *offset = lseek(fd, *offset, whence); - int ret = -E_LSEEK; + int ret = -E_OSL_LSEEK; if (*offset == -1) return ret; return 1; @@ -124,7 +124,7 @@ static int __lseek(int fd, off_t *offset, int whence) * occurred during the write. * * \return On success, the number of bytes written is returned, otherwise, the - * function returns \p -E_WRITE. + * function returns \p -E_OSL_WRITE. * * \sa write(2). */ @@ -136,7 +136,7 @@ static ssize_t __write(int fd, const void *buf, size_t size) ret = write(fd, buf, size); if ((ret < 0) && (errno == EAGAIN || errno == EINTR)) continue; - return ret >= 0? ret : -E_WRITE; + return ret >= 0? ret : -E_OSL_WRITE; } } @@ -230,15 +230,15 @@ out: static int verify_name(const char *name) { if (!name) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (!*name) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (strchr(name, '/')) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (!strcmp(name, "..")) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (!strcmp(name, ".")) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; return 1; } @@ -325,11 +325,11 @@ static int init_column_descriptions(struct osl_table *t) int i, j, ret; const struct osl_column_description *cd; - ret = -E_BAD_TABLE_DESC; + ret = -E_OSL_BAD_TABLE_DESC; ret = verify_name(t->desc->name); if (ret < 0) goto err; - ret = -E_BAD_DB_DIR; + ret = -E_OSL_BAD_DB_DIR; if (!t->desc->dir && (t->num_disk_storage_columns || t->num_mapped_columns)) goto err; /* the size of the index header without column descriptions */ @@ -338,11 +338,11 @@ static int init_column_descriptions(struct osl_table *t) struct osl_column *col = t->columns + i; if (cd->storage_flags & OSL_RBTREE) { if (!cd->compare_function) - return -E_NO_COMPARE_FUNC; + return -E_OSL_NO_COMPARE_FUNC; } if (cd->storage_type == OSL_NO_STORAGE) continue; - ret = -E_NO_COLUMN_NAME; + ret = -E_OSL_NO_COLUMN_NAME; if (!cd->name || !cd->name[0]) goto err; ret = verify_name(cd->name); @@ -350,7 +350,7 @@ static int init_column_descriptions(struct osl_table *t) goto err; t->index_header_size += index_column_description_size(cd->name); column_name_hash(cd->name, col->name_hash); - ret = -E_DUPLICATE_COL_NAME; + ret = -E_OSL_DUPLICATE_COL_NAME; for (j = i + 1; j < t->desc->num_columns; j++) { const char *name2 = get_column_description(t->desc, j)->name; @@ -373,10 +373,7 @@ err: * of these tests fail. On success, a struct \p osl_table is allocated and * initialized with data derived from \p desc. * - * \return Positive on success, negative on errors. Possible errors include: \p - * E_BAD_TABLE_DESC, \p E_NO_COLUMN_DESC, \p E_NO_COLUMNS, \p - * E_BAD_STORAGE_TYPE, \p E_BAD_STORAGE_FLAGS, \p E_BAD_STORAGE_SIZE, \p - * E_NO_UNIQUE_RBTREE_COLUMN, \p E_NO_RBTREE_COL. + * \return Standard. * * \sa struct osl_table. */ @@ -389,15 +386,15 @@ int init_table_structure(const struct osl_table_description *desc, if (!t) return ret; - ret = -E_BAD_TABLE_DESC; + ret = -E_OSL_BAD_TABLE_DESC; if (!desc) goto err; DEBUG_LOG("creating table structure for '%s' from table " "description\n", desc->name); - ret = -E_NO_COLUMN_DESC; + ret = -E_OSL_NO_COLUMN_DESC; if (!desc->column_descriptions) goto err; - ret = -E_NO_COLUMNS; + ret = -E_OSL_NO_COLUMNS; if (!desc->num_columns) goto err; ret = -ERRNO_TO_ERROR(ENOMEM); @@ -410,14 +407,14 @@ int init_table_structure(const struct osl_table_description *desc, enum osl_storage_flags sf = cd->storage_flags; struct osl_column *col = &t->columns[i]; - ret = -E_BAD_STORAGE_TYPE; + ret = -E_OSL_BAD_STORAGE_TYPE; if (st != OSL_MAPPED_STORAGE && st != OSL_DISK_STORAGE && st != OSL_NO_STORAGE) goto err; - ret = -E_BAD_STORAGE_FLAGS; + ret = -E_OSL_BAD_STORAGE_FLAGS; if (st == OSL_DISK_STORAGE && sf & OSL_RBTREE) goto err; - ret = -E_BAD_STORAGE_SIZE; + ret = -E_OSL_BAD_STORAGE_SIZE; if (sf & OSL_FIXED_SIZE && !cd->data_size) goto err; switch (st) { @@ -444,10 +441,10 @@ int init_table_structure(const struct osl_table_description *desc, } } } - ret = -E_NO_UNIQUE_RBTREE_COLUMN; + ret = -E_OSL_NO_UNIQUE_RBTREE_COLUMN; if (t->num_disk_storage_columns && !have_disk_storage_name_column) goto err; - ret = -E_NO_RBTREE_COL; + ret = -E_OSL_NO_RBTREE_COL; if (!t->num_rbtrees) goto err; /* success */ @@ -472,7 +469,7 @@ err: * Read the index header, check for the paraslash magic string and the table version number. * Read all information stored in the index header into \a desc. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa struct osl_table_description, osl_create_table. */ @@ -486,20 +483,20 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) struct osl_column_description *cd; if (map->size < MIN_INDEX_HEADER_SIZE(1)) - return -E_SHORT_TABLE; + return -E_OSL_SHORT_TABLE; if (strncmp(buf + IDX_PARA_MAGIC, PARA_MAGIC, strlen(PARA_MAGIC))) - return -E_NO_MAGIC; + return -E_OSL_NO_MAGIC; version = read_u8(buf + IDX_VERSION); if (version < MIN_TABLE_VERSION || version > MAX_TABLE_VERSION) - return -E_VERSION_MISMATCH; + return -E_OSL_VERSION_MISMATCH; desc->flags = read_u8(buf + IDX_TABLE_FLAGS); desc->num_columns = read_u16(buf + IDX_NUM_COLUMNS); DEBUG_LOG("%u columns\n", desc->num_columns); if (!desc->num_columns) - return -E_NO_COLUMNS; + return -E_OSL_NO_COLUMNS; header_size = read_u16(buf + IDX_HEADER_SIZE); if (map->size < header_size) - return -E_BAD_SIZE; + return -E_OSL_BAD_SIZE; desc->column_descriptions = calloc(desc->num_columns, sizeof(struct osl_column_description)); if (!desc->column_descriptions) @@ -508,7 +505,7 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) FOR_EACH_COLUMN(i, desc, cd) { char *null_byte; - ret = -E_SHORT_TABLE; + ret = -E_OSL_SHORT_TABLE; if (map->size < offset + MIN_IDX_COLUMN_DESCRIPTION_SIZE) { ERROR_LOG("map size = %zu < %u = offset + min desc size\n", map->size, offset + MIN_IDX_COLUMN_DESCRIPTION_SIZE); @@ -520,7 +517,7 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) cd->data_size = read_u32(buf + offset + IDX_CD_DATA_SIZE); null_byte = memchr(buf + offset + IDX_CD_NAME, '\0', map->size - offset - IDX_CD_NAME); - ret = -E_INDEX_CORRUPTION; + ret = -E_OSL_INDEX_CORRUPTION; if (!null_byte) goto err; ret = -ERRNO_TO_ERROR(ENOMEM); @@ -530,7 +527,7 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) offset += index_column_description_size(cd->name); } if (offset != header_size) { - ret = -E_INDEX_CORRUPTION; + ret = -E_OSL_INDEX_CORRUPTION; ERROR_LOG("real header size = %u != %u = stored header size\n", offset, header_size); goto err; @@ -556,10 +553,10 @@ static int compare_table_descriptions(struct osl_table *t) ret = read_table_desc(&t->index_map, &desc); if (ret < 0) return ret; - ret = -E_BAD_TABLE_FLAGS; + ret = -E_OSL_BAD_TABLE_FLAGS; if (desc.flags != t->desc->flags) goto out; - ret = -E_BAD_COLUMN_NUM; + ret = -E_OSL_BAD_COLUMN_NUM; if (desc.num_columns > t->desc->num_columns) goto out; if (desc.num_columns < t->desc->num_columns) { @@ -580,22 +577,22 @@ static int compare_table_descriptions(struct osl_table *t) } FOR_EACH_COLUMN(i, t->desc, cd1) { cd2 = get_column_description(&desc, i); - ret = -E_BAD_STORAGE_TYPE; + ret = -E_OSL_BAD_STORAGE_TYPE; if (cd1->storage_type != cd2->storage_type) goto out; if (cd1->storage_type == OSL_NO_STORAGE) continue; - ret = -E_BAD_STORAGE_FLAGS; + ret = -E_OSL_BAD_STORAGE_FLAGS; if (cd1->storage_flags != cd2->storage_flags) { ERROR_LOG("sf1 = %u != %u = sf2\n", cd1->storage_flags, cd2->storage_flags); goto out; } - ret = -E_BAD_DATA_SIZE; + ret = -E_OSL_BAD_DATA_SIZE; if (cd1->storage_flags & OSL_FIXED_SIZE) if (cd1->data_size != cd2->data_size) goto out; - ret = -E_BAD_COLUMN_NAME; + ret = -E_OSL_BAD_COLUMN_NAME; if (strcmp(cd1->name, cd2->name)) goto out; } @@ -770,7 +767,7 @@ int unmap_table(struct osl_table *t, enum osl_close_flags flags) return 1; DEBUG_LOG("unmapping table '%s'\n", t->desc->name); if (!t->index_map.data) - return -E_NOT_MAPPED; + return -E_OSL_NOT_MAPPED; if (flags & OSL_MARK_CLEAN) mark_table_clean(t); ret = para_munmap(t->index_map.data, t->index_map.size); @@ -788,7 +785,7 @@ static int map_column(struct osl_table *t, unsigned col_num) { struct stat statbuf; char *filename = column_filename(t, col_num); - int ret = -E_STAT; + int ret = -E_OSL_STAT; if (!filename) return -ERRNO_TO_ERROR(ENOMEM); @@ -828,7 +825,7 @@ int map_table(struct osl_table *t, enum map_table_flags flags) if (!t->num_mapped_columns) return 0; if (t->index_map.data) - return -E_ALREADY_MAPPED; + return -E_OSL_ALREADY_MAPPED; filename = index_filename(t->desc); if (!filename) return -ERRNO_TO_ERROR(ENOMEM); @@ -843,7 +840,7 @@ int map_table(struct osl_table *t, enum map_table_flags flags) if (ret < 0) goto err; } - ret = -E_BUSY; + ret = -E_OSL_BUSY; if (!(flags & MAP_TBL_FL_IGNORE_DIRTY)) { if (table_is_dirty(t)) { ERROR_LOG("%s is dirty\n", t->desc->name); @@ -883,8 +880,7 @@ err: /* unmap what is already mapped */ * It is considered an error if \a col_num does not refer to a column * of storage type \p OSL_MAPPED_STORAGE. * - * \return Positive on success, negative on errors. Possible errors include: - * \p E_BAD_ROW_NUM, \p E_INVALID_OBJECT. + * \return Standard. * * \sa osl_storage_type. */ @@ -898,7 +894,7 @@ int get_mapped_object(const struct osl_table *t, unsigned col_num, int ret; if (t->num_rows <= row_num) - return -E_BAD_ROW_NUM; + return -E_OSL_BAD_ROW_NUM; ret = get_cell_index(t, row_num, col_num, &cell_index); if (ret < 0) return ret; @@ -909,7 +905,7 @@ int get_mapped_object(const struct osl_table *t, unsigned col_num, if (read_u8(header) == 0xff) { ERROR_LOG("col %u, size %zu, offset %u\n", col_num, obj->size, offset); - return -E_INVALID_OBJECT; + return -E_OSL_INVALID_OBJECT; } return 1; } @@ -952,7 +948,7 @@ static int search_rbtree(const struct osl_object *obj, *result = parent; if (rb_link) *rb_link = new; - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; } static int insert_rbtree(struct osl_table *t, unsigned col_num, @@ -964,7 +960,7 @@ static int insert_rbtree(struct osl_table *t, unsigned col_num, int ret = search_rbtree(obj, t, col_num, &parent, &rb_link); if (ret > 0) - return -E_RB_KEY_EXISTS; + return -E_OSL_RB_KEY_EXISTS; rbtree_num = t->columns[col_num].rbtree_num; n = get_rb_node_pointer(row, rbtree_num); rb_link_node(n, parent, rb_link); @@ -1107,8 +1103,7 @@ void clear_rbtrees(struct osl_table *t) * passed to this function in order to flush all changes to the file system and * to free the resources that were allocated by osl_open_table(). * - * \return Positive on success, negative on errors. Possible errors: \p E_BAD_TABLE, - * errors returned by unmap_table(). + * \return Standard. * * \sa osl_open_table(), unmap_table(). */ @@ -1117,7 +1112,7 @@ __export int osl_close_table(struct osl_table *t, enum osl_close_flags flags) int ret; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; free_volatile_objects(t, flags); clear_rbtrees(t); ret = unmap_table(t, flags); @@ -1164,7 +1159,7 @@ int row_is_invalid(struct osl_table *t, uint32_t row_num) * This function marks each mapped object in the index entry of \a row as * invalid. * - * \return Positive on success, negative on errors. + * \return Standard. */ int mark_row_invalid(struct osl_table *t, uint32_t row_num) { @@ -1183,7 +1178,7 @@ int mark_row_invalid(struct osl_table *t, uint32_t row_num) * * \param t The table containing the rbtrees to be initialized. * - * \return Positive on success, negative on errors. + * \return Standard. */ int init_rbtrees(struct osl_table *t) { @@ -1344,8 +1339,7 @@ static int append_row_index(const struct osl_table *t, char *row_index) * * Truncate the regular file named by \a path by \a size bytes. * - * \return Positive on success, negative on errors. Possible errors include: \p - * E_STAT, \p E_BAD_SIZE, \p E_TRUNC. + * \return Standard. * * \sa truncate(2) */ @@ -1354,13 +1348,13 @@ int para_truncate(const char *path, off_t size) int ret; struct stat statbuf; - ret = -E_STAT; + ret = -E_OSL_STAT; if (stat(path, &statbuf) < 0) goto out; - ret = -E_BAD_SIZE; + ret = -E_OSL_BAD_SIZE; if (statbuf.st_size < size) goto out; - ret = -E_TRUNC; + ret = -E_OSL_TRUNC; if (truncate(path, statbuf.st_size - size) < 0) goto out; ret = 1; @@ -1423,9 +1417,7 @@ static int delete_disk_storage_file(const struct osl_table *t, unsigned col_num, * rbtree if this object is equal to an object already contained in that column * (i.e. the compare function for the column's rbtree returns zero). * - * Possible errors include: \p E_RB_KEY_EXISTS, \p E_BAD_DATA_SIZE. - * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa struct osl_table_description, osl_compare_func, osl_add_row(). */ @@ -1440,7 +1432,7 @@ __export int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects const struct osl_column_description *cd; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; rb_parents = malloc(t->num_rbtrees * sizeof(struct rn_node*)); if (!rb_parents) return -ERRNO_TO_ERROR(ENOMEM); @@ -1464,14 +1456,14 @@ __export int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects enum osl_storage_type st = cd->storage_type; enum osl_storage_flags sf = cd->storage_flags; -// ret = -E_NULL_OBJECT; +// ret = -E_OSL_NULL_OBJECT; // if (!objects[i]) // goto out; if (st == OSL_DISK_STORAGE) continue; if (sf & OSL_RBTREE) { unsigned rbtree_num = t->columns[i].rbtree_num; - ret = -E_RB_KEY_EXISTS; + ret = -E_OSL_RB_KEY_EXISTS; // DEBUG_LOG("checking whether %p exists\n", // objects[i].data); if (search_rbtree(objects + i, t, i, @@ -1482,7 +1474,7 @@ __export int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects if (sf & OSL_FIXED_SIZE) { // DEBUG_LOG("fixed size. need: %zu, have: %d\n", // objects[i].size, cd->data_size); - ret = -E_BAD_DATA_SIZE; + ret = -E_OSL_BAD_DATA_SIZE; if (objects[i].size != cd->data_size) goto out; } @@ -1598,8 +1590,7 @@ __export int osl_add_row(struct osl_table *t, struct osl_object *objects) * or \p OSL_NO_STORAGE, i.e. no disk storage objects may be retrieved by this * function. * - * \return Positive if object was found, negative on errors. Possible errors - * include: \p E_BAD_TABLE, \p E_BAD_STORAGE_TYPE. + * \return Standard. * * \sa osl_storage_type, osl_open_disk_object(). */ @@ -1609,11 +1600,11 @@ __export int osl_get_object(const struct osl_table *t, const struct osl_row *r, const struct osl_column_description *cd; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; cd = get_column_description(t->desc, col_num); /* col must not be disk storage */ if (cd->storage_type == OSL_DISK_STORAGE) - return -E_BAD_STORAGE_TYPE; + return -E_OSL_BAD_STORAGE_TYPE; if (cd->storage_type == OSL_MAPPED_STORAGE) return get_mapped_object(t, col_num, r->num, object); /* volatile */ @@ -1647,8 +1638,7 @@ static int mark_mapped_object_invalid(const struct osl_table *t, * data is merely marked invalid and may be pruned from time to time by * para_fsck. * - * \return Positive on success, negative on errors. Possible errors include: - * \p E_BAD_TABLE, errors returned by osl_get_object(). + * \return Standard. */ __export int osl_del_row(struct osl_table *t, struct osl_row *row) { @@ -1657,7 +1647,7 @@ __export int osl_del_row(struct osl_table *t, struct osl_row *row) const struct osl_column_description *cd; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; INFO_LOG("deleting row %p\n", row); if (t->num_disk_storage_columns) { @@ -1699,9 +1689,9 @@ static int check_rbtree_col(const struct osl_table *t, unsigned col_num, struct osl_column **col) { if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; if (!(get_column_description(t->desc, col_num)->storage_flags & OSL_RBTREE)) - return -E_BAD_STORAGE_FLAGS; + return -E_OSL_BAD_STORAGE_FLAGS; *col = t->columns + col_num; return 1; } @@ -1717,10 +1707,7 @@ static int check_rbtree_col(const struct osl_table *t, unsigned col_num, * Lookup \a obj in \a t and return the row containing \a obj. The column * specified by \a col_num must have an associated rbtree. * - * \return Positive on success, negative on errors. If an error occurred, \a - * result is set to \p NULL. Possible errors include: \p E_BAD_TABLE, \p - * E_BAD_STORAGE_FLAGS, errors returned by get_mapped_object(), \p - * E_RB_KEY_NOT_FOUND. + * \return Standard. * * \sa osl_storage_flags */ @@ -1796,9 +1783,8 @@ static int rbtree_loop_reverse(struct osl_column *col, void *private_data, * value, or if all nodes of the tree have been visited. * * - * \return Positive on success, negative on errors. If the termination of the - * loop was caused by \a func returning a negative value, this value is - * returned. + * \return Standard. If the termination of the loop was caused by \a func + * returning a negative value, this value is returned. * * \sa osl_storage_flags, osl_rbtree_loop_reverse(), osl_compare_func. */ @@ -1909,17 +1895,17 @@ __export int osl_update_object(struct osl_table *t, const struct osl_row *r, int ret; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; col = &t->columns[col_num]; cd = get_column_description(t->desc, col_num); DEBUG_LOG("updating column %u of %s\n", col_num, t->desc->name); if (cd->storage_flags & OSL_RBTREE) { if (search_rbtree(obj, t, col_num, NULL, NULL) > 0) - return -E_RB_KEY_EXISTS; + return -E_OSL_RB_KEY_EXISTS; } if (cd->storage_flags & OSL_FIXED_SIZE) { if (obj->size != cd->data_size) - return -E_BAD_DATA_SIZE; + return -E_OSL_BAD_DATA_SIZE; } remove_rb_node(t, col_num, r); if (cd->storage_type == OSL_NO_STORAGE) { /* TODO: If fixed size, reuse object? */ @@ -1997,8 +1983,7 @@ __export int osl_update_object(struct osl_table *t, const struct osl_row *r, * retrieve one of its containing objects. Afterwards, osl_close_disk_object() * must be called in order to deallocate the resources. * - * \return Positive on success, negative on errors. Possible errors include: - * \p E_BAD_TABLE, \p E_BAD_STORAGE_TYPE, errors returned by osl_get_object(). + * \return Standard. * * \sa osl_get_object(), osl_storage_type, osl_close_disk_object(). */ @@ -2010,10 +1995,10 @@ __export int osl_open_disk_object(const struct osl_table *t, const struct osl_ro int ret; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; cd = get_column_description(t->desc, col_num); if (cd->storage_type != OSL_DISK_STORAGE) - return -E_BAD_STORAGE_TYPE; + return -E_OSL_BAD_STORAGE_TYPE; ret = disk_storage_name_of_row(t, r, &ds_name); if (ret < 0) @@ -2050,12 +2035,12 @@ __export int osl_close_disk_object(struct osl_object *obj) * * The number of rows returned via \a num_rows excluding any invalid rows. * - * \return Positive on success, \p -E_BAD_TABLE if \a t is \p NULL. + * \return Positive on success, \p -E_OSL_BAD_TABLE if \a t is \p NULL. */ __export int osl_get_num_rows(const struct osl_table *t, unsigned *num_rows) { if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; assert(t->num_rows >= t->num_invalid_rows); *num_rows = t->num_rows - t->num_invalid_rows; return 1; @@ -2073,7 +2058,7 @@ __export int osl_get_num_rows(const struct osl_table *t, unsigned *num_rows) * determined by an in-order tree walk of the rbtree associated with column * number \a col_num of \a table. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa osl_get_nth_row(). */ @@ -2095,7 +2080,7 @@ __export int osl_get_rank(const struct osl_table *t, struct osl_row *r, return ret; ret = rb_rank(node, rank); if (ret < 0) - return -E_BAD_ROW; + return -E_OSL_BAD_ROW; return 1; } @@ -2113,8 +2098,7 @@ __export int osl_get_rank(const struct osl_table *t, struct osl_row *r, * \a col_num is not a rbtree column, or if \a n is larger than the * number of rows in the table. * - * \return Positive on success, negative on errors. Possible errors: - * \p E_BAD_TABLE, \p E_BAD_STORAGE_FLAGS, \p E_RB_KEY_NOT_FOUND. + * \return Standard. * * \sa osl_storage_flags, osl_compare_func, osl_get_row(), * osl_rbtree_last_row(), osl_rbtree_first_row(), osl_get_rank(). @@ -2128,18 +2112,18 @@ __export int osl_get_nth_row(const struct osl_table *t, unsigned col_num, int ret; if (n == 0) - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; ret = osl_get_num_rows(t, &num_rows); if (ret < 0) return ret; if (n > num_rows) - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; ret = check_rbtree_col(t, col_num, &col); if (ret < 0) return ret; node = rb_nth(col->rbtree.rb_node, n); if (!node) - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; *result = get_row_pointer(node, col->rbtree_num); return 1; } @@ -2156,7 +2140,7 @@ __export int osl_get_nth_row(const struct osl_table *t, unsigned col_num, * returned. It is an error if \a col_num refers to a column without an * associated rbtree. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa osl_get_nth_row(), osl_rbtree_last_row(). */ @@ -2177,7 +2161,7 @@ __export int osl_rbtree_first_row(const struct osl_table *t, unsigned col_num, * is that the row containing the greatest rather than the smallest object is * returned. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa osl_get_nth_row(), osl_rbtree_first_row(). */ diff --git a/osl.h b/osl.h.in similarity index 100% rename from osl.h rename to osl.h.in -- 2.39.2