afw_utf8.h

Go to the documentation of this file.

// See the 'COPYING' file in the project root for licensing information.
/*
 * AFW - String Functions
 *
 * Copyright (c) 2010-2023 Clemson University
 *
 */
 
#ifndef __AFW_UTF8_H__
#define __AFW_UTF8_H__
 
#include "afw_minimal.h"
 
AFW_BEGIN_DECLARES
 
typedef const afw_utf8_t *
(AFW_CALLBACK *afw_utf8_from_value_t) (
    const afw_value_t *value,
    afw_boolean_t own,
    afw_xctx_t *xctx);
 
 
typedef const afw_value_t *
(AFW_CALLBACK *afw_utf8_to_value_t) (
    const afw_utf8_t *from_utf8,
    const afw_utf8_t *path,
    afw_xctx_t *xctx);
 
 
/*  @brief Options for function afw_utf8_nfc(). */
typedef enum afw_utf8_nfc_option_e {
 
    afw_utf8_nfc_option_is_valid,
 
    afw_utf8_nfc_option_is_nfc,
 
    afw_utf8_nfc_option_create,
 
    afw_utf8_nfc_option_create_copy
 
} afw_utf8_nfc_option_t;
 
 
AFW_DECLARE(const afw_utf8_t *)
afw_utf8_nfc(
    const afw_utf8_octet_t *s, afw_size_t len,
    afw_utf8_nfc_option_t option,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
AFW_DECLARE(afw_code_point_t)
afw_utf8_next_code_point(const afw_utf8_octet_t *s, afw_size_t *offset,
    afw_size_t len, afw_xctx_t *xctx);
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_from_code_point(afw_utf8_octet_t utf8_z[5], afw_code_point_t cp,
    afw_xctx_t *xctx);
 
 
#define afw_utf8_is_valid(s, len, xctx) \
    (afw_utf8_nfc(s, len, afw_utf8_nfc_option_is_valid, \
        (xctx)->p, xctx) == NULL)
 
 
 
#define afw_utf8_is_nfc(s, len, p, xctx) \
    (afw_utf8_nfc(s, len, afw_utf8_nfc_option_is_nfc, \
        p, xctx) == NULL)
 
 
AFW_DEFINE_STATIC_INLINE(const afw_memory_t *)
afw_utf8_as_raw(
    const afw_utf8_t *string, const afw_pool_t *p, afw_xctx_t *xctx)
{
    return (const afw_memory_t *)string;
}
 
 
AFW_DEFINE_STATIC_INLINE(const afw_utf8_t *)
afw_utf8_from_raw(
    const afw_memory_t *raw, const afw_pool_t *p, afw_xctx_t *xctx)
{
    return afw_utf8_nfc((const afw_utf8_octet_t *)raw->ptr, raw->size,
        afw_utf8_nfc_option_create, p, xctx);
}
 
 
 
AFW_DECLARE(const afw_utf8_t *)
afw_utf8_from_encoding(
    const afw_utf8_t * from_encoding,
    const char* * from, afw_size_t * from_size,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
#define afw_utf8_create(s,len, p,  xctx) \
    afw_utf8_nfc(s, len, afw_utf8_nfc_option_create, p, xctx)
 
 
 
#define afw_utf8_from_utf8_z(s_z, p, xctx) \
    afw_utf8_nfc(s_z, AFW_UTF8_Z_LEN, afw_utf8_nfc_option_create, \
        p, xctx)
 
 
AFW_DECLARE(const afw_utf8_t * const *)
afw_utf8_clone_pointer_array(
    afw_size_t count,
    const afw_utf8_t * const * pointers,
    afw_boolean_t NULL_terminate,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
AFW_DECLARE(const afw_utf8_t *)
afw_utf8_array_to_utf8_with_separator(
    const afw_utf8_t * const * strings,
    const afw_utf8_t * separator,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(const afw_utf8_z_t *)
afw_utf8_array_to_utf8_z_with_separator(
    const afw_utf8_t * const * strings,
    const afw_utf8_t * separator,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(const afw_utf8_z_t *)
afw_utf8_z_array_to_utf8_z_with_separator(
    const afw_utf8_z_t * const * strings_z,
    const afw_utf8_t * separator,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_utf8_t *)
afw_utf8_clone(
    const afw_utf8_t *string, const afw_pool_t *p, afw_xctx_t *xctx)
{
    return (string)
        ? afw_utf8_nfc(string->s, string->len,
            afw_utf8_nfc_option_create_copy, p, xctx)
        : NULL;
}
 
 
 
#define afw_utf8_create_copy(s, len, p, xctx) \
    afw_utf8_nfc(s, len, afw_utf8_nfc_option_create_copy, p, xctx)
 
 
 
AFW_DECLARE(const afw_utf8_t *)
afw_utf8_to_lower(
    const afw_utf8_t *s, const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(const afw_utf8_t *)
afw_utf8_normalize_space(
    const afw_utf8_t *s, const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
AFW_DECLARE_ELLIPSIS(const afw_utf8_t *)
afw_utf8_concat(
    const afw_pool_t *p, afw_xctx_t *xctx, ...);
 
 
AFW_DECLARE(const afw_utf8_t *)
afw_utf8_concat_v(const afw_pool_t *p,
    afw_xctx_t *xctx, va_list strings);
 
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_line_column_of_offset(
    afw_size_t *line_number,
    afw_size_t *column_number,
    const afw_utf8_t *s,
    afw_size_t offset,
    int tab_size,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_utf8_line_count_and_max_column(
    afw_size_t *number_of_lines,
    afw_size_t *max_column_number,
    const afw_utf8_t *s,
    int tab_size,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE_ELLIPSIS(const afw_utf8_t *)
afw_utf8_printf(
    const afw_pool_t *p, afw_xctx_t *xctx, const afw_utf8_z_t *format_z,
    ...);
 
 
AFW_DECLARE(const afw_utf8_t *)
afw_utf8_printf_v(
    const afw_utf8_z_t *format, va_list arg,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(const afw_utf8_z_t *)
afw_utf8_to_utf8_z(
    const afw_utf8_t *string, const afw_pool_t *p, afw_xctx_t *xctx)
{
    afw_utf8_z_t * result;
 
    result = afw_pool_malloc(p, string->len + 1, xctx);
    memcpy(result, string->s, string->len);
    result[string->len] = 0;
    return result;
}
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_starts_with(
    const afw_utf8_t *string, const afw_utf8_t *starts_with);
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_starts_with_z(
    const afw_utf8_t *string, const afw_utf8_z_t *starts_with_z);
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_ends_with(
    const afw_utf8_t *string, const afw_utf8_t *ends_with);
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_ends_with_z(
    const afw_utf8_t *string, const afw_utf8_z_t *ends_with_z);
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_equal(
    const afw_utf8_t *s1, const afw_utf8_t *s2);
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_contains(
    const afw_utf8_t *s1, const afw_utf8_t *s2);
 
 
AFW_DECLARE(int)
afw_utf8_compare(
    const afw_utf8_t *s1, const afw_utf8_t *s2);
 
 
AFW_DECLARE(int)
afw_utf8_compare_ignore_case(
    const afw_utf8_t *s1, const afw_utf8_t *s2, afw_xctx_t *xctx);
 
 
AFW_DECLARE(afw_boolean_t)
afw_utf8_equal_utf8_z(
    const afw_utf8_t *s1, const afw_utf8_z_t *s2_z);
 
 
AFW_DECLARE(const afw_utf8_t * const *)
afw_utf8_parse_csv(
    const afw_utf8_t *s,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_utf8_substring_byte(
    afw_utf8_t *result, const afw_utf8_t *string, afw_size_t start,
    afw_size_t end)
{
    if (end > string->len) end = string->len;
    result->len = (end > start) ? end - start : 0;
    result->s = (result->len > 0) ? string->s + start : NULL;
}
 
 
/* -- The following are primarily zero terminate utf-8 string functions. -- */
 
AFW_DECLARE(const afw_utf8_z_t *)
afw_utf8_z_create(
    const afw_utf8_octet_t *s, afw_size_t len, const afw_pool_t *p, afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(afw_boolean_t)
afw_utf8_len_starts_with_z(
    const afw_utf8_octet_t *s1, afw_size_t len1, const afw_utf8_z_t *s2_z)
{
    while (*s2_z) {
        if (len1-- <= 0 || *s1 != *s2_z) {
            return false;
        }
        s1++;
        s2_z++;
    }
 
    return true;
}
 
 
AFW_DEFINE_STATIC_INLINE(afw_boolean_t)
afw_utf8_z_starts_with_z(
    const afw_utf8_z_t *s1_z, const afw_utf8_z_t *s2_z)
{
    while (*s2_z) {
        if (!*s1_z || *s1_z != *s2_z) {
            return false;
        }
        s1_z++;
        s2_z++;
    }
 
    return true;
}
 
 
AFW_DEFINE_STATIC_INLINE(int)
afw_utf8_z_compare_ignore_case(
    const afw_utf8_z_t *s1, const afw_utf8_z_t *s2, afw_xctx_t *xctx)
{
    afw_utf8_t a1, a2;
 
    a1.s = s1;
    a1.len = s1 ? strlen(s1): 0;
 
    a2.s = s2;
    a2.len = s2 ? strlen(s2): 0;
 
    return afw_utf8_compare_ignore_case(&a1, &a2, xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(afw_boolean_t)
afw_utf8_z_equal(
    const afw_utf8_z_t *s1, const afw_utf8_z_t *s2)
{
    return (s1 && s2 && (strcmp((const char *)s1, (const char *)s2) == 0
        || s1 == s2)) ? TRUE : FALSE;
}
 
 
AFW_DEFINE_STATIC_INLINE(afw_boolean_t)
afw_utf8_z_equal_ignore_case(
    const afw_utf8_z_t *s1, const afw_utf8_z_t *s2)
{
    return (strcasecmp((const char *)s1, (const char *)s2) == 0) ? true : false;
}
 
 
 
AFW_DECLARE_ELLIPSIS(const afw_utf8_z_t *)
afw_utf8_z_concat(
    const afw_pool_t *p, afw_xctx_t *xctx, ...);
 
 
AFW_DECLARE(const afw_object_t *)
afw_utf8_z_query_string_to_object(
    const afw_utf8_z_t *s, afw_xctx_t *xctx);
 
 
AFW_DECLARE(const afw_utf8_z_t *)
afw_utf8_z_printf_v(
    const afw_utf8_z_t *format_z, va_list ap,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(const afw_utf8_z_t *)
afw_utf8_z_printf(
    const afw_pool_t *p, afw_xctx_t *xctx, const afw_utf8_z_t *format_z, ...)
{
    va_list ap;
    const afw_utf8_z_t *result;
 
    va_start(ap, format_z);
    result = afw_utf8_z_printf_v(format_z, ap, p, xctx);
    va_end(ap);
 
    return result;
};
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_utf8_z_t *)
afw_utf8_z_file_name_from_path(
    const afw_utf8_z_t *path_z)
{
    const afw_utf8_z_t *file_name;
    const afw_utf8_z_t *c;
 
    if (!path_z) return "";
 
    for (c = file_name = path_z; *c; c++) {
        if ((*c == '/') || (*c == '\\')) {
            file_name = c + 1;
        }
    }
 
    return file_name;
}
 
 
AFW_DECLARE(const afw_utf8_z_t *)
afw_utf8_z_source_file(const afw_utf8_z_t *source_z);
 
 
 
AFW_DECLARE(const afw_stream_t *)
afw_utf8_stream_create(
    const afw_utf8_t *streamId,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(const afw_writer_t *)
afw_utf8_writer_create(
    const afw_utf8_t *tab,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_utf8_stream_get_current_cached_string(
    const afw_stream_t *stream,
    afw_utf8_t *current_cached_string,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_utf8_writer_current_string(
    const afw_writer_t *writer,
    afw_utf8_t *current_string,
    afw_xctx_t *xctx);
 
 
 
AFW_END_DECLARES
 
#endif /* __AFW_UTF8_H__ */