wchar.cpp revision 1b836ee6f8e5c0f61d67c1f014819a066366ab6f
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#include <ctype.h> 30#include <errno.h> 31#include <limits.h> 32#include <stdlib.h> 33#include <string.h> 34#include <wchar.h> 35 36/* stubs for wide-char functions */ 37 38wint_t btowc(int c) { 39 return (c == EOF) ? WEOF : c; 40} 41 42int fwprintf(FILE* stream, const wchar_t* format, ...) { 43 va_list args; 44 va_start(args, format); 45 int result = vfwprintf(stream, format, args); 46 va_end(args); 47 return result; 48} 49 50int wprintf(const wchar_t* format, ...) { 51 va_list args; 52 va_start(args, format); 53 int result = vwprintf(format, args); 54 va_end(args); 55 return result; 56} 57 58int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...) { 59 va_list args; 60 va_start(args, format); 61 int result = vswprintf(s, n, format, args); 62 va_end(args); 63 return result; 64} 65 66int vwprintf(const wchar_t* format, va_list arg) { 67 return vfwprintf(stdout, format, arg); 68} 69 70int vfwprintf(FILE* /*stream*/, const wchar_t* /*format*/, va_list /*arg*/) { 71 errno = ENOTSUP; 72 return -1; 73} 74 75int vswprintf(wchar_t* /*s*/, size_t /*n*/, const wchar_t* /*format*/, va_list /*arg*/) { 76 errno = ENOTSUP; 77 return -1; 78} 79 80int fwscanf(FILE* /*stream*/, const wchar_t* /*format*/, ... ) { 81 errno = ENOTSUP; 82 return -1; 83} 84 85int wscanf(const wchar_t* format, ... ) { 86 va_list args; 87 va_start (args, format); 88 int result = fwscanf(stdout, format, args ); 89 va_end (args); 90 return result; 91} 92 93int swscanf(const wchar_t* /*s*/, const wchar_t* /*format*/, ... ) { 94 errno = ENOTSUP; 95 return -1; 96} 97 98int iswalnum(wint_t wc) { return isalnum(wc); } 99int iswalpha(wint_t wc) { return isalpha(wc); } 100int iswblank(wint_t wc) { return isblank(wc); } 101int iswcntrl(wint_t wc) { return iscntrl(wc); } 102int iswdigit(wint_t wc) { return isdigit(wc); } 103int iswgraph(wint_t wc) { return isgraph(wc); } 104int iswlower(wint_t wc) { return islower(wc); } 105int iswprint(wint_t wc) { return isprint(wc); } 106int iswpunct(wint_t wc) { return ispunct(wc); } 107int iswspace(wint_t wc) { return isspace(wc); } 108int iswupper(wint_t wc) { return isupper(wc); } 109int iswxdigit(wint_t wc) { return isxdigit(wc); } 110 111int iswctype(wint_t wc, wctype_t char_class) { 112 switch (char_class) { 113 case WC_TYPE_ALNUM: return isalnum(wc); 114 case WC_TYPE_ALPHA: return isalpha(wc); 115 case WC_TYPE_BLANK: return isblank(wc); 116 case WC_TYPE_CNTRL: return iscntrl(wc); 117 case WC_TYPE_DIGIT: return isdigit(wc); 118 case WC_TYPE_GRAPH: return isgraph(wc); 119 case WC_TYPE_LOWER: return islower(wc); 120 case WC_TYPE_PRINT: return isprint(wc); 121 case WC_TYPE_PUNCT: return ispunct(wc); 122 case WC_TYPE_SPACE: return isspace(wc); 123 case WC_TYPE_UPPER: return isupper(wc); 124 case WC_TYPE_XDIGIT: return isxdigit(wc); 125 default: return 0; 126 } 127} 128 129wint_t fgetwc(FILE* stream) { 130 return static_cast<wint_t>(fgetc(stream)); 131} 132 133wchar_t* fgetws(wchar_t* ws, int n, FILE* stream) { 134 return reinterpret_cast<wchar_t*>(fgets(reinterpret_cast<char*>(ws), n, stream)); 135} 136 137wint_t fputwc(wchar_t wc, FILE* stream) { 138 return static_cast<wint_t>(fputc(static_cast<char>(wc), stream)); 139} 140 141int fputws(const wchar_t* str, FILE* stream) { 142 return fputs(reinterpret_cast<const char*>(str), stream ); 143} 144 145int fwide(FILE* /*stream*/, int mode) { 146 return mode; 147} 148 149wint_t getwc(FILE* stream) { 150 return getc(stream); 151} 152 153wint_t getwchar() { 154 return getchar(); 155} 156 157int mbsinit(const mbstate_t* /*ps*/) { 158 return 1; 159} 160 161size_t mbrlen(const char* s, size_t n, mbstate_t* /*ps*/) { 162 return (n == 0 || s[0] == 0) ? 0 : 1; 163} 164 165size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* /*ps*/) { 166 if (s == NULL) { 167 s = ""; 168 pwc = NULL; 169 } 170 if (n == 0) { 171 if (pwc) { 172 *pwc = 0; 173 return 0; 174 } 175 } 176 if (pwc) { 177 *pwc = *s; 178 } 179 return (*s != 0); 180} 181 182size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* /*ps*/) { 183 const char* s = *src; 184 const char* s2 = reinterpret_cast<const char*>(memchr(s, 0, len)); 185 186 if (s2 != NULL) { 187 len = (size_t)(s2 - s) + 1U; 188 } 189 190 if (dst) { 191 memcpy(reinterpret_cast<char*>(dst), s, len ); 192 } 193 194 *src = s + len; 195 return len; 196} 197 198size_t mbstowcs(wchar_t* dst, const char* src, size_t len) { 199 return mbsrtowcs(dst, &src, len, NULL); 200} 201 202wint_t putwc(wchar_t wc, FILE* stream) { 203 return fputc(static_cast<char>(wc), stream); 204} 205 206wint_t putwchar(wchar_t wc) { 207 return putchar(static_cast<char>(wc)); 208} 209 210wint_t towlower(wint_t wc) { 211 return tolower(wc); 212} 213 214wint_t towupper(wint_t wc) { 215 return toupper(wc); 216} 217 218wint_t ungetwc(wint_t wc, FILE* stream) { 219 return ungetc(static_cast<char>(wc), stream); 220} 221 222int wctomb(char* s, wchar_t wc) { 223 if (s == NULL) { 224 return 0; 225 } 226 if (wc <= 0xff) { 227 *s = static_cast<char>(wc); 228 } else { 229 *s = '?'; 230 } 231 return 1; 232} 233 234size_t wcrtomb(char* s, wchar_t wc, mbstate_t* /*ps*/) { 235 if (s == NULL) { 236 char buf[MB_LEN_MAX]; 237 return wctomb(buf, L'\0'); 238 } 239 return wctomb(s, wc); 240} 241 242size_t wcsftime(wchar_t* wcs, size_t maxsize, const wchar_t* format, const struct tm* timptr) { 243 return strftime(reinterpret_cast<char*>(wcs), maxsize, reinterpret_cast<const char*>(format), timptr); 244} 245 246size_t wcsrtombs(char* dst, const wchar_t** src, size_t n, mbstate_t* /*ps*/) { 247 size_t i = 0; // Number of input characters read. 248 size_t o = 0; // Number of output bytes written. 249 for (; (*src)[i] != 0; ++i) { 250 // TODO: UTF-8 support. 251 if ((*src)[i] > 0x7f) { 252 errno = EILSEQ; 253 if (dst != NULL) { 254 *src = &(*src)[i]; 255 } 256 return static_cast<size_t>(-1); 257 } 258 if (dst != NULL) { 259 if (o + 1 > n) { 260 break; 261 } 262 dst[o++] = static_cast<char>((*src)[i]); 263 } else { 264 ++o; 265 } 266 } 267 // If we consumed all the input, terminate the output. 268 if (dst != NULL && o < n) { 269 dst[o] = 0; 270 } 271 // If we were actually consuming input, record how far we got. 272 if (dst != NULL) { 273 if ((*src)[i] != 0) { 274 *src = &(*src)[i]; // This is where the next call should pick up. 275 } else { 276 *src = NULL; // We consumed everything. 277 } 278 } 279 return o; 280} 281 282size_t wcstombs(char* dst, const wchar_t* src, size_t len) { 283 const wchar_t* p = src; 284 return wcsrtombs(dst, &p, len, NULL); 285} 286 287double wcstod(const wchar_t* nptr, wchar_t** endptr) { 288 return strtod(reinterpret_cast<const char*>(nptr), reinterpret_cast<char**>(endptr)); 289} 290 291long int wcstol(const wchar_t* nptr, wchar_t** endptr, int base) { 292 return strtol(reinterpret_cast<const char*>(nptr), reinterpret_cast<char**>(endptr), base); 293} 294 295unsigned long int wcstoul(const wchar_t* nptr, wchar_t** endptr, int base) { 296 return strtoul(reinterpret_cast<const char*>(nptr), reinterpret_cast<char**>(endptr), base); 297} 298 299wchar_t* wcswcs(const wchar_t* ws1, const wchar_t* ws2) { 300 const char* s1 = reinterpret_cast<const char*>(ws1); 301 const char* s2 = reinterpret_cast<const char*>(ws2); 302 return reinterpret_cast<wchar_t*>(strstr(s1, s2)); 303} 304 305int wctob(wint_t c) { 306 return c; 307} 308 309wctype_t wctype(const char* property) { 310 static const char* const properties[WC_TYPE_MAX] = { 311 "<invalid>", 312 "alnum", "alpha", "blank", "cntrl", "digit", "graph", 313 "lower", "print", "punct", "space", "upper", "xdigit" 314 }; 315 for (size_t i = 0; i < WC_TYPE_MAX; ++i) { 316 if (!strcmp(properties[i], property)) { 317 return static_cast<wctype_t>(i); 318 } 319 } 320 return static_cast<wctype_t>(0); 321} 322 323int wcwidth(wchar_t wc) { 324 return (wc > 0); 325} 326