| // Copyright Joyent, Inc. and other Node contributors. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a |
| // copy of this software and associated documentation files (the |
| // "Software"), to deal in the Software without restriction, including |
| // without limitation the rights to use, copy, modify, merge, publish, |
| // distribute, sublicense, and/or sell copies of the Software, and to permit |
| // persons to whom the Software is furnished to do so, subject to the |
| // following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included |
| // in all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
| // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
| // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| // USE OR OTHER DEALINGS IN THE SOFTWARE. |
| |
| #ifndef NAN_STRING_BYTES_H_ |
| #define NAN_STRING_BYTES_H_ |
| |
| // Decodes a v8::Local<v8::String> or Buffer to a raw char* |
| |
| namespace imp { |
| |
| using v8::Local; |
| using v8::Object; |
| using v8::String; |
| using v8::Value; |
| |
| |
| //// Base 64 //// |
| |
| #define base64_encoded_size(size) ((size + 2 - ((size + 2) % 3)) / 3 * 4) |
| |
| |
| |
| //// HEX //// |
| |
| static bool contains_non_ascii_slow(const char* buf, size_t len) { |
| for (size_t i = 0; i < len; ++i) { |
| if (buf[i] & 0x80) return true; |
| } |
| return false; |
| } |
| |
| |
| static bool contains_non_ascii(const char* src, size_t len) { |
| if (len < 16) { |
| return contains_non_ascii_slow(src, len); |
| } |
| |
| const unsigned bytes_per_word = sizeof(void*); |
| const unsigned align_mask = bytes_per_word - 1; |
| const unsigned unaligned = reinterpret_cast<uintptr_t>(src) & align_mask; |
| |
| if (unaligned > 0) { |
| const unsigned n = bytes_per_word - unaligned; |
| if (contains_non_ascii_slow(src, n)) return true; |
| src += n; |
| len -= n; |
| } |
| |
| |
| #if defined(__x86_64__) || defined(_WIN64) |
| const uintptr_t mask = 0x8080808080808080ll; |
| #else |
| const uintptr_t mask = 0x80808080l; |
| #endif |
| |
| const uintptr_t* srcw = reinterpret_cast<const uintptr_t*>(src); |
| |
| for (size_t i = 0, n = len / bytes_per_word; i < n; ++i) { |
| if (srcw[i] & mask) return true; |
| } |
| |
| const unsigned remainder = len & align_mask; |
| if (remainder > 0) { |
| const size_t offset = len - remainder; |
| if (contains_non_ascii_slow(src + offset, remainder)) return true; |
| } |
| |
| return false; |
| } |
| |
| |
| static void force_ascii_slow(const char* src, char* dst, size_t len) { |
| for (size_t i = 0; i < len; ++i) { |
| dst[i] = src[i] & 0x7f; |
| } |
| } |
| |
| |
| static void force_ascii(const char* src, char* dst, size_t len) { |
| if (len < 16) { |
| force_ascii_slow(src, dst, len); |
| return; |
| } |
| |
| const unsigned bytes_per_word = sizeof(void*); |
| const unsigned align_mask = bytes_per_word - 1; |
| const unsigned src_unalign = reinterpret_cast<uintptr_t>(src) & align_mask; |
| const unsigned dst_unalign = reinterpret_cast<uintptr_t>(dst) & align_mask; |
| |
| if (src_unalign > 0) { |
| if (src_unalign == dst_unalign) { |
| const unsigned unalign = bytes_per_word - src_unalign; |
| force_ascii_slow(src, dst, unalign); |
| src += unalign; |
| dst += unalign; |
| len -= src_unalign; |
| } else { |
| force_ascii_slow(src, dst, len); |
| return; |
| } |
| } |
| |
| #if defined(__x86_64__) || defined(_WIN64) |
| const uintptr_t mask = ~0x8080808080808080ll; |
| #else |
| const uintptr_t mask = ~0x80808080l; |
| #endif |
| |
| const uintptr_t* srcw = reinterpret_cast<const uintptr_t*>(src); |
| uintptr_t* dstw = reinterpret_cast<uintptr_t*>(dst); |
| |
| for (size_t i = 0, n = len / bytes_per_word; i < n; ++i) { |
| dstw[i] = srcw[i] & mask; |
| } |
| |
| const unsigned remainder = len & align_mask; |
| if (remainder > 0) { |
| const size_t offset = len - remainder; |
| force_ascii_slow(src + offset, dst + offset, remainder); |
| } |
| } |
| |
| |
| static size_t base64_encode(const char* src, |
| size_t slen, |
| char* dst, |
| size_t dlen) { |
| // We know how much we'll write, just make sure that there's space. |
| assert(dlen >= base64_encoded_size(slen) && |
| "not enough space provided for base64 encode"); |
| |
| dlen = base64_encoded_size(slen); |
| |
| unsigned a; |
| unsigned b; |
| unsigned c; |
| unsigned i; |
| unsigned k; |
| unsigned n; |
| |
| static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| "abcdefghijklmnopqrstuvwxyz" |
| "0123456789+/"; |
| |
| i = 0; |
| k = 0; |
| n = slen / 3 * 3; |
| |
| while (i < n) { |
| a = src[i + 0] & 0xff; |
| b = src[i + 1] & 0xff; |
| c = src[i + 2] & 0xff; |
| |
| dst[k + 0] = table[a >> 2]; |
| dst[k + 1] = table[((a & 3) << 4) | (b >> 4)]; |
| dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)]; |
| dst[k + 3] = table[c & 0x3f]; |
| |
| i += 3; |
| k += 4; |
| } |
| |
| if (n != slen) { |
| switch (slen - n) { |
| case 1: |
| a = src[i + 0] & 0xff; |
| dst[k + 0] = table[a >> 2]; |
| dst[k + 1] = table[(a & 3) << 4]; |
| dst[k + 2] = '='; |
| dst[k + 3] = '='; |
| break; |
| |
| case 2: |
| a = src[i + 0] & 0xff; |
| b = src[i + 1] & 0xff; |
| dst[k + 0] = table[a >> 2]; |
| dst[k + 1] = table[((a & 3) << 4) | (b >> 4)]; |
| dst[k + 2] = table[(b & 0x0f) << 2]; |
| dst[k + 3] = '='; |
| break; |
| } |
| } |
| |
| return dlen; |
| } |
| |
| |
| static size_t hex_encode(const char* src, size_t slen, char* dst, size_t dlen) { |
| // We know how much we'll write, just make sure that there's space. |
| assert(dlen >= slen * 2 && |
| "not enough space provided for hex encode"); |
| |
| dlen = slen * 2; |
| for (uint32_t i = 0, k = 0; k < dlen; i += 1, k += 2) { |
| static const char hex[] = "0123456789abcdef"; |
| uint8_t val = static_cast<uint8_t>(src[i]); |
| dst[k + 0] = hex[val >> 4]; |
| dst[k + 1] = hex[val & 15]; |
| } |
| |
| return dlen; |
| } |
| |
| |
| |
| static Local<Value> Encode(const char* buf, |
| size_t buflen, |
| enum Encoding encoding) { |
| assert(buflen <= node::Buffer::kMaxLength); |
| if (!buflen && encoding != BUFFER) |
| return New("").ToLocalChecked(); |
| |
| Local<String> val; |
| switch (encoding) { |
| case BUFFER: |
| return CopyBuffer(buf, buflen).ToLocalChecked(); |
| |
| case ASCII: |
| if (contains_non_ascii(buf, buflen)) { |
| char* out = new char[buflen]; |
| force_ascii(buf, out, buflen); |
| val = New<String>(out, buflen).ToLocalChecked(); |
| delete[] out; |
| } else { |
| val = New<String>(buf, buflen).ToLocalChecked(); |
| } |
| break; |
| |
| case UTF8: |
| val = New<String>(buf, buflen).ToLocalChecked(); |
| break; |
| |
| case BINARY: { |
| // TODO(isaacs) use ExternalTwoByteString? |
| const unsigned char *cbuf = reinterpret_cast<const unsigned char*>(buf); |
| uint16_t * twobytebuf = new uint16_t[buflen]; |
| for (size_t i = 0; i < buflen; i++) { |
| // XXX is the following line platform independent? |
| twobytebuf[i] = cbuf[i]; |
| } |
| val = New<String>(twobytebuf, buflen).ToLocalChecked(); |
| delete[] twobytebuf; |
| break; |
| } |
| |
| case BASE64: { |
| size_t dlen = base64_encoded_size(buflen); |
| char* dst = new char[dlen]; |
| |
| size_t written = base64_encode(buf, buflen, dst, dlen); |
| assert(written == dlen); |
| |
| val = New<String>(dst, dlen).ToLocalChecked(); |
| delete[] dst; |
| break; |
| } |
| |
| case UCS2: { |
| const uint16_t* data = reinterpret_cast<const uint16_t*>(buf); |
| val = New<String>(data, buflen / 2).ToLocalChecked(); |
| break; |
| } |
| |
| case HEX: { |
| size_t dlen = buflen * 2; |
| char* dst = new char[dlen]; |
| size_t written = hex_encode(buf, buflen, dst, dlen); |
| assert(written == dlen); |
| |
| val = New<String>(dst, dlen).ToLocalChecked(); |
| delete[] dst; |
| break; |
| } |
| |
| default: |
| assert(0 && "unknown encoding"); |
| break; |
| } |
| |
| return val; |
| } |
| |
| #undef base64_encoded_size |
| |
| } // end of namespace imp |
| |
| #endif // NAN_STRING_BYTES_H_ |