Gecko [ unitednationsplay.com ]

Name	Size	Permission	Date
doc	[ DIR ]	drwxr-xr-x	2021-02-04 21:24
tools	[ DIR ]	drwxr-xr-x	2021-02-04 21:24
CHANGELOG.md	19.83 KB	-rw-r--r--	2018-09-29 08:04
LICENSE.md	1.19 KB	-rw-r--r--	2018-02-22 17:07
README.md	27.94 KB	-rw-r--r--	2018-09-29 08:04
include_dirs.js	55 B	-rw-r--r--	2017-04-05 22:07
nan-2.11.1.tgz	72.81 KB	-rw-r--r--	2018-09-29 08:09
nan.h	83.32 KB	-rw-r--r--	2018-09-29 08:05
nan_callbacks.h	3.02 KB	-rw-r--r--	2018-02-22 17:07
nan_callbacks_12_inl.h	17.13 KB	-rw-r--r--	2018-08-25 12:11
nan_callbacks_pre_12_inl.h	16.68 KB	-rw-r--r--	2018-02-22 17:07
nan_converters.h	2.06 KB	-rw-r--r--	2018-02-22 17:07
nan_converters_43_inl.h	1.69 KB	-rw-r--r--	2018-03-16 15:57
nan_converters_pre_43_inl.h	1.22 KB	-rw-r--r--	2018-02-22 17:07
nan_define_own_property_helper.h	1 KB	-rw-r--r--	2018-03-16 15:57
nan_implementation_12_inl.h	13.95 KB	-rw-r--r--	2018-09-29 08:02
nan_implementation_pre_12_inl.h	7.76 KB	-rw-r--r--	2018-02-22 17:07
nan_json.h	5.64 KB	-rw-r--r--	2018-02-22 17:07
nan_maybe_43_inl.h	12.29 KB	-rw-r--r--	2018-03-16 15:57
nan_maybe_pre_43_inl.h	8.04 KB	-rw-r--r--	2018-03-16 15:57
nan_new.h	8.58 KB	-rw-r--r--	2018-02-22 17:07
nan_object_wrap.h	4 KB	-rw-r--r--	2018-02-22 17:07
nan_persistent_12_inl.h	3.78 KB	-rw-r--r--	2018-02-22 17:07
nan_persistent_pre_12_inl.h	6.01 KB	-rw-r--r--	2018-02-22 17:07
nan_private.h	2.42 KB	-rw-r--r--	2018-02-22 17:07
nan_string_bytes.h	7.91 KB	-rw-r--r--	2017-04-05 22:07
nan_typedarray_contents.h	2.8 KB	-rw-r--r--	2018-02-22 17:07
nan_weak.h	14.65 KB	-rw-r--r--	2018-02-22 17:07
package.json	2.56 KB	-rw-r--r--	2021-02-04 21:24

Rename

// 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_