CDB: /var/home/joerg/c/CDB/include/string

00001 /*
00002  * Unicode abstraction test.
00003  *
00004  * Dieser source wurde zur abstraktion der Unicode funktionalität in Linux environments geschrieben.
00005  * Es wird die System wchar_t Implementation genutzt wenn der Define USE_WCHAR definiert ist.
00006  * Es wird ICU verwendet, wenn USE_ICU gesetzt ist.
00007  * Ist keine der definitionen gesetzt wird char und die zugehoerigen Funktionen verwendet.
00008  *
00009  * CDB is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2 of the License, or
00012  * (at your option) any later version.
00013  *
00014  * CDB is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00017  * GNU General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU General Public License
00020  * along with CDB; if not, write to the Free Software
00021  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022  *
00023  * Author: Joerg Hundertmarck
00024  * Datum: 09.07.2005
00025  */
00026 
00027 /* Testing for logic template specifcations */
00028 #ifndef _STRING_FORWARD_H
00029 #define _STRING_FORWARD_H
00030 
00031 #include "sysdep.h"
00032 
00033 #ifdef USE_ICU
00034 
00035 #ifndef SUPPORT_ICU
00036 #define SUPPORT_ICU
00037 #endif
00038 
00039 #undef USE_WCHAR
00040 #undef USE_NATIVE
00041 
00042 #elif defined(USE_WCHAR)
00043 
00044 #ifndef SUPPORT_WCHAR
00045 #define SUPPORT_WCHAR
00046 #endif
00047 
00048 #undef USE_ICU
00049 #undef USE_NATIVE
00050 
00051 #else
00052 
00053 #ifndef USE_NATIVE
00054 #define USE_NATIVE
00055 #endif
00056 
00057 #ifndef SUPPORT_NATIVE
00058 #define SUPPORT_NATIVE
00059 #endif
00060 
00061 #undef USE_ICU
00062 #undef USE_WCHAR
00063 
00064 #endif
00065 
00066 /* FORCE NATIVE */
00067 #ifndef SUPPORT_NATIVE
00068 #define SUPPORT_NATIVE
00069 #endif
00070 
00071 /* Specifying includes for different support levels. */
00072 
00073 #ifdef SUPPORT_ICU
00074 
00075 #include <unicode/ustdio.h>
00076 #include <unicode/ustring.h>
00077 #include <unicode/utf16.h>
00078 #include <unicode/ucnv.h>
00079 
00080 #endif
00081 
00082 #ifdef SUPPORT_WCHAR
00083 
00084 #ifndef __USE_ISOC99
00085 #define __USE_ISOC99
00086 #endif
00087 #ifndef __USE_GNU
00088 #define __USE_GNU
00089 #endif
00090 #include <wchar.h>
00091 #include <wctype.h>
00092 #include <stdlib.h>
00093 #include <locale.h>
00094 #include <stdarg.h>
00095 
00096 #endif
00097 
00098 #ifdef SUPPORT_NATIVE
00099 
00100 #include <stdio.h>
00101 #include <string.h>
00102 
00103 #endif
00104 
00105 #ifdef __cplusplus
00106 extern "C" {
00107 #endif
00108 
00109 /* Begining with definition of main Mchar implementation */
00110 
00112 typedef struct st_string_forward_conversion {
00113 #ifdef SUPPORT_ICU
00114         UConverter *icu_cnv;
00115 #endif
00116 #ifdef SUPPORT_WCHAR
00117         char wchar_dummy;
00118 #endif
00119 #ifdef SUPPORT_NATIVE
00120         char native_dummy;
00121 #endif
00122 } string_forward_conversion_t;
00123 
00125 string_forward_conversion_t *MprepareConversion(void);
00127 void MfreeConversion(string_forward_conversion_t *);
00128 
00129 /* Some macros are need to implemted or helped by functions that definitions
00130  * should be here. */
00131 #ifdef SUPPORT_WCHAR
00132 
00133 int WcharSnprintf(wchar_t *dst, int s, const char *fmt, ...);
00134 #endif
00135 
00136 /* Now it is time to setup the conversion macros and functions between different supported standars. */
00137 /* WCHAR => ICU */
00138 /* ICU => WCHAR */
00139 /* These macros are designated to 16 or 32 bit wchar implementation */
00140 #if defined(SUPPORT_WCHAR) && defined(SUPPORT_ICU)
00141 #ifdef U_WCHAR_IS_UTF32
00142 
00143 #define WcharToIcu(cnv, dst, dst_size, src, src_size) ({ \
00144         register int _ret = 0; \
00145         UErrorCode errorCode=U_ZERO_ERROR; \
00146         u_strFromUTF32(dst, dst_size, NULL, (const UChar32*)src, src_size, &errorCode); \
00147         if(U_FAILURE(errorCode) || errorCode==U_STRING_NOT_TERMINATED_WARNING) { \
00148                 printf("problem converting string to Unicode: %s\n", u_errorName(errorCode)); \
00149                 _ret = -1; \
00150         } \
00151         _ret; \
00152 })
00153 
00154 #define IcuToWchar(cnv, dst, dst_size, src, src_size) ({ \
00155         register int _ret = 0; \
00156         UErrorCode errorCode=U_ZERO_ERROR; \
00157         u_strToUTF32((UChar32*)dst, dst_size, NULL, src, src_size, &errorCode); \
00158         if(U_FAILURE(errorCode) || errorCode==U_STRING_NOT_TERMINATED_WARNING) { \
00159                 printf("problem converting string to Unicode: %s\n", u_errorName(errorCode)); \
00160                 _ret = -1; \
00161         } \
00162         _ret; \
00163 })
00164 #else
00165 
00166 #define WcharToIcu(cnv, dst, dst_size, src, src_size) wcsncpy(dst, src, dst_size)
00167 
00168 #define IcuToWchar(cnv, dst, dst_size, src, src_size) wcsncpy(dst, src, dst_size)
00169 #endif
00170 #endif
00171 
00172 #if defined(SUPPORT_NATIVE) && defined(SUPPORT_ICU)
00173 
00174 #define CharToIcu(cnv, dst, dst_size, src, src_size) ({ \
00175         register int _ret = 0; \
00176         UErrorCode errorCode=U_ZERO_ERROR; \
00177         ucnv_toUChars(cnv->icu_cnv, dst, dst_size, src, src_size, &errorCode); \
00178         if(U_FAILURE(errorCode) || errorCode==U_STRING_NOT_TERMINATED_WARNING) { \
00179                 printf("problem converting string to Unicode: %s\n", u_errorName(errorCode)); \
00180                 _ret = -1; \
00181         } \
00182         _ret; \
00183 })
00184 
00185 #define IcuToChar(cnv, dst, dst_size, src, src_size) ({ \
00186         register int _ret = 0; \
00187         UErrorCode errorCode=U_ZERO_ERROR; \
00188         ucnv_fromUChars(cnv->icu_cnv, dst, dst_size, src, src_size, &errorCode); \
00189         if(U_FAILURE(errorCode) || errorCode==U_STRING_NOT_TERMINATED_WARNING) { \
00190                 printf("problem converting string from Unicode: %s\n", u_errorName(errorCode)); \
00191                 _ret = -1; \
00192         } \
00193         _ret; \
00194 })
00195 #endif
00196 
00197 #if defined(SUPPORT_WCHAR) && defined(SUPPORT_NATIVE)
00198 
00199 #define CharToWchar(cnv, dst, dst_size, src, src_size) mbstowcs(dst, src, dst_size)
00200 
00201 #define WcharToChar(cnv, dst, dst_size, src, src_size) wcstombs(dst, src, dst_size)
00202 #endif
00203 
00204 /* Here comes the maros for icu implementation. */
00205 #ifdef USE_ICU
00206 
00207 #define Mchar UChar
00208 #define Mdecln(name, value, len) U_STRING_DECL(name, value, len)
00209 #define Mdecl(name, value) U_STRING_DECL(name, value, sizeof(value)-1)
00210 #define Minitn(name, value, len) U_STRING_INIT(name, value, len)
00211 #define Minit(name, value) U_STRING_INIT(name, value, sizeof(value)-1)
00212 #define Mstrncpy(dst, src, dst_size) u_strncpy(dst, src, dst_size)
00213 #define Mstrncat(dst, src, dst_size) u_strncat(dst, src, dst_size)
00214 #define Mstrlen(s) u_strlen(s)
00215 /* static memory */
00216 #define Msizeof(s) (sizeof(s)/sizeof(s[0]))
00217 /* dynamic memory */
00218 #define Mstrsize(s) Mstrlen(s)+1
00219 #define Msnprintf(dst, s, fmt ...) u_snprintf(dst, s, NULL, fmt)
00220 #define MSC "%S"
00221 #define Mstrcmp(s1, s2) u_strcmp(s1, s2)
00222 #define Mstrstr(in, for) u_strstr(in, for)
00223 #define Mstrncmp(s1, s2, c) u_strncmp(s1, s2, c)
00224 #define Mstrdup(s) ({ \
00225 int _size = (u_strlen(s)+1)*sizeof(UChar); \
00226 UChar *_ret = (UChar*)malloc(_size); \
00227 u_strncpy(_ret, s, _size); \
00228 _ret; \
00229 })
00230 #define Mtoupper(c) u_toupper(c)
00231 #define Mtolower(c) u_tolower(c)
00232 
00233 int MUtf8To(string_forward_conversion_t *cnv, Mchar *dst, size_t dst_size, const char *src, size_t src_size);
00234 int MUtf8From(string_forward_conversion_t *cnv, char *dst, size_t dst_size, const Mchar *src, size_t src_size);
00235 
00236 #ifdef SUPPORT_NATIVE
00237 #define MAsciiTo(cnv, dst, dst_size, src, src_size) CharToIcu(cnv, dst, dst_size, src, src_size)
00238 #define MAsciiFrom(cnv, dst, dst_size, src, src_size) IcuToChar(cnv, dst, dst_size, src, src_size)
00239 #endif
00240 #ifdef SUPPORT_WCHAR
00241 #define MwcharTo(cnv, dst, dst_size, src, src_size) WcharToIcu(cnv, dst, dst_size, src, src_size)
00242 #define MwcharFrom(cnv, dst, dst_size, src, src_size) IcuToWchar(cnv, dst, dst_size, src, src_size)
00243 #endif
00244 #define MicuTo(cnv, dst, dst_size, src, src_size) Mstrncpy(dst, src, dst_size)
00245 #define MicuFrom(cnv, dst, dst_size, src, src_size) Mstrncpy(dst, src, dst_size)
00246 
00247 #endif /* END OF USE_ICU */
00248 
00249 /* Now it is time for wchar */
00250 #ifdef USE_WCHAR
00251 
00252 #define Mchar wchar_t
00253 #define Mdecln(name, value, len) static Mchar name[len] = L ## value
00254 #define Mdecl(name, value) static Mchar name[] = L ## value
00255 #define Minitn(name, value, len)
00256 #define Minit(name, value)
00257 #define Mstrncpy(dst, src, dst_size) wcsncpy(dst, src, dst_size)
00258 #define Mstrncat(dst, src, dst_size) wcsncat(dst, src, dst_size)
00259 #define MAsciiTo(cnv, dst, dst_size, src, src_size) CharToWchar(cnv, dst, dst_size, src, src_size)
00260 #define MAsciiFrom(cnv, dst, dst_size, src, src_size) WcharToChar(cnv, dst, dst_size, src, src_size)
00261 #define Mstrlen(s) wcslen(s)
00262 #define Mstrsize(s) Mstrlen(s)+1
00263 #define Msizeof(s) (sizeof(s)/sizeof(Mchar))
00264 #define Msnprintf(dst, s, fmt ...) WcharSnprintf(dst, s, fmt)
00265 #define MSC "%S"
00266 #define Mstrcmp(s1, s2) wcscmp(s1, s2)
00267 #define Mstrncmp(s1, s2, c) wcsncmp(s1, s2, c)
00268 #define Mstrncmp(s1, s2, c) wcsncmp(s1, s2, c)
00269 #define Mstrstr(in, for) wcsstr(in, for)
00270 #define Mstrdup(s) wcsdup(s)
00271 #define Mtoupper(c) towupper(c)
00272 #define Mtolower(c) towlower(c)
00273 
00274 int MUtf8To(string_forward_conversion_t *cnv, Mchar *dst, size_t dst_size, const char *src, size_t src_size);
00275 int MUtf8From(string_forward_conversion_t *cnv, char *dst, size_t dst_size, const Mchar *src, size_t src_size);
00276 
00277 #ifdef SUPPORT_NATIVE
00278 #define MAsciiTo(cnv, dst, dst_size, src, src_size) CharToWchar(cnv, dst, dst_size, src, src_size)
00279 #define MAsciiFrom(cnv, dst, dst_size, src, src_size) WcharToChar(cnv, dst, dst_size, src, src_size)
00280 #endif
00281 #define MwcharTo(cnv, dst, dst_size, src, src_size) Mstrncpy(dst, src, dst_size)
00282 #define MwcharFrom(cnv, dst, dst_size, src, src_size) Mstrncpy(dst, src, dst_size)
00283 #ifdef SUPPORT_ICU
00284 #define MicuTo(cnv, dst, dst_size, src, src_size) IcuToWchar(cnv, dst, dst_size, src, src_size)
00285 #define MicuFrom(cnv, dst, dst_size, src, src_size) WcharToIcu(cnv, dst, dst_size, src, src_size)
00286 #endif
00287 
00288 #endif /* END OF USE_WCHAR */
00289 
00290 /* And the last one is native char. */
00291 #ifdef USE_NATIVE
00292 
00294 #define Mchar char
00295 
00297 #define Mdecln(name, value, len) static Mchar name[len] = value
00298 
00300 #define Mdecl(name, value) static Mchar name[] = value
00301 
00303 #define Minitn(name, value, len)
00304 
00306 #define Minit(name, value)
00307 
00309 #define Mstrncpy(dst, src, dst_size) strncpy((char*)(dst), (const char*)(src), dst_size)
00310 
00312 #define Mstrncat(dst, src, dst_size) strncat((Mchar*)dst, (const Mchar*)src, dst_size)
00313 
00315 #define Mstrlen(s) strlen(s)
00316 
00325 #define Msizeof(s) sizeof(s)
00326 
00333 #define Mstrsize(s) (Mstrlen(s)+1)
00334 
00340 #define Msnprintf(dst, s, fmt ...) snprintf(dst, s, fmt)
00341 
00348 #define MSC "%s"
00349 
00353 #define Mstrcmp(s1, s2) strcmp(s1, s2)
00354 
00358 #define Mstrstr(in, for) strstr(in, for)
00359 
00363 #define Mstrncmp(s1, s2, c) strncmp(s1, s2, c)
00364 
00368 #define Mstrdup(s) strdup(s)
00369 
00370 #define Mtoupper(c) toupper(c)
00371 #define Mtolower(c) tolower(c)
00372 
00374 #define MAsciiTo(cnv, dst, dst_size, src, src_size) Mstrncpy(dst, src, ((size_t)dst_size > (size_t)src_size ? src_size + 1 : dst_size))
00375 
00376 #define MAsciiFrom(cnv, dst, dst_size, src, src_size) Mstrncpy(dst, src, ((size_t)dst_size > (size_t)src_size ? src_size + 1 : dst_size))
00377 #ifdef SUPPORT_WCHAR
00378 
00379 #define MwcharTo(cnv, dst, dst_size, src, src_size) WcharToChar(cnv, dst, dst_size, src, src_size)
00380 
00381 #define MwcharFrom(cnv, dst, dst_size, src, src_size) CharToWchar(cnv, dst, dst_size, src, src_size)
00382 #endif
00383 #ifdef SUPPORT_ICU
00384 
00385 #define MicuTo(cnv, dst, dst_size, src, src_size) IcuToChar(cnv, dst, dst_size, src, src_size)
00386 
00387 #define MicuFrom(cnv, dst, dst_size, src, src_size) CharToIcu(cnv, dst, dst_size, src, src_size)
00388 #endif
00389 
00390 int MUtf8To(string_forward_conversion_t *cnv, Mchar *dst, size_t dst_size, const char *src, size_t src_size);
00391 int MUtf8From(string_forward_conversion_t *cnv, char *dst, size_t dst_size, const Mchar *src, size_t src_size);
00392 
00393 /* END OF USE_NATIVE */
00394 #endif
00395 
00396 Mchar *MdupAsciiTo(const char *s);
00397 char *MdupAsciiFrom(const Mchar *s);
00398 int Matoi(const Mchar *s);
00399 int64_t Matoll(const Mchar *s);
00400 double Matof(const Mchar *s);
00401 void Mcopy2A(char *dst, const Mchar *src, int size);
00402 void Acopy2M(Mchar *dst, const char *src, int size);
00403 
00404 #ifdef __cplusplus
00405 }
00406 #endif
00407 
00408 #endif
/var/home/joerg/c/CDB/include/string_forward.h
