utf8proc
annotate utf8proc.h @ 12:82d33620bb8a
Compatibility with Microsoft Visual Studio; Make utf8proc usable in C++ programs
- Patches for compatibility with Microsoft Visual Studio
- Fixes to make utf8proc usable in C++ programs
- Patches for compatibility with Microsoft Visual Studio
- Fixes to make utf8proc usable in C++ programs
author | Jan Nijtmans |
---|---|
date | Thu Oct 08 12:00:00 2009 +0200 (2009-10-08) |
parents | 00d2bcbdc945 |
children | 15450ff3d454 |
rev | line source |
---|---|
jbe@0 | 1 /* |
jbe@10 | 2 * Copyright (c) 2009 Public Software Group e. V., Berlin, Germany |
jbe@0 | 3 * |
jbe@7 | 4 * Permission is hereby granted, free of charge, to any person obtaining a |
jbe@7 | 5 * copy of this software and associated documentation files (the "Software"), |
jbe@7 | 6 * to deal in the Software without restriction, including without limitation |
jbe@7 | 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
jbe@7 | 8 * and/or sell copies of the Software, and to permit persons to whom the |
jbe@7 | 9 * Software is furnished to do so, subject to the following conditions: |
jbe@0 | 10 * |
jbe@7 | 11 * The above copyright notice and this permission notice shall be included in |
jbe@7 | 12 * all copies or substantial portions of the Software. |
jbe@0 | 13 * |
jbe@7 | 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
jbe@7 | 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
jbe@7 | 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
jbe@7 | 17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
jbe@7 | 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
jbe@7 | 19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
jbe@7 | 20 * DEALINGS IN THE SOFTWARE. |
jbe@0 | 21 */ |
jbe@7 | 22 |
jbe@0 | 23 |
jbe@0 | 24 /* |
jbe@0 | 25 * File name: utf8proc.h |
jbe@0 | 26 * |
jbe@0 | 27 * Description: |
jbe@0 | 28 * Header files for libutf8proc, which is a mapping tool for UTF-8 strings |
jbe@0 | 29 * with following features: |
jbe@0 | 30 * - decomposing and composing of strings |
jbe@0 | 31 * - replacing compatibility characters with their equivalents |
jbe@0 | 32 * - stripping of "default ignorable characters" |
jbe@0 | 33 * like SOFT-HYPHEN or ZERO-WIDTH-SPACE |
jbe@3 | 34 * - folding of certain characters for string comparison |
jbe@3 | 35 * (e.g. HYPHEN U+2010 and MINUS U+2212 to ASCII "-") |
jbe@3 | 36 * (see "LUMP" option) |
jbe@0 | 37 * - optional rejection of strings containing non-assigned code points |
jbe@0 | 38 * - stripping of control characters |
jbe@3 | 39 * - stripping of character marks (accents, etc.) |
jbe@0 | 40 * - transformation of LF, CRLF, CR and NEL to line-feed (LF) |
jbe@0 | 41 * or to the unicode chararacters for paragraph separation (PS) |
jbe@0 | 42 * or line separation (LS). |
jbe@0 | 43 * - unicode case folding (for case insensitive string comparisons) |
jbe@7 | 44 * - rejection of illegal UTF-8 data |
jbe@7 | 45 * (i.e. UTF-8 encoded UTF-16 surrogates) |
jbe@0 | 46 * - support for korean hangul characters |
jbe@2 | 47 * Unicode Version 5.0.0 is supported. |
jbe@0 | 48 */ |
jbe@0 | 49 |
jbe@0 | 50 |
jbe@0 | 51 #ifndef UTF8PROC_H |
jbe@0 | 52 #define UTF8PROC_H |
jbe@0 | 53 |
jbe@0 | 54 |
jbe@0 | 55 #include <stdlib.h> |
Jan@12 | 56 #include <sys/types.h> |
Jan@12 | 57 #ifdef _MSC_VER |
Jan@12 | 58 typedef signed char int8_t; |
Jan@12 | 59 typedef unsigned char uint8_t; |
Jan@12 | 60 typedef short int16_t; |
Jan@12 | 61 typedef unsigned short uint16_t; |
Jan@12 | 62 typedef int int32_t; |
Jan@12 | 63 #ifdef _WIN64 |
Jan@12 | 64 #define ssize_t __int64 |
Jan@12 | 65 #else |
Jan@12 | 66 #define ssize_t int |
Jan@12 | 67 #endif |
Jan@12 | 68 typedef unsigned char bool; |
Jan@12 | 69 enum {false, true}; |
Jan@12 | 70 #else |
jbe@0 | 71 #include <stdbool.h> |
jbe@0 | 72 #include <inttypes.h> |
Jan@12 | 73 #endif |
jbe@0 | 74 #include <limits.h> |
jbe@0 | 75 |
Jan@12 | 76 #ifdef __cplusplus |
Jan@12 | 77 extern "C" { |
Jan@12 | 78 #endif |
Jan@12 | 79 |
jbe@0 | 80 #ifndef SSIZE_MAX |
jbe@10 | 81 #define SSIZE_MAX ((size_t)SIZE_MAX/2) |
jbe@0 | 82 #endif |
jbe@0 | 83 |
jbe@2 | 84 #define UTF8PROC_NULLTERM (1<<0) |
jbe@2 | 85 #define UTF8PROC_STABLE (1<<1) |
jbe@2 | 86 #define UTF8PROC_COMPAT (1<<2) |
jbe@2 | 87 #define UTF8PROC_COMPOSE (1<<3) |
jbe@2 | 88 #define UTF8PROC_DECOMPOSE (1<<4) |
jbe@2 | 89 #define UTF8PROC_IGNORE (1<<5) |
jbe@2 | 90 #define UTF8PROC_REJECTNA (1<<6) |
jbe@2 | 91 #define UTF8PROC_NLF2LS (1<<7) |
jbe@2 | 92 #define UTF8PROC_NLF2PS (1<<8) |
jbe@2 | 93 #define UTF8PROC_NLF2LF (UTF8PROC_NLF2LS | UTF8PROC_NLF2PS) |
jbe@2 | 94 #define UTF8PROC_STRIPCC (1<<9) |
jbe@2 | 95 #define UTF8PROC_CASEFOLD (1<<10) |
jbe@2 | 96 #define UTF8PROC_CHARBOUND (1<<11) |
jbe@3 | 97 #define UTF8PROC_LUMP (1<<12) |
jbe@3 | 98 #define UTF8PROC_STRIPMARK (1<<13) |
jbe@0 | 99 /* |
jbe@0 | 100 * Flags being regarded by several functions in the library: |
jbe@2 | 101 * NULLTERM: The given UTF-8 input is NULL terminated. |
jbe@2 | 102 * STABLE: Unicode Versioning Stability has to be respected. |
jbe@2 | 103 * COMPAT: Compatiblity decomposition |
jbe@2 | 104 * (i.e. formatting information is lost) |
jbe@2 | 105 * COMPOSE: Return a result with composed characters. |
jbe@2 | 106 * DECOMPOSE: Return a result with decomposed characters. |
jbe@2 | 107 * IGNORE: Strip "default ignorable characters" |
jbe@7 | 108 * REJECTNA: Return an error, if the input contains unassigned |
jbe@7 | 109 * code points. |
jbe@2 | 110 * NLF2LS: Indicating that NLF-sequences (LF, CRLF, CR, NEL) are |
jbe@2 | 111 * representing a line break, and should be converted to the |
jbe@2 | 112 * unicode character for line separation (LS). |
jbe@2 | 113 * NLF2PS: Indicating that NLF-sequences are representing a paragraph |
jbe@2 | 114 * break, and should be converted to the unicode character for |
jbe@2 | 115 * paragraph separation (PS). |
jbe@2 | 116 * NLF2LF: Indicating that the meaning of NLF-sequences is unknown. |
jbe@2 | 117 * STRIPCC: Strips and/or convers control characters. |
jbe@7 | 118 * NLF-sequences are transformed into space, except if one of |
jbe@7 | 119 * the NLF2LS/PS/LF options is given. |
jbe@2 | 120 * HorizontalTab (HT) and FormFeed (FF) are treated as a |
jbe@2 | 121 * NLF-sequence in this case. |
jbe@2 | 122 * All other control characters are simply removed. |
jbe@2 | 123 * CASEFOLD: Performs unicode case folding, to be able to do a |
jbe@2 | 124 * case-insensitive string comparison. |
jbe@7 | 125 * CHARBOUND: Inserts 0xFF bytes at the beginning of each sequence which |
jbe@7 | 126 * is representing a single grapheme cluster (see UAX#29). |
jbe@3 | 127 * LUMP: Lumps certain characters together |
jbe@3 | 128 * (e.g. HYPHEN U+2010 and MINUS U+2212 to ASCII "-"). |
jbe@3 | 129 * (See lump.txt for details.) |
jbe@7 | 130 * If NLF2LF is set, this includes a transformation of |
jbe@7 | 131 * paragraph and line separators to ASCII line-feed (LF). |
jbe@3 | 132 * STRIPMARK: Strips all character markings |
jbe@3 | 133 * (non-spacing, spacing and enclosing) (i.e. accents) |
jbe@3 | 134 * NOTE: this option works only with COMPOSE or DECOMPOSE |
jbe@0 | 135 */ |
jbe@0 | 136 |
jbe@0 | 137 #define UTF8PROC_ERROR_NOMEM -1 |
jbe@0 | 138 #define UTF8PROC_ERROR_OVERFLOW -2 |
jbe@0 | 139 #define UTF8PROC_ERROR_INVALIDUTF8 -3 |
jbe@0 | 140 #define UTF8PROC_ERROR_NOTASSIGNED -4 |
jbe@3 | 141 #define UTF8PROC_ERROR_INVALIDOPTS -5 |
jbe@0 | 142 /* |
jbe@0 | 143 * Error codes being returned by almost all functions: |
jbe@0 | 144 * ERROR_NOMEM: Memory could not be allocated. |
jbe@0 | 145 * ERROR_OVERFLOW: The given string is too long to be processed. |
jbe@0 | 146 * ERROR_INVALIDUTF8: The given string is not a legal UTF-8 string. |
jbe@0 | 147 * ERROR_NOTASSIGNED: The REJECTNA flag was set, |
jbe@0 | 148 * and an unassigned code point was found. |
jbe@3 | 149 * ERROR_INVALIDOPTS: Invalid options have been used. |
jbe@0 | 150 */ |
jbe@0 | 151 |
jbe@3 | 152 typedef int16_t utf8proc_propval_t; |
jbe@0 | 153 typedef struct utf8proc_property_struct { |
jbe@3 | 154 utf8proc_propval_t category; |
jbe@3 | 155 utf8proc_propval_t combining_class; |
jbe@3 | 156 utf8proc_propval_t bidi_class; |
jbe@3 | 157 utf8proc_propval_t decomp_type; |
jbe@0 | 158 const int32_t *decomp_mapping; |
jbe@7 | 159 unsigned bidi_mirrored:1; |
jbe@7 | 160 int32_t uppercase_mapping; |
jbe@7 | 161 int32_t lowercase_mapping; |
jbe@7 | 162 int32_t titlecase_mapping; |
jbe@7 | 163 int32_t comb1st_index; |
jbe@7 | 164 int32_t comb2nd_index; |
jbe@7 | 165 unsigned comp_exclusion:1; |
jbe@7 | 166 unsigned ignorable:1; |
jbe@7 | 167 unsigned control_boundary:1; |
jbe@7 | 168 unsigned extend:1; |
jbe@0 | 169 const int32_t *casefold_mapping; |
jbe@0 | 170 } utf8proc_property_t; |
jbe@0 | 171 |
jbe@2 | 172 #define UTF8PROC_CATEGORY_LU 1 |
jbe@2 | 173 #define UTF8PROC_CATEGORY_LL 2 |
jbe@2 | 174 #define UTF8PROC_CATEGORY_LT 3 |
jbe@2 | 175 #define UTF8PROC_CATEGORY_LM 4 |
jbe@2 | 176 #define UTF8PROC_CATEGORY_LO 5 |
jbe@2 | 177 #define UTF8PROC_CATEGORY_MN 6 |
jbe@2 | 178 #define UTF8PROC_CATEGORY_MC 7 |
jbe@2 | 179 #define UTF8PROC_CATEGORY_ME 8 |
jbe@2 | 180 #define UTF8PROC_CATEGORY_ND 9 |
jbe@2 | 181 #define UTF8PROC_CATEGORY_NL 10 |
jbe@2 | 182 #define UTF8PROC_CATEGORY_NO 11 |
jbe@2 | 183 #define UTF8PROC_CATEGORY_PC 12 |
jbe@2 | 184 #define UTF8PROC_CATEGORY_PD 13 |
jbe@2 | 185 #define UTF8PROC_CATEGORY_PS 14 |
jbe@2 | 186 #define UTF8PROC_CATEGORY_PE 15 |
jbe@2 | 187 #define UTF8PROC_CATEGORY_PI 16 |
jbe@2 | 188 #define UTF8PROC_CATEGORY_PF 17 |
jbe@2 | 189 #define UTF8PROC_CATEGORY_PO 18 |
jbe@2 | 190 #define UTF8PROC_CATEGORY_SM 19 |
jbe@2 | 191 #define UTF8PROC_CATEGORY_SC 20 |
jbe@2 | 192 #define UTF8PROC_CATEGORY_SK 21 |
jbe@2 | 193 #define UTF8PROC_CATEGORY_SO 22 |
jbe@2 | 194 #define UTF8PROC_CATEGORY_ZS 23 |
jbe@2 | 195 #define UTF8PROC_CATEGORY_ZL 24 |
jbe@2 | 196 #define UTF8PROC_CATEGORY_ZP 25 |
jbe@2 | 197 #define UTF8PROC_CATEGORY_CC 26 |
jbe@2 | 198 #define UTF8PROC_CATEGORY_CF 27 |
jbe@2 | 199 #define UTF8PROC_CATEGORY_CS 28 |
jbe@2 | 200 #define UTF8PROC_CATEGORY_CO 29 |
jbe@2 | 201 #define UTF8PROC_CATEGORY_CN 30 |
jbe@2 | 202 #define UTF8PROC_BIDI_CLASS_L 1 |
jbe@2 | 203 #define UTF8PROC_BIDI_CLASS_LRE 2 |
jbe@2 | 204 #define UTF8PROC_BIDI_CLASS_LRO 3 |
jbe@2 | 205 #define UTF8PROC_BIDI_CLASS_R 4 |
jbe@2 | 206 #define UTF8PROC_BIDI_CLASS_AL 5 |
jbe@2 | 207 #define UTF8PROC_BIDI_CLASS_RLE 6 |
jbe@2 | 208 #define UTF8PROC_BIDI_CLASS_RLO 7 |
jbe@2 | 209 #define UTF8PROC_BIDI_CLASS_PDF 8 |
jbe@2 | 210 #define UTF8PROC_BIDI_CLASS_EN 9 |
jbe@2 | 211 #define UTF8PROC_BIDI_CLASS_ES 10 |
jbe@2 | 212 #define UTF8PROC_BIDI_CLASS_ET 11 |
jbe@2 | 213 #define UTF8PROC_BIDI_CLASS_AN 12 |
jbe@2 | 214 #define UTF8PROC_BIDI_CLASS_CS 13 |
jbe@2 | 215 #define UTF8PROC_BIDI_CLASS_NSM 14 |
jbe@2 | 216 #define UTF8PROC_BIDI_CLASS_BN 15 |
jbe@2 | 217 #define UTF8PROC_BIDI_CLASS_B 16 |
jbe@2 | 218 #define UTF8PROC_BIDI_CLASS_S 17 |
jbe@2 | 219 #define UTF8PROC_BIDI_CLASS_WS 18 |
jbe@2 | 220 #define UTF8PROC_BIDI_CLASS_ON 19 |
jbe@2 | 221 #define UTF8PROC_DECOMP_TYPE_FONT 1 |
jbe@2 | 222 #define UTF8PROC_DECOMP_TYPE_NOBREAK 2 |
jbe@2 | 223 #define UTF8PROC_DECOMP_TYPE_INITIAL 3 |
jbe@2 | 224 #define UTF8PROC_DECOMP_TYPE_MEDIAL 4 |
jbe@2 | 225 #define UTF8PROC_DECOMP_TYPE_FINAL 5 |
jbe@2 | 226 #define UTF8PROC_DECOMP_TYPE_ISOLATED 6 |
jbe@2 | 227 #define UTF8PROC_DECOMP_TYPE_CIRCLE 7 |
jbe@2 | 228 #define UTF8PROC_DECOMP_TYPE_SUPER 8 |
jbe@2 | 229 #define UTF8PROC_DECOMP_TYPE_SUB 9 |
jbe@2 | 230 #define UTF8PROC_DECOMP_TYPE_VERTICAL 10 |
jbe@2 | 231 #define UTF8PROC_DECOMP_TYPE_WIDE 11 |
jbe@2 | 232 #define UTF8PROC_DECOMP_TYPE_NARROW 12 |
jbe@2 | 233 #define UTF8PROC_DECOMP_TYPE_SMALL 13 |
jbe@2 | 234 #define UTF8PROC_DECOMP_TYPE_SQUARE 14 |
jbe@2 | 235 #define UTF8PROC_DECOMP_TYPE_FRACTION 15 |
jbe@2 | 236 #define UTF8PROC_DECOMP_TYPE_COMPAT 16 |
jbe@2 | 237 |
jbe@0 | 238 extern const int8_t utf8proc_utf8class[256]; |
jbe@0 | 239 |
jbe@9 | 240 const char *utf8proc_version(void); |
jbe@9 | 241 |
jbe@0 | 242 const char *utf8proc_errmsg(ssize_t errcode); |
jbe@0 | 243 /* |
jbe@0 | 244 * Returns a static error string for the given error code. |
jbe@0 | 245 */ |
jbe@0 | 246 |
jbe@7 | 247 ssize_t utf8proc_iterate(const uint8_t *str, ssize_t strlen, int32_t *dst); |
jbe@0 | 248 /* |
jbe@0 | 249 * Reads a single char from the UTF-8 sequence being pointed to by 'str'. |
jbe@0 | 250 * The maximum number of bytes read is 'strlen', unless 'strlen' is |
jbe@0 | 251 * negative. |
jbe@0 | 252 * If a valid unicode char could be read, it is stored in the variable |
jbe@0 | 253 * being pointed to by 'dst', otherwise that variable will be set to -1. |
jbe@0 | 254 * In case of success the number of bytes read is returned, otherwise a |
jbe@0 | 255 * negative error code is returned. |
jbe@0 | 256 */ |
jbe@0 | 257 |
jbe@7 | 258 bool utf8proc_codepoint_valid(int32_t uc); |
jbe@7 | 259 /* |
jbe@7 | 260 * Returns 1, if the given unicode code-point is valid, otherwise 0. |
jbe@7 | 261 */ |
jbe@7 | 262 |
jbe@0 | 263 ssize_t utf8proc_encode_char(int32_t uc, uint8_t *dst); |
jbe@0 | 264 /* |
jbe@0 | 265 * Encodes the unicode char with the code point 'uc' as an UTF-8 string in |
jbe@0 | 266 * the byte array being pointed to by 'dst'. This array has to be at least |
jbe@0 | 267 * 4 bytes long. |
jbe@7 | 268 * In case of success the number of bytes written is returned, |
jbe@7 | 269 * otherwise 0. |
jbe@0 | 270 * This function does not check if 'uc' is a valid unicode code point. |
jbe@0 | 271 */ |
jbe@0 | 272 |
jbe@0 | 273 const utf8proc_property_t *utf8proc_get_property(int32_t uc); |
jbe@0 | 274 /* |
jbe@0 | 275 * Returns a pointer to a (constant) struct containing information about |
jbe@0 | 276 * the unicode char with the given code point 'uc'. |
jbe@0 | 277 * If the character is not existent a pointer to a special struct is |
jbe@0 | 278 * returned, where 'category' is a NULL pointer. |
jbe@0 | 279 * WARNING: The parameter 'uc' has to be in the range of 0x0000 to |
jbe@0 | 280 * 0x10FFFF, otherwise the program might crash! |
jbe@0 | 281 */ |
jbe@0 | 282 |
jbe@7 | 283 ssize_t utf8proc_decompose_char( |
jbe@7 | 284 int32_t uc, int32_t *dst, ssize_t bufsize, |
jbe@7 | 285 int options, int *last_boundclass |
jbe@7 | 286 ); |
jbe@0 | 287 /* |
jbe@0 | 288 * Writes a decomposition of the unicode char 'uc' into the array being |
jbe@0 | 289 * pointed to by 'dst'. |
jbe@0 | 290 * Following flags in the 'options' field are regarded: |
jbe@2 | 291 * REJECTNA: an unassigned unicode code point leads to an error |
jbe@2 | 292 * IGNORE: "default ignorable" chars are stripped |
jbe@2 | 293 * CASEFOLD: unicode casefolding is applied |
jbe@2 | 294 * COMPAT: replace certain characters with their |
jbe@2 | 295 * compatibility decomposition |
jbe@2 | 296 * CHARBOUND: Inserts 0xFF bytes before each grapheme cluster |
jbe@3 | 297 * LUMP: lumps certain different characters together |
jbe@3 | 298 * STRIPMARK: removes all character marks |
jbe@7 | 299 * The pointer 'last_boundclass' has to point to an integer variable which |
jbe@7 | 300 * is storing the last character boundary class, if the CHARBOUND option |
jbe@7 | 301 * is used. |
jbe@0 | 302 * In case of success the number of chars written is returned, |
jbe@0 | 303 * in case of an error, a negative error code is returned. |
jbe@0 | 304 * If the number of written chars would be bigger than 'bufsize', |
jbe@0 | 305 * the buffer (up to 'bufsize') has inpredictable data, and the needed |
jbe@0 | 306 * buffer size is returned. |
jbe@0 | 307 * WARNING: The parameter 'uc' has to be in the range of 0x0000 to |
jbe@0 | 308 * 0x10FFFF, otherwise the program might crash! |
jbe@0 | 309 */ |
jbe@0 | 310 |
jbe@7 | 311 ssize_t utf8proc_decompose( |
jbe@7 | 312 const uint8_t *str, ssize_t strlen, |
jbe@7 | 313 int32_t *buffer, ssize_t bufsize, int options |
jbe@7 | 314 ); |
jbe@0 | 315 /* |
jbe@0 | 316 * Does the same as 'utf8proc_decompose_char', but acts on a whole UTF-8 |
jbe@0 | 317 * string, and orders the decomposed sequences correctly. |
jbe@0 | 318 * If the NULLTERM flag in 'options' is set, processing will be stopped, |
jbe@0 | 319 * when a NULL byte is encounted, otherwise 'strlen' bytes are processed. |
jbe@0 | 320 * The result in form of unicode code points is written into the buffer |
jbe@0 | 321 * being pointed to by 'buffer', having the length of 'bufsize' entries. |
jbe@0 | 322 * In case of success the number of chars written is returned, |
jbe@0 | 323 * in case of an error, a negative error code is returned. |
jbe@0 | 324 * If the number of written chars would be bigger than 'bufsize', |
jbe@0 | 325 * the buffer (up to 'bufsize') has inpredictable data, and the needed |
jbe@0 | 326 * buffer size is returned. |
jbe@0 | 327 */ |
jbe@0 | 328 |
jbe@0 | 329 ssize_t utf8proc_reencode(int32_t *buffer, ssize_t length, int options); |
jbe@0 | 330 /* |
jbe@0 | 331 * Reencodes the sequence of unicode characters given by the pointer |
jbe@0 | 332 * 'buffer' and 'length' as UTF-8. |
jbe@0 | 333 * The result is stored in the same memory area where the data is read. |
jbe@0 | 334 * Following flags in the 'options' field are regarded: |
jbe@0 | 335 * NLF2LS: converts LF, CRLF, CR and NEL into LS |
jbe@0 | 336 * NLF2PS: converts LF, CRLF, CR and NEL into PS |
jbe@0 | 337 * NLF2LF: converts LF, CRLF, CR and NEL into LF |
jbe@0 | 338 * STRIPCC: strips or converts all non-affected control characters |
jbe@7 | 339 * COMPOSE: tries to combine decomposed characters into composite |
jbe@7 | 340 * characters |
jbe@0 | 341 * STABLE: prohibits combining characters which would violate |
jbe@0 | 342 * the unicode versioning stability |
jbe@7 | 343 * In case of success the length of the resulting UTF-8 string is |
jbe@7 | 344 * returned, otherwise a negative error code is returned. |
jbe@0 | 345 * WARNING: The amount of free space being pointed to by 'buffer', has to |
jbe@0 | 346 * exceed the amount of the input data by one byte, and the |
jbe@0 | 347 * entries of the array pointed to by 'str' have to be in the |
jbe@7 | 348 * range of 0x0000 to 0x10FFFF, otherwise the program might |
jbe@7 | 349 * crash! |
jbe@0 | 350 */ |
jbe@0 | 351 |
jbe@7 | 352 ssize_t utf8proc_map( |
jbe@7 | 353 const uint8_t *str, ssize_t strlen, uint8_t **dstptr, int options |
jbe@7 | 354 ); |
jbe@0 | 355 /* |
jbe@0 | 356 * Maps the given UTF-8 string being pointed to by 'str' to a new UTF-8 |
jbe@7 | 357 * string, which is allocated dynamically, and afterwards pointed to by |
jbe@7 | 358 * the pointer being pointed to by 'dstptr'. |
jbe@0 | 359 * If the NULLTERM flag in the 'options' field is set, the length is |
jbe@0 | 360 * determined by a NULL terminator, otherwise the parameter 'strlen' is |
jbe@0 | 361 * evaluated to determine the string length, but in any case the result |
jbe@7 | 362 * will be NULL terminated (though it might contain NULL characters |
jbe@7 | 363 * before). Other flags in the 'options' field are passed to the functions |
jbe@7 | 364 * defined above, and regarded as described. |
jbe@0 | 365 * In case of success the length of the new string is returned, |
jbe@0 | 366 * otherwise a negative error code is returned. |
jbe@0 | 367 * NOTICE: The memory of the new UTF-8 string will have been allocated with |
jbe@0 | 368 * 'malloc', and has theirfore to be freed with 'free'. |
jbe@0 | 369 */ |
jbe@0 | 370 |
jbe@7 | 371 uint8_t *utf8proc_NFD(const uint8_t *str); |
jbe@7 | 372 uint8_t *utf8proc_NFC(const uint8_t *str); |
jbe@7 | 373 uint8_t *utf8proc_NFKD(const uint8_t *str); |
jbe@7 | 374 uint8_t *utf8proc_NFKC(const uint8_t *str); |
jbe@0 | 375 /* |
jbe@0 | 376 * Returns a pointer to newly allocated memory of a NFD, NFC, NFKD or NFKC |
jbe@0 | 377 * normalized version of the null-terminated string 'str'. |
jbe@0 | 378 */ |
jbe@0 | 379 |
Jan@12 | 380 #ifdef __cplusplus |
Jan@12 | 381 } |
Jan@12 | 382 #endif |
jbe@0 | 383 |
jbe@0 | 384 #endif |
jbe@0 | 385 |