Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/glacials/splits-io. a speedrunning data store and analysis engine splits.io
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306// 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_