/* $Id: obsutil,v 1.2 2004/12/05 01:15:02 kss Exp kss $ */ /* * GNU obstack wrapper with some utilities * Copyright (C) 2003, 2004 Seong-Kook Shin <cinsk.shin at samsung.com> */ #ifndef OBSUTIL_H_ #define OBSUTIL_H_ #if HAVE_CONFIG_H # include <config.h> #endif #include <obstack.h> #ifndef obstack_chunk_alloc # include <stdlib.h> # define obstack_chunk_alloc malloc # define obstack_chunk_free free #endif /* This indirect using of extern "C" { ... } makes Emacs happy */ #ifndef BEGIN_C_DECLS # ifdef __cplusplus # define BEGIN_C_DECLS extern "C" { # define END_C_DECLS } # else # define BEGIN_C_DECLS # define END_C_DECLS # endif #endif /* BEGIN_C_DECLS */ BEGIN_C_DECLS /* * We encapsulated GNU obstack to provide better interface, * All of GNU obstack functions and macros are provided in upper-case * names. For example, call OBSTACK_INIT() instead obstack_init(), * and use OBSTACK_CHUNK_SIZE() rather than obstack_chunk_size(). * * obsutil wrappers -- that is, GNU obstack wrapper functions and macros * -- are the same as original GNU obstack functions in terms of argument * types and numbers. It is much better to use obsutil wrappers because * it provides some error condition directly via return values. * * For example, the return type of obstack_init() is `void'. You will not * know weather the call was successful before installing obstack error * handler. But OBSTACK_INIT() returns 0 if the call was successful, * otherwise it returns -1. * * All obsutils wrapper which returns 'int' type returns zero on success, * otherwise returns -1. Note that some wrapper will not generate any * error. In this case, the return values are the same as the original * functions. * * All obsutils wrapper which returns some pointer type returns NULL on * failure. */ extern int obstack_errno_; typedef void (*obstack_alloc_failed_handler_t)(void); extern void obsutil_alloc_failed_handler(void); /* * You should call obsutil_init() before calling any function or using * any macro in this header file. obsutil_init() modifies the * global variable `obstack_alloc_failed_handler' to check errors. * * If you've used your own handler for `obstack_alloc_failed_handler', * you should call obsutil_alloc_failed_handler() in your own handler. * * If you're not sure, just call obsutil_init(). */ extern obstack_alloc_failed_handler_t obsutil_init(void); #define OBS_ERROR_CLEAR do { obstack_errno_ = 0; } while (0) #define OBS_ERROR_SET do { obstack_errno_ = 1; } while (0) #define OBS_ERROR (obstack_errno_ != 0) static __inline__ int OBSTACK_INIT(struct obstack *stack) { obstack_init(stack); if (OBS_ERROR) return -1; return 0; } static __inline__ int OBSTACK_BEGIN(struct obstack *stack, int size) { OBS_ERROR_CLEAR; obstack_begin(stack, size); if (OBS_ERROR) return -1; return 0; } static __inline__ void * OBSTACK_ALLOC(struct obstack *stack, int size) { void *ptr; OBS_ERROR_CLEAR; ptr = obstack_alloc(stack, size); if (OBS_ERROR) return 0; return ptr; } static __inline__ void * OBSTACK_COPY(struct obstack *stack, void *address, int size) { void *ptr; OBS_ERROR_CLEAR; ptr = obstack_copy(stack, address, size); if (obstack_errno_) return 0; return ptr; } static __inline__ void * OBSTACK_COPY0(struct obstack *stack, void *address, int size) { void *ptr; OBS_ERROR_CLEAR; ptr = obstack_copy0(stack, address, size); if (obstack_errno_) return 0; return ptr; } static __inline__ void OBSTACK_FREE(struct obstack *stack, void *object) { obstack_free(stack, object); } static __inline__ int OBSTACK_BLANK(struct obstack *stack, int size) { OBS_ERROR_CLEAR; obstack_blank(stack, size); if (obstack_errno_) return -1; return 0; } static __inline__ int OBSTACK_GROW(struct obstack *stack, void *data, int size) { OBS_ERROR_CLEAR; obstack_grow(stack, data, size); if (obstack_errno_) return -1; return 0; } static __inline__ int OBSTACK_GROW0(struct obstack *stack, void *data, int size) { OBS_ERROR_CLEAR; obstack_grow0(stack, data, size); if (obstack_errno_) return -1; return 0; } static __inline__ int OBSTACK_1GROW(struct obstack *stack, char c) { OBS_ERROR_CLEAR; obstack_1grow(stack, c); if (obstack_errno_) return -1; return 0; } static __inline__ int OBSTACK_PTR_GROW(struct obstack *stack, void *data) { OBS_ERROR_CLEAR; obstack_ptr_grow(stack, data); if (obstack_errno_) return -1; return 0; } static __inline__ int OBSTACK_INT_GROW(struct obstack *stack, int data) { OBS_ERROR_CLEAR; obstack_int_grow(stack, data); if (obstack_errno_) return -1; return 0; } static __inline__ void * OBSTACK_FINISH(struct obstack *stack) { return obstack_finish(stack); } static __inline__ int OBSTACK_OBJECT_SIZE(struct obstack *stack) { return obstack_object_size(stack); } static __inline__ int OBSTACK_ROOM(struct obstack *stack) { return obstack_room(stack); } static __inline__ void OBSTACK_1GROW_FAST(struct obstack *stack, char c) { obstack_1grow_fast(stack, c); } static __inline__ void OBSTACK_INT_GROW_FAST(struct obstack *stack, int data) { obstack_int_grow_fast(stack, data); } static __inline__ void OBSTACK_BLANK_FAST(struct obstack *stack, int size) { obstack_blank_fast(stack, size); } static __inline__ void * OBSTACK_BASE(struct obstack *stack) { return obstack_base(stack); } static __inline__ void * OBSTACK_NEXT_FREE(struct obstack *stack) { return obstack_next_free(stack); } static __inline__ int OBSTACK_ALIGNMENT_MASK(struct obstack *stack) { return obstack_alignment_mask(stack); } static __inline__ int OBSTACK_CHUNK_SIZE(struct obstack *stack) { return obstack_chunk_size(stack); } struct os_slist_ { void *data; struct os_slist_ *next; }; typedef struct os_slist_ os_slist_t; #define OS_SLIST_DATA(list) ((list)->data) #define OS_SLIST_NEXT(list) ((list)->next) struct os_slist_man_ { os_slist_t *grave; struct obstack *stack; /* backward reference */ int num_zombies; int num_nodes; }; typedef struct os_slist_man_ os_slist_man_t; extern os_slist_man_t *os_slist_init(struct obstack *stack); extern os_slist_t *os_slist_node_new(os_slist_man_t *manager, void *data); extern os_slist_t *os_slist_new_v(os_slist_man_t *manager, int nelem, ...); static __inline__ void * os_slist_node_delete_(os_slist_man_t *manager, os_slist_t *node) { void *ret = node->data; node->next = manager->grave; manager->grave = node; manager->num_zombies++; return ret; } static __inline__ void os_slist_delete(os_slist_man_t *manager, os_slist_t *list) { os_slist_t *ptr = list; while (ptr) { os_slist_t *tmp = ptr->next; os_slist_node_delete_(manager, ptr); ptr = tmp; } } static __inline__ os_slist_t * os_slist_append(os_slist_man_t *manager, os_slist_t *dest, os_slist_t *src) { os_slist_t *last, *tmp; for (tmp = dest; tmp != NULL; tmp = tmp->next) last = tmp; last->next = src; return dest; } static __inline__ os_slist_t * os_slist_prepend(os_slist_man_t *manager, os_slist_t *dest, os_slist_t *src) { os_slist_t *last, *tmp; for (tmp = src; tmp != NULL; tmp = tmp->next) last = tmp; last->next = dest; return src; } static __inline__ os_slist_t * os_slist_next(os_slist_man_t *manager, os_slist_t *list) { return list->next; } static __inline__ os_slist_t * os_slist_find_first(os_slist_man_t *manager, os_slist_t *list, void *data) { os_slist_t *ptr; for (ptr = list; ptr != NULL; ptr = ptr->next) if (ptr->data == data) return ptr; return 0; } static __inline__ os_slist_t * os_slist_find_nth(os_slist_man_t *manager, os_slist_t *list, void *data, int nth) { os_slist_t *ptr; int match = 0; for (ptr = list; ptr != 0; ptr = ptr->next) { if (ptr->data == data) { if (match == nth) return ptr; match++; } } return 0; } static __inline__ os_slist_t * os_slist_find_last(os_slist_man_t *manager, os_slist_t *list, void *data) { os_slist_t *ptr, *ptr2 = 0; for (ptr = list; ptr != NULL; ptr = ptr->next) { if (ptr->data == data) { ptr2 = ptr; } } return ptr2; } END_C_DECLS #endif /* OBSUTIL_H_ */

/* $Id: obsutil,v 1.2 2004/12/05 01:15:02 kss Exp kss $ */ /* * GNU obstack wrapper with some utilities * Copyright (C) 2003, 2004 Seong-Kook Shin <cinsky@gmail.com> */ #include <assert.h> #include <stdarg.h> #include <obsutil.h> int obstack_errno_ = 0; void obsutil_alloc_failed_handler(void) { obstack_errno_ = 1; } obstack_alloc_failed_handler_t obsutil_init(void) { obstack_alloc_failed_handler_t handler = obstack_alloc_failed_handler; obstack_alloc_failed_handler = obsutil_alloc_failed_handler; return handler; } os_slist_man_t * os_slist_init(struct obstack *stack) { os_slist_man_t *manager; assert(OBSTACK_OBJECT_SIZE(stack) == 0); manager = OBSTACK_ALLOC(stack, sizeof(*manager)); if (obstack_errno_) return 0; manager->grave = 0; manager->stack = stack; manager->num_zombies = 0; manager->num_nodes = 0; return manager; } os_slist_t * os_slist_node_new(os_slist_man_t *manager, void *data) { os_slist_t *node; assert(OBSTACK_OBJECT_SIZE(manager->stack) == 0); if (manager->grave) { node = manager->grave; manager->grave = node->next; manager->num_zombies--; } else { node = OBSTACK_ALLOC(manager->stack, sizeof(*node)); if (obstack_errno_) return 0; manager->num_nodes++; } node->next = 0; node->data = data; return node; } os_slist_t * os_slist_new_v(os_slist_man_t *manager, int nelem, ...) { va_list argptr; int i; os_slist_t *list = 0, *last, *ptr; if (nelem < 1) return 0; va_start(argptr, nelem); list = os_slist_node_new(manager, va_arg(argptr, void *)); last = list; for (i = 1; i < nelem; i++) { ptr = os_slist_node_new(manager, va_arg(argptr, void *)); if (!ptr) { os_slist_delete(manager, list); va_end(argptr); return 0; } last->next = ptr; last = ptr; } va_end(argptr); return list; } #ifdef TEST_OBSUTIL #include <error.h> int main(void) { struct obstack stack_; struct obstack *stack = &stack_; os_slist_man_t *manager; os_slist_t *list; obsutil_init(); if (OBSTACK_INIT(stack) < 0) error(1, 0, "obstack_init() failed"); manager = os_slist_init(stack); if (!manager) error(1, 0, "os_slist_init() failed"); list = os_slist_new_v(manager, 4, NULL, NULL, NULL, NULL); return 0; } #endif /* TEST_OBSUTIL */