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);                \
        assert(__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_ */