libwapcaplet.h

Go to the documentation of this file.

/* libwapcaplet.h
 *
 * String internment and management tools.
 *
 * Copyright 2009 The NetSurf Browser Project.
 *                Daniel Silverstone <dsilvers@netsurf-browser.org>
 */
 
#ifndef libwapcaplet_h_
#define libwapcaplet_h_
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include <sys/types.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <assert.h>
 
typedef uint32_t lwc_refcounter;
        
typedef uint32_t lwc_hash;
 
typedef struct lwc_string_s {
        struct lwc_string_s **  prevptr;
        struct lwc_string_s *   next;
        size_t          len;
        lwc_hash        hash;
        lwc_refcounter  refcnt;
        struct lwc_string_s *   insensitive;
} lwc_string;
        
typedef void (*lwc_iteration_callback_fn)(lwc_string *str, void *pw);
 
typedef enum lwc_error_e {
        lwc_error_ok            = 0,    
        lwc_error_oom           = 1,    
        lwc_error_range         = 2     
} lwc_error;
 
extern lwc_error lwc_intern_string(const char *s, size_t slen,
                                   lwc_string **ret);
 
extern lwc_error lwc_intern_substring(lwc_string *str,
                                      size_t ssoffset, size_t sslen,
                                      lwc_string **ret);
 
extern lwc_error lwc_string_tolower(lwc_string *str, lwc_string **ret);
 
#if defined(STMTEXPR)
#define lwc_string_ref(str) ({lwc_string *__lwc_s = (str); assert(__lwc_s != NULL); __lwc_s->refcnt++; __lwc_s;})
#else
static inline lwc_string *
lwc_string_ref(lwc_string *str)
{
        assert(str != NULL);
        str->refcnt++;
        return str;
}
#endif
 
#define lwc_string_unref(str) {                                  \
                lwc_string *__lwc_s = (str);                     \
                if (__lwc_s != NULL) {                           \
                        __lwc_s->refcnt--;                       \
                        if ((__lwc_s->refcnt == 0) ||            \
                            ((__lwc_s->refcnt == 1) &&           \
                             (__lwc_s->insensitive == __lwc_s))) \
                                lwc_string_destroy(__lwc_s);     \
                }                                                \
        }
        
extern void lwc_string_destroy(lwc_string *str);
 
#define lwc_string_isequal(str1, str2, ret) \
        ((*(ret) = ((str1) == (str2))), lwc_error_ok)
 
extern lwc_error
lwc__intern_caseless_string(lwc_string *str);
 
#if defined(STMTEXPR)
#define lwc_string_caseless_isequal(_str1,_str2,_ret) ({                \
            lwc_error __lwc_err = lwc_error_ok;                         \
            lwc_string *__lwc_str1 = (_str1);                           \
            lwc_string *__lwc_str2 = (_str2);                           \
            bool *__lwc_ret = (_ret);                                   \
                                                                        \
            if (__lwc_str1->insensitive == NULL) {                      \
                __lwc_err = lwc__intern_caseless_string(__lwc_str1);    \
            }                                                           \
            if (__lwc_err == lwc_error_ok && __lwc_str2->insensitive == NULL) { \
                __lwc_err = lwc__intern_caseless_string(__lwc_str2);    \
            }                                                           \
            if (__lwc_err == lwc_error_ok)                              \
                *__lwc_ret = (__lwc_str1->insensitive == __lwc_str2->insensitive); \
            __lwc_err;                                                  \
        })
        
#else
static inline lwc_error
lwc_string_caseless_isequal(lwc_string *str1, lwc_string *str2, bool *ret)
{
       lwc_error err = lwc_error_ok;
       if (str1->insensitive == NULL) {
           err = lwc__intern_caseless_string(str1);
       }
       if (err == lwc_error_ok && str2->insensitive == NULL) {
           err = lwc__intern_caseless_string(str2);
       }
       if (err == lwc_error_ok)
           *ret = (str1->insensitive == str2->insensitive);
       return err;
}
#endif
 
#if defined(STMTEXPR)
#define lwc__assert_and_expr(str, expr) ({assert(str != NULL); expr;})
#else
#define lwc__assert_and_expr(str, expr) (expr)
#endif
        
#define lwc_string_data(str) lwc__assert_and_expr(str, (const char *)((str)+1))
 
#define lwc_string_length(str) lwc__assert_and_expr(str, (str)->len)
 
#define lwc_string_hash_value(str) lwc__assert_and_expr(str, (str)->hash)
 
static inline lwc_error lwc_string_caseless_hash_value(
        lwc_string *str, lwc_hash *hash)
{
        if (str->insensitive == NULL) {
                lwc_error err = lwc__intern_caseless_string(str);
                if (err != lwc_error_ok) {
                        return err;
                }
        }
 
        *hash = str->insensitive->hash;
        return lwc_error_ok;
}
 
 
extern void lwc_iterate_strings(lwc_iteration_callback_fn cb, void *pw);
 
#ifdef __cplusplus
}
#endif
 
#endif /* libwapcaplet_h_ */