From 270f765c9113c4c7f9a39d8226384d080bfea0e9 Mon Sep 17 00:00:00 2001 From: Tom Hacohen Date: Tue, 27 Jul 2010 08:22:20 +0000 Subject: [PATCH] Eina: Added Eina_Unicode. SVN revision: 50532 --- legacy/eina/configure.ac | 10 ++ legacy/eina/src/include/Eina.h | 1 + legacy/eina/src/include/Makefile.am | 1 + legacy/eina/src/include/eina_config.h.in | 15 +++ legacy/eina/src/include/eina_unicode.h | 73 ++++++++++++ legacy/eina/src/lib/Makefile.am | 1 + legacy/eina/src/lib/eina_unicode.c | 145 +++++++++++++++++++++++ 7 files changed, 246 insertions(+) create mode 100644 legacy/eina/src/include/eina_unicode.h create mode 100644 legacy/eina/src/lib/eina_unicode.c diff --git a/legacy/eina/configure.ac b/legacy/eina/configure.ac index 73c4dd3e50..8fa6a5834a 100644 --- a/legacy/eina/configure.ac +++ b/legacy/eina/configure.ac @@ -296,7 +296,17 @@ AC_HEADER_TIME ### Checks for types +AC_CHECK_HEADER([inttypes.h], + [EINA_CONFIGURE_HAVE_INTTYPES_H="#define EINA_HAVE_INTTYPES_H"]) +AC_SUBST(EINA_CONFIGURE_HAVE_INTTYPES_H) +AC_CHECK_HEADER([stdint.h], + [EINA_CONFIGURE_HAVE_STDINT_H="#define EINA_HAVE_STDINT_H"]) +AC_SUBST(EINA_CONFIGURE_HAVE_STDINT_H) + +AC_CHECK_SIZEOF(wchar_t) +EINA_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t +AC_SUBST(EINA_SIZEOF_WCHAR_T) ### Checks for structures diff --git a/legacy/eina/src/include/Eina.h b/legacy/eina/src/include/Eina.h index 152bde26ad..32071aa682 100644 --- a/legacy/eina/src/include/Eina.h +++ b/legacy/eina/src/include/Eina.h @@ -149,6 +149,7 @@ extern "C" { #include "eina_matrixsparse.h" #include "eina_str.h" #include "eina_strbuf.h" +#include "eina_unicode.h" #include "eina_quadtree.h" #ifdef __cplusplus diff --git a/legacy/eina/src/include/Makefile.am b/legacy/eina/src/include/Makefile.am index 6022d439e3..bb3b4b0dee 100644 --- a/legacy/eina/src/include/Makefile.am +++ b/legacy/eina/src/include/Makefile.am @@ -46,6 +46,7 @@ eina_inline_tiler.x \ eina_str.h \ eina_inline_str.x \ eina_strbuf.h \ +eina_unicode.h \ eina_quadtree.h installed_mainheaderdir = $(includedir)/eina-@VMAJ@ diff --git a/legacy/eina/src/include/eina_config.h.in b/legacy/eina/src/include/eina_config.h.in index 4f0b3c3b0e..56331bb288 100644 --- a/legacy/eina/src/include/eina_config.h.in +++ b/legacy/eina/src/include/eina_config.h.in @@ -34,4 +34,19 @@ #endif @EINA_CONFIGURE_SAFETY_CHECKS@ +#ifdef EINA_HAVE_INTTYPES_H +# undef EINA_HAVE_INTTYPES_H +#endif +@EINA_CONFIGURE_HAVE_INTTYPES_H@ + +#ifdef EINA_HAVE_STDINT_H +# undef EINA_HAVE_STDINT_H +#endif +@EINA_CONFIGURE_HAVE_STDINT_H@ + +#ifdef EINA_SIZEOF_WCHAR_T +# undef EINA_SIZEOF_WCHAR_T +#endif +#define EINA_SIZEOF_WCHAR_T @EINA_SIZEOF_WCHAR_T@ + #endif /* EINA_CONFIG_H_ */ diff --git a/legacy/eina/src/include/eina_unicode.h b/legacy/eina/src/include/eina_unicode.h new file mode 100644 index 0000000000..08192cd835 --- /dev/null +++ b/legacy/eina/src/include/eina_unicode.h @@ -0,0 +1,73 @@ +#ifndef EINA_UNICODE_H +#define EINA_UNICODE_H + +/** + * @addtogroup Eina_Data_Types_Group Data Types + * + * @{ + */ +/** + * @addtogroup Eina_Unicode_String Unicode String + * + * @brief These functions provide basic unicode string handling + * + * Eina_Unicode is a type that holds unicode codepoints. + * + * @{ + */ + +#include "eina_config.h" + +/** + * @typedef Eina_Unicode + * A type that holds Unicode codepoints. + */ +#if EINA_SIZEOF_WCHAR_T >= 4 +# include +typedef wchar_t Eina_Unicode; +#elif defined(EINA_HAVE_INTTYPES_H) +# include +typedef uint32_t Eina_Unicode; +#elif defined(EINA_HAVE_STDINT_H) +# include +typedef uint32_t Eina_Unicode; +#else +/* Hope that int is big enough */ +typedef unsigned int Eina_Unicode; +#endif + +#include + +#include "eina_types.h" + +extern const Eina_Unicode *EINA_UNICODE_EMPTY_STRING; + +EAPI size_t +eina_unicode_strlen(const Eina_Unicode *ustr) EINA_ARG_NONNULL(1); + +EAPI Eina_Unicode * +eina_unicode_strdup(const Eina_Unicode *text) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC; + +EAPI int +eina_unicode_strcmp(const Eina_Unicode *a, const Eina_Unicode *b) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2); + +EAPI Eina_Unicode * +eina_unicode_strcpy(Eina_Unicode *dest, const Eina_Unicode *source); + +EAPI Eina_Unicode * +eina_unicode_strstr(const Eina_Unicode *haystack, const Eina_Unicode *needle) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2); + +EAPI Eina_Unicode * +eina_unicode_strncpy(Eina_Unicode *dest, const Eina_Unicode *source, size_t n); + +EAPI Eina_Unicode * +eina_unicode_escape(const Eina_Unicode *str); + +/** + * @} + */ +/** + * @} + */ + +#endif diff --git a/legacy/eina/src/lib/Makefile.am b/legacy/eina/src/lib/Makefile.am index 000d936744..7628e7f127 100644 --- a/legacy/eina/src/lib/Makefile.am +++ b/legacy/eina/src/lib/Makefile.am @@ -39,6 +39,7 @@ eina_hamster.c \ eina_safety_checks.c \ eina_str.c \ eina_strbuf.c \ +eina_unicode.c \ eina_quadtree.c if EINA_STATIC_BUILD_CHAINED_POOL diff --git a/legacy/eina/src/lib/eina_unicode.c b/legacy/eina/src/lib/eina_unicode.c new file mode 100644 index 0000000000..72234b463b --- /dev/null +++ b/legacy/eina/src/lib/eina_unicode.c @@ -0,0 +1,145 @@ +/* EINA - EFL data type library + * Copyright (C) 2010-2010 Tom Hacohen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; + * if not, see . + + */ + +#include +#include "eina_unicode.h" + +/* FIXME: check if sizeof(wchar_t) == sizeof(Eina_Unicode) if so, + * probably better to use the standard functions */ + +const Eina_Unicode *EINA_UNICODE_EMPTY_STRING = {0}; +/** + * @brief Same as the standard strcmp just with Eina_Unicode instead of char. + */ +EAPI int +eina_unicode_strcmp(const Eina_Unicode *a, const Eina_Unicode *b) +{ + for ( ; *a && *a == *b ; a++, b++) + ; + if (*a == *b) + return 0; + else if (*a < *b) + return -1; + else + return 1; +} + +/** + * @brief Same as the standard strcpy just with Eina_Unicode instead of char. + */ +EAPI Eina_Unicode * +eina_unicode_strcpy(Eina_Unicode *dest, const Eina_Unicode *source) +{ + Eina_Unicode *ret = dest; + + while (*source) + *dest++ = *source++; + return ret; +} + +/** + * @brief Same as the standard strncpy just with Eina_Unicode instead of char. + */ +EAPI Eina_Unicode * +eina_unicode_strncpy(Eina_Unicode *dest, const Eina_Unicode *source, size_t n) +{ + Eina_Unicode *ret = dest; + + for (n = 0 ; *source && n ; n--) + *dest++ = *source++; + for ( ; n ; n--) + *dest++ = 0; + return ret; +} + +/** + * @brief Same as the standard strlen just with Eina_Unicode instead of char. + */ +EAPI size_t +eina_unicode_strlen(const Eina_Unicode *ustr) +{ + const Eina_Unicode *end; + for (end = ustr ; *end ; end++) + ; + return end - ustr; +} + +/** + * @brief Same as the standard strdup just with Eina_Unicode instead of char. + */ +EAPI Eina_Unicode * +eina_unicode_strdup(const Eina_Unicode *text) +{ + Eina_Unicode *ustr; + int len; + + len = eina_unicode_strlen(text); + ustr = (Eina_Unicode *) calloc(sizeof(Eina_Unicode), len + 1); + memcpy(ustr, text, len * sizeof(Eina_Unicode)); + + return ustr; +} + +/** + * @brief Same as the standard strdup just with Eina_Unicode instead of char. + */ +EAPI Eina_Unicode * +eina_unicode_strstr(const Eina_Unicode *haystack, const Eina_Unicode *needle) +{ + const Eina_Unicode *i, *j; + + for (i = haystack ; *i ; i++) + { + haystack = i; /* set this location as the base position */ + for (j = needle ; *j && *i && *j == *i ; j++, i++) + ; + + if (!*j) /*if we got to the end of j this means we got a full match */ + { + return (Eina_Unicode *) haystack; /* return the new base position */ + } + } + + return NULL; +} + +/** + * @see eina_str_escape() + */ +EAPI Eina_Unicode * +eina_unicode_escape(const Eina_Unicode *str) +{ + Eina_Unicode *s2, *d; + const Eina_Unicode *s; + + s2 = malloc((eina_unicode_strlen(str) * 2) + 1); + if (!s2) return NULL; + for (s = str, d = s2; *s != 0; s++, d++) + { + if ((*s == ' ') || (*s == '\\') || (*s == '\'')) + { + *d = '\\'; + d++; + } + *d = *s; + } + *d = 0; + return s2; +} +