@encharm/cws 4.3.0 → 4.4.0

package/src/headers/20/string_bytes.h

@@ -0,0 +1,120 @@
+// 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 SRC_STRING_BYTES_H_
+#define SRC_STRING_BYTES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+// Decodes a v8::Local<v8::String> or Buffer to a raw char*
+
+#include "v8.h"
+#include "env-inl.h"
+
+#include <string>
+
+namespace node {
+
+class StringBytes {
+ public:
+  class InlineDecoder : public MaybeStackBuffer<char> {
+   public:
+    inline v8::Maybe<bool> Decode(Environment* env,
+                                  v8::Local<v8::String> string,
+                                  enum encoding enc) {
+      size_t storage;
+      if (!StringBytes::StorageSize(env->isolate(), string, enc).To(&storage))
+        return v8::Nothing<bool>();
+      AllocateSufficientStorage(storage);
+      const size_t length =
+          StringBytes::Write(env->isolate(), out(), storage, string, enc);
+
+      // No zero terminator is included when using this method.
+      SetLength(length);
+      return v8::Just(true);
+    }
+
+    inline size_t size() const { return length(); }
+  };
+
+  // Fast, but can be 2 bytes oversized for Base64, and
+  // as much as triple UTF-8 strings <= 65536 chars in length
+  static v8::Maybe<size_t> StorageSize(v8::Isolate* isolate,
+                                       v8::Local<v8::Value> val,
+                                       enum encoding enc);
+
+  // Precise byte count, but slightly slower for Base64 and
+  // very much slower for UTF-8
+  static v8::Maybe<size_t> Size(v8::Isolate* isolate,
+                                v8::Local<v8::Value> val,
+                                enum encoding enc);
+
+  // Write the bytes from the string or buffer into the char*
+  // returns the number of bytes written, which will always be
+  // <= buflen.  Use StorageSize/Size first to know how much
+  // memory to allocate.
+  static size_t Write(v8::Isolate* isolate,
+                      char* buf,
+                      size_t buflen,
+                      v8::Local<v8::Value> val,
+                      enum encoding enc);
+
+  // Take the bytes in the src, and turn it into a Buffer or String.
+  static v8::MaybeLocal<v8::Value> Encode(v8::Isolate* isolate,
+                                          const char* buf,
+                                          size_t buflen,
+                                          enum encoding encoding,
+                                          v8::Local<v8::Value>* error);
+
+  // Warning: This reverses endianness on BE platforms, even though the
+  // signature using uint16_t implies that it should not.
+  // However, the brokenness is already public API and can't therefore
+  // be changed easily.
+  static v8::MaybeLocal<v8::Value> Encode(v8::Isolate* isolate,
+                                          const uint16_t* buf,
+                                          size_t buflen,
+                                          v8::Local<v8::Value>* error);
+
+  static v8::MaybeLocal<v8::Value> Encode(v8::Isolate* isolate,
+                                          const char* buf,
+                                          enum encoding encoding,
+                                          v8::Local<v8::Value>* error);
+
+  static size_t hex_encode(const char* src,
+                           size_t slen,
+                           char* dst,
+                           size_t dlen);
+
+  static std::string hex_encode(const char* src, size_t slen);
+
+ private:
+  static size_t WriteUCS2(v8::Isolate* isolate,
+                          char* buf,
+                          size_t buflen,
+                          v8::Local<v8::String> str,
+                          int flags);
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_STRING_BYTES_H_

package/src/headers/20/string_decoder-inl.h

@@ -0,0 +1,37 @@
+#ifndef SRC_STRING_DECODER_INL_H_
+#define SRC_STRING_DECODER_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "string_decoder.h"
+
+namespace node {
+
+void StringDecoder::SetEncoding(enum encoding encoding) {
+  state_[kBufferedBytes] = 0;
+  state_[kMissingBytes] = 0;
+  state_[kEncodingField] = encoding;
+}
+
+enum encoding StringDecoder::Encoding() const {
+  return static_cast<enum encoding>(state_[kEncodingField]);
+}
+
+unsigned StringDecoder::BufferedBytes() const {
+  return state_[kBufferedBytes];
+}
+
+unsigned StringDecoder::MissingBytes() const {
+  return state_[kMissingBytes];
+}
+
+char* StringDecoder::IncompleteCharacterBuffer() {
+  return reinterpret_cast<char*>(state_ + kIncompleteCharactersStart);
+}
+
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif   // SRC_STRING_DECODER_INL_H_

package/src/headers/20/string_decoder.h

@@ -0,0 +1,50 @@
+#ifndef SRC_STRING_DECODER_H_
+#define SRC_STRING_DECODER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+
+namespace node {
+
+class StringDecoder {
+ public:
+  StringDecoder() { state_[kEncodingField] = BUFFER; }
+  inline void SetEncoding(enum encoding encoding);
+  inline enum encoding Encoding() const;
+
+  inline char* IncompleteCharacterBuffer();
+  inline unsigned MissingBytes() const;
+  inline unsigned BufferedBytes() const;
+
+  // Decode a string from the specified encoding.
+  // The value pointed to by `nread` will be modified to reflect that
+  // less data may have been read because it ended on an incomplete character
+  // and more data may have been read because a previously incomplete character
+  // was finished.
+  v8::MaybeLocal<v8::String> DecodeData(v8::Isolate* isolate,
+                                        const char* data,
+                                        size_t* nread);
+  // Flush an incomplete character. For character encodings like UTF8 this
+  // means printing replacement characters, buf for e.g. Base64 the returned
+  // string contains more data.
+  v8::MaybeLocal<v8::String> FlushData(v8::Isolate* isolate);
+
+  enum Fields {
+    kIncompleteCharactersStart = 0,
+    kIncompleteCharactersEnd = 4,
+    kMissingBytes = 4,
+    kBufferedBytes = 5,
+    kEncodingField = 6,
+    kNumFields = 7
+  };
+
+ private:
+  uint8_t state_[kNumFields] = {};
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif   // SRC_STRING_DECODER_H_