◐ Shell
clean mode source ↗

src: add node_encoding.cc · nodejs/node@8e2e167

@@ -765,129 +765,6 @@ Local<Value> MakeCallback(Isolate* isolate,

765765

.FromMaybe(Local<Value>()));

766766

}

767767768-769-

enum encoding ParseEncoding(const char* encoding,

770-

enum encoding default_encoding) {

771-

switch (encoding[0]) {

772-

case 'u':

773-

// utf8, utf16le

774-

if (encoding[1] == 't' && encoding[2] == 'f') {

775-

// Skip `-`

776-

encoding += encoding[3] == '-' ? 4 : 3;

777-

if (encoding[0] == '8' && encoding[1] == '\0')

778-

return UTF8;

779-

if (strncmp(encoding, "16le", 4) == 0)

780-

return UCS2;

781-782-

// ucs2

783-

} else if (encoding[1] == 'c' && encoding[2] == 's') {

784-

encoding += encoding[3] == '-' ? 4 : 3;

785-

if (encoding[0] == '2' && encoding[1] == '\0')

786-

return UCS2;

787-

}

788-

break;

789-

case 'l':

790-

// latin1

791-

if (encoding[1] == 'a') {

792-

if (strncmp(encoding + 2, "tin1", 4) == 0)

793-

return LATIN1;

794-

}

795-

break;

796-

case 'b':

797-

// binary

798-

if (encoding[1] == 'i') {

799-

if (strncmp(encoding + 2, "nary", 4) == 0)

800-

return LATIN1;

801-802-

// buffer

803-

} else if (encoding[1] == 'u') {

804-

if (strncmp(encoding + 2, "ffer", 4) == 0)

805-

return BUFFER;

806-

}

807-

break;

808-

case '\0':

809-

return default_encoding;

810-

default:

811-

break;

812-

}

813-814-

if (StringEqualNoCase(encoding, "utf8")) {

815-

return UTF8;

816-

} else if (StringEqualNoCase(encoding, "utf-8")) {

817-

return UTF8;

818-

} else if (StringEqualNoCase(encoding, "ascii")) {

819-

return ASCII;

820-

} else if (StringEqualNoCase(encoding, "base64")) {

821-

return BASE64;

822-

} else if (StringEqualNoCase(encoding, "ucs2")) {

823-

return UCS2;

824-

} else if (StringEqualNoCase(encoding, "ucs-2")) {

825-

return UCS2;

826-

} else if (StringEqualNoCase(encoding, "utf16le")) {

827-

return UCS2;

828-

} else if (StringEqualNoCase(encoding, "utf-16le")) {

829-

return UCS2;

830-

} else if (StringEqualNoCase(encoding, "latin1")) {

831-

return LATIN1;

832-

} else if (StringEqualNoCase(encoding, "binary")) {

833-

return LATIN1; // BINARY is a deprecated alias of LATIN1.

834-

} else if (StringEqualNoCase(encoding, "buffer")) {

835-

return BUFFER;

836-

} else if (StringEqualNoCase(encoding, "hex")) {

837-

return HEX;

838-

} else {

839-

return default_encoding;

840-

}

841-

}

842-843-844-

enum encoding ParseEncoding(Isolate* isolate,

845-

Local<Value> encoding_v,

846-

enum encoding default_encoding) {

847-

CHECK(!encoding_v.IsEmpty());

848-849-

if (!encoding_v->IsString())

850-

return default_encoding;

851-852-

node::Utf8Value encoding(isolate, encoding_v);

853-854-

return ParseEncoding(*encoding, default_encoding);

855-

}

856-857-

Local<Value> Encode(Isolate* isolate,

858-

const char* buf,

859-

size_t len,

860-

enum encoding encoding) {

861-

CHECK_NE(encoding, UCS2);

862-

Local<Value> error;

863-

return StringBytes::Encode(isolate, buf, len, encoding, &error)

864-

.ToLocalChecked();

865-

}

866-867-

Local<Value> Encode(Isolate* isolate, const uint16_t* buf, size_t len) {

868-

Local<Value> error;

869-

return StringBytes::Encode(isolate, buf, len, &error)

870-

.ToLocalChecked();

871-

}

872-873-

// Returns -1 if the handle was not valid for decoding

874-

ssize_t DecodeBytes(Isolate* isolate,

875-

Local<Value> val,

876-

enum encoding encoding) {

877-

HandleScope scope(isolate);

878-879-

return StringBytes::Size(isolate, val, encoding);

880-

}

881-882-

// Returns number of bytes written.

883-

ssize_t DecodeWrite(Isolate* isolate,

884-

char* buf,

885-

size_t buflen,

886-

Local<Value> val,

887-

enum encoding encoding) {

888-

return StringBytes::Write(isolate, buf, buflen, val, encoding, nullptr);

889-

}

890-891768

bool IsExceptionDecorated(Environment* env, Local<Value> er) {

892769

if (!er.IsEmpty() && er->IsObject()) {

893770

Local<Object> err_obj = er.As<Object>();