| /* ----------------------------------------------------------------------- * |
| * |
| * Copyright 1996-2009 The NASM Authors - All Rights Reserved |
| * See the file AUTHORS included with the NASM distribution for |
| * the specific copyright holders. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following |
| * conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * ----------------------------------------------------------------------- */ |
| |
| /* |
| * strfunc.c |
| * |
| * String transformation functions |
| */ |
| |
| #include "nasmlib.h" |
| #include "nasm.h" |
| |
| /* |
| * Convert a string in UTF-8 format to UTF-16LE |
| */ |
| static size_t utf8_to_16le(uint8_t *str, size_t len, char *op) |
| { |
| #define EMIT(x) do { if (op) { WRITESHORT(op,x); } outlen++; } while(0) |
| |
| size_t outlen = 0; |
| int expect = 0; |
| uint8_t c; |
| uint32_t v = 0, vmin = 0; |
| |
| while (len--) { |
| c = *str++; |
| |
| if (expect) { |
| if ((c & 0xc0) != 0x80) { |
| expect = 0; |
| return -1; |
| } else { |
| v = (v << 6) | (c & 0x3f); |
| if (!--expect) { |
| if (v < vmin || v > 0x10ffff || |
| (v >= 0xd800 && v <= 0xdfff)) { |
| return -1; |
| } else if (v > 0xffff) { |
| v -= 0x10000; |
| EMIT(0xd800 | (v >> 10)); |
| EMIT(0xdc00 | (v & 0x3ff)); |
| } else { |
| EMIT(v); |
| } |
| } |
| continue; |
| } |
| } |
| |
| if (c < 0x80) { |
| EMIT(c); |
| } else if (c < 0xc0 || c >= 0xfe) { |
| /* Invalid UTF-8 */ |
| return -1; |
| } else if (c < 0xe0) { |
| v = c & 0x1f; |
| expect = 1; |
| vmin = 0x80; |
| } else if (c < 0xf0) { |
| v = c & 0x0f; |
| expect = 2; |
| vmin = 0x800; |
| } else if (c < 0xf8) { |
| v = c & 0x07; |
| expect = 3; |
| vmin = 0x10000; |
| } else if (c < 0xfc) { |
| v = c & 0x03; |
| expect = 4; |
| vmin = 0x200000; |
| } else { |
| v = c & 0x01; |
| expect = 5; |
| vmin = 0x4000000; |
| } |
| } |
| |
| return expect ? (size_t)-1 : outlen << 1; |
| |
| #undef EMIT |
| } |
| |
| /* |
| * Convert a string in UTF-8 format to UTF-16BE |
| */ |
| static size_t utf8_to_16be(uint8_t *str, size_t len, char *op) |
| { |
| #define EMIT(x) \ |
| do { \ |
| uint16_t _y = (x); \ |
| if (op) { \ |
| WRITECHAR(op, _y >> 8); \ |
| WRITECHAR(op, _y); \ |
| } \ |
| outlen++; \ |
| } while (0) \ |
| |
| size_t outlen = 0; |
| int expect = 0; |
| uint8_t c; |
| uint32_t v = 0, vmin = 0; |
| |
| while (len--) { |
| c = *str++; |
| |
| if (expect) { |
| if ((c & 0xc0) != 0x80) { |
| expect = 0; |
| return -1; |
| } else { |
| v = (v << 6) | (c & 0x3f); |
| if (!--expect) { |
| if (v < vmin || v > 0x10ffff || |
| (v >= 0xd800 && v <= 0xdfff)) { |
| return -1; |
| } else if (v > 0xffff) { |
| v -= 0x10000; |
| EMIT(0xdc00 | (v & 0x3ff)); |
| EMIT(0xd800 | (v >> 10)); |
| } else { |
| EMIT(v); |
| } |
| } |
| continue; |
| } |
| } |
| |
| if (c < 0x80) { |
| EMIT(c); |
| } else if (c < 0xc0 || c >= 0xfe) { |
| /* Invalid UTF-8 */ |
| return -1; |
| } else if (c < 0xe0) { |
| v = c & 0x1f; |
| expect = 1; |
| vmin = 0x80; |
| } else if (c < 0xf0) { |
| v = c & 0x0f; |
| expect = 2; |
| vmin = 0x800; |
| } else if (c < 0xf8) { |
| v = c & 0x07; |
| expect = 3; |
| vmin = 0x10000; |
| } else if (c < 0xfc) { |
| v = c & 0x03; |
| expect = 4; |
| vmin = 0x200000; |
| } else { |
| v = c & 0x01; |
| expect = 5; |
| vmin = 0x4000000; |
| } |
| } |
| |
| return expect ? (size_t)-1 : outlen << 1; |
| |
| #undef EMIT |
| } |
| |
| /* |
| * Convert a string in UTF-8 format to UTF-32LE |
| */ |
| static size_t utf8_to_32le(uint8_t *str, size_t len, char *op) |
| { |
| #define EMIT(x) do { if (op) { WRITELONG(op,x); } outlen++; } while(0) |
| |
| size_t outlen = 0; |
| int expect = 0; |
| uint8_t c; |
| uint32_t v = 0, vmin = 0; |
| |
| while (len--) { |
| c = *str++; |
| |
| if (expect) { |
| if ((c & 0xc0) != 0x80) { |
| return -1; |
| } else { |
| v = (v << 6) | (c & 0x3f); |
| if (!--expect) { |
| if (v < vmin || (v >= 0xd800 && v <= 0xdfff)) { |
| return -1; |
| } else { |
| EMIT(v); |
| } |
| } |
| continue; |
| } |
| } |
| |
| if (c < 0x80) { |
| EMIT(c); |
| } else if (c < 0xc0 || c >= 0xfe) { |
| /* Invalid UTF-8 */ |
| return -1; |
| } else if (c < 0xe0) { |
| v = c & 0x1f; |
| expect = 1; |
| vmin = 0x80; |
| } else if (c < 0xf0) { |
| v = c & 0x0f; |
| expect = 2; |
| vmin = 0x800; |
| } else if (c < 0xf8) { |
| v = c & 0x07; |
| expect = 3; |
| vmin = 0x10000; |
| } else if (c < 0xfc) { |
| v = c & 0x03; |
| expect = 4; |
| vmin = 0x200000; |
| } else { |
| v = c & 0x01; |
| expect = 5; |
| vmin = 0x4000000; |
| } |
| } |
| |
| return expect ? (size_t)-1 : outlen << 2; |
| |
| #undef EMIT |
| } |
| |
| /* |
| * Convert a string in UTF-8 format to UTF-32BE |
| */ |
| static size_t utf8_to_32be(uint8_t *str, size_t len, char *op) |
| { |
| #define EMIT(x) \ |
| do { \ |
| uint32_t _y = (x); \ |
| if (op) { \ |
| WRITECHAR(op,_y >> 24); \ |
| WRITECHAR(op,_y >> 16); \ |
| WRITECHAR(op,_y >> 8); \ |
| WRITECHAR(op,_y); \ |
| } \ |
| outlen++; \ |
| } while (0) |
| |
| size_t outlen = 0; |
| int expect = 0; |
| uint8_t c; |
| uint32_t v = 0, vmin = 0; |
| |
| while (len--) { |
| c = *str++; |
| |
| if (expect) { |
| if ((c & 0xc0) != 0x80) { |
| return -1; |
| } else { |
| v = (v << 6) | (c & 0x3f); |
| if (!--expect) { |
| if (v < vmin || (v >= 0xd800 && v <= 0xdfff)) { |
| return -1; |
| } else { |
| EMIT(v); |
| } |
| } |
| continue; |
| } |
| } |
| |
| if (c < 0x80) { |
| EMIT(c); |
| } else if (c < 0xc0 || c >= 0xfe) { |
| /* Invalid UTF-8 */ |
| return -1; |
| } else if (c < 0xe0) { |
| v = c & 0x1f; |
| expect = 1; |
| vmin = 0x80; |
| } else if (c < 0xf0) { |
| v = c & 0x0f; |
| expect = 2; |
| vmin = 0x800; |
| } else if (c < 0xf8) { |
| v = c & 0x07; |
| expect = 3; |
| vmin = 0x10000; |
| } else if (c < 0xfc) { |
| v = c & 0x03; |
| expect = 4; |
| vmin = 0x200000; |
| } else { |
| v = c & 0x01; |
| expect = 5; |
| vmin = 0x4000000; |
| } |
| } |
| |
| return expect ? (size_t)-1 : outlen << 2; |
| |
| #undef EMIT |
| } |
| |
| typedef size_t (*transform_func)(uint8_t *, size_t, char *); |
| |
| /* |
| * Apply a specific string transform and return it in a nasm_malloc'd |
| * buffer, returning the length. On error, returns (size_t)-1 and no |
| * buffer is allocated. |
| */ |
| size_t string_transform(char *str, size_t len, char **out, enum strfunc func) |
| { |
| /* This should match enum strfunc in nasm.h */ |
| static const transform_func str_transforms[] = { |
| utf8_to_16le, |
| utf8_to_16le, |
| utf8_to_16be, |
| utf8_to_32le, |
| utf8_to_32le, |
| utf8_to_32be, |
| }; |
| transform_func transform = str_transforms[func]; |
| size_t outlen; |
| uint8_t *s = (uint8_t *)str; |
| char *buf; |
| |
| outlen = transform(s, len, NULL); |
| if (outlen == (size_t)-1) |
| return -1; |
| |
| *out = buf = nasm_malloc(outlen+1); |
| buf[outlen] = '\0'; /* Forcibly null-terminate the buffer */ |
| return transform(s, len, buf); |
| } |
