lcn_types.h

Go to the documentation of this file.

/* Copyright 2005 The Apache Software Foundation or its licensors, as
 * applicable.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * @file lcn_types.h
 * @brief Random stuff that doesn't fit anywhere else
 */

#ifndef _LCN_TYPES_H
#define _LCN_TYPES_H

#include <apr.h>
#include <apr_pools.h>

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/** Since we use C89 we need a boolean type... */
typedef int lcn_boolean_t;

#ifndef FALSE
/** You figure it out. */
#define FALSE 0
#endif

#ifndef TRUE
/** You figure it out. */
#define TRUE 1
#endif

/** Our exception object. */
typedef struct lcn_error_t {
  apr_status_t apr_err;      /**< The underlying APR error */

  const char *message;       /**< Human readable error message */

  struct lcn_error_t *child; /**< The next error in the chain, or @c NULL */

  apr_pool_t *pool;          /**< The pool this error was allocated in */

} lcn_error_t;

/** The best kind of error. */
#define LCN_NO_ERROR 0

/** Create a new error with underlying error code @a apr_err, wrapping around
 * @a child, with error message @a message.
 */
lcn_error_t *
lcn_error_create (apr_status_t apr_err,
                  lcn_error_t *child,
                  const char *message);

/** A @c printf style version of @c lcn_error_create. */
lcn_error_t *
lcn_error_createf (apr_status_t apr_err,
                   lcn_error_t *child,
                   const char *fmt,
                   ...)
#ifdef DOXYGEN_SHOULD_SKIP_THIS
                   ;
#else
                   __attribute__ ((format (printf, 3, 4)));
#endif

/** Destroy @a error. */
void lcn_error_clear (lcn_error_t *error);

/** A handy wrapper for functions that return an @c lcn_error_t, just returns
 * the error to our caller if it's not @c LCN_NO_ERROR.
 */
#define LCN_ERR(expr)                    \
  do {                                   \
    lcn_error_t *lcn_err__temp = (expr); \
    if (lcn_err__temp)                   \
      return lcn_err__temp;              \
    } while (0)

/** A java style 16 bit char. */
typedef apr_uint16_t lcn_char_t;

/** Count the number of characters in a string of lcn_char_t's */
apr_size_t lcn_strlen (const lcn_char_t *str);

/** Get the size of a string of lcn_char_t's in bytes */
#define LCN_STRING_SIZE(str) ((lcn_strlen (str) + 1) * sizeof (lcn_char_t))

/** Lexographically compare @a first and @a second. */
int lcn_strcmp (const lcn_char_t *first, const lcn_char_t *second);

/** Return a copy of @a str, allocated in @a pool. */
lcn_char_t *
lcn_strcpy (const lcn_char_t *str, apr_pool_t *pool);

/** Convert @a in into a cstring @a out, allocated in @a pool.
 *
 * This will result in an error if @a in cannot be represented in ASCII
 * characters.
 */
lcn_error_t *
lcn_str_to_cstring (char **out, const lcn_char_t *in, apr_pool_t *pool);

/** Create a string of @c lcn_char_ts that corresponds to the contents of 
 * @a in, allocated in @a pool.
 */
lcn_char_t *
lcn_str_from_cstring (const char *in, apr_pool_t *pool);

/** Index into an apr_array_header_t */
#define APR_ARRAY_IDX(ary,i,type) (((type *)(ary)->elts)[i])

/** Easier array-pushing syntax */
#define APR_ARRAY_PUSH(ary,type) (*((type *)apr_array_push (ary)))

/** A convenience wrapper for @c apr_pool_create. */
apr_pool_t *lcn_pool_create (apr_pool_t *parent);

/** For symmetry with @c lcn_pool_create. */
#define lcn_pool_destroy apr_pool_destroy

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif

---