1 // -*- C++ -*- 2 //===----------------------- support/win32/support.h ----------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #include <cstdarg> // va_start, va_end 12 #include <cstddef> // size_t 13 #include <cstdlib> // malloc 14 #include <cstdio> // vsprintf, vsnprintf 15 #include <cstring> // strcpy, wcsncpy 16 #include <cwchar> // mbstate_t 17 18 19 // Like sprintf, but when return value >= 0 it returns 20 // a pointer to a malloc'd string in *sptr. 21 // If return >= 0, use free to delete *sptr. 22 int __libcpp_vasprintf( char **sptr, const char *__restrict format, va_list ap ) 23 { 24 *sptr = NULL; 25 // Query the count required. 26 int count = _vsnprintf( NULL, 0, format, ap ); 27 if (count < 0) 28 return count; 29 size_t buffer_size = static_cast<size_t>(count) + 1; 30 char* p = static_cast<char*>(malloc(buffer_size)); 31 if ( ! p ) 32 return -1; 33 // If we haven't used exactly what was required, something is wrong. 34 // Maybe bug in vsnprintf. Report the error and return. 35 if (_vsnprintf(p, buffer_size, format, ap) != count) { 36 free(p); 37 return -1; 38 } 39 // All good. This is returning memory to the caller not freeing it. 40 *sptr = p; 41 return count; 42 } 43 44 // Returns >= 0: the number of wide characters found in the 45 // multi byte sequence src (of src_size_bytes), that fit in the buffer dst 46 // (of max_dest_chars elements size). The count returned excludes the 47 // null terminator. When dst is NULL, no characters are copied 48 // and no "out" parameters are updated. 49 // Returns (size_t) -1: an incomplete sequence encountered. 50 // Leaves *src pointing the next character to convert or NULL 51 // if a null character was converted from *src. 52 size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src, 53 size_t src_size_bytes, size_t max_dest_chars, mbstate_t *__restrict ps ) 54 { 55 const size_t terminated_sequence = static_cast<size_t>(0); 56 //const size_t invalid_sequence = static_cast<size_t>(-1); 57 const size_t incomplete_sequence = static_cast< size_t>(-2); 58 59 size_t dest_converted = 0; 60 size_t source_converted = 0; 61 size_t source_remaining = src_size_bytes; 62 size_t result = 0; 63 bool have_result = false; 64 65 while ( source_remaining ) { 66 if ( dst && dest_converted >= max_dest_chars ) 67 break; 68 // Converts one multi byte character. 69 // if result > 0, it's the size in bytes of that character. 70 // othewise if result is zero it indicates the null character has been found. 71 // otherwise it's an error and errno may be set. 72 size_t char_size = mbrtowc( dst ? dst + dest_converted : NULL, *src + source_converted, source_remaining, ps ); 73 // Don't do anything to change errno from here on. 74 if ( char_size > 0 ) { 75 source_remaining -= char_size; 76 source_converted += char_size; 77 ++dest_converted; 78 continue; 79 } 80 result = char_size; 81 have_result = true; 82 break; 83 } 84 if ( dst ) { 85 if ( have_result && result == terminated_sequence ) 86 *src = NULL; 87 else 88 *src += source_converted; 89 } 90 if ( have_result && result != terminated_sequence && result != incomplete_sequence ) 91 return static_cast<size_t>(-1); 92 93 return dest_converted; 94 } 95 96 // Converts max_source_chars from the wide character buffer pointer to by *src, 97 // into the multi byte character sequence buffer stored at dst which must be 98 // dst_size_bytes bytes in size. 99 // Returns >= 0: the number of bytes in the sequence 100 // converted from *src, excluding the null terminator. 101 // Returns size_t(-1) if an error occurs, also sets errno. 102 // If dst is NULL dst_size_bytes is ignored and no bytes are copied to dst 103 // and no "out" parameters are updated. 104 size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src, 105 size_t max_source_chars, size_t dst_size_bytes, mbstate_t *__restrict ps ) 106 { 107 //const size_t invalid_sequence = static_cast<size_t>(-1); 108 109 size_t source_converted = 0; 110 size_t dest_converted = 0; 111 size_t dest_remaining = dst_size_bytes; 112 size_t char_size = 0; 113 const errno_t no_error = ( errno_t) 0; 114 errno_t result = ( errno_t ) 0; 115 bool have_result = false; 116 bool terminator_found = false; 117 118 while ( source_converted != max_source_chars ) { 119 if ( ! dest_remaining ) 120 break; 121 wchar_t c = (*src)[source_converted]; 122 if ( dst ) 123 result = wcrtomb_s( &char_size, dst + dest_converted, dest_remaining, c, ps); 124 else 125 result = wcrtomb_s( &char_size, NULL, 0, c, ps); 126 // If result is zero there is no error and char_size contains the 127 // size of the multi-byte-sequence converted. 128 // Otherwise result indicates an errno type error. 129 if ( result == no_error ) { 130 if ( c == L'\0' ) { 131 terminator_found = true; 132 break; 133 } 134 ++source_converted; 135 if ( dst ) 136 dest_remaining -= char_size; 137 dest_converted += char_size; 138 continue; 139 } 140 have_result = true; 141 break; 142 } 143 if ( dst ) { 144 if ( terminator_found ) 145 *src = NULL; 146 else 147 *src = *src + source_converted; 148 } 149 if ( have_result && result != no_error ) { 150 errno = result; 151 return static_cast<size_t>(-1); 152 } 153 154 return dest_converted; 155 } 156
