fix: support null characters on NSString marshalling

Author: edusperoni

NativeScript/runtime/ArgConverter.mm

@@ -163,7 +163,7 @@
             void* errorParam = argValues[errorParamIndex];
             NSError*__strong** outPtr = static_cast<NSError*__strong**>(errorParam);
             if (outPtr && *outPtr) {
-                NSError* error = [NSError errorWithDomain:@"TNSErrorDomain" code:164 userInfo:@{ @"TNSJavaScriptError": [NSString stringWithUTF8String:message.c_str()] }];
+                NSError* error = [NSError errorWithDomain:@"TNSErrorDomain" code:164 userInfo:@{ @"TNSJavaScriptError": tns::ToNSString(message) }];
                 **static_cast<NSError*__strong**>(outPtr) = error;
             }
         }
@@ -248,8 +248,7 @@
     } else if (value->IsString()) {
         if (type == BinaryTypeEncodingType::IdEncoding ||
             type == BinaryTypeEncodingType::InterfaceDeclarationReference) {
-            std::string strValue = tns::ToString(isolate, value);
-            id data = [[NSString alloc] initWithBytes:strValue.c_str() length:strValue.length() encoding:NSUTF8StringEncoding];
+            id data = tns::ToNSString(isolate, value);
             *(CFTypeRef*)retValue = CFBridgingRetain(data);
             return;
         }

NativeScript/runtime/DictionaryAdapter.mm

@@ -46,8 +46,7 @@ - (id)nextObject {
         bool success = array->Get(context, self->index_).ToLocal(&key);
         tns::Assert(success, isolate);
         self->index_ += 2;
-        std::string keyStr = tns::ToString(self->isolate_, key);
-        NSString* result = [NSString stringWithUTF8String:keyStr.c_str()];
+        NSString* result = tns::ToNSString(self->isolate_, key);
         return result;
     }
 

NativeScript/runtime/Helpers.h

@@ -15,9 +15,38 @@ extern "C" void NSLog(CFStringRef format, ...);
 
 namespace tns {
 
-inline v8::Local<v8::String> ToV8String(v8::Isolate* isolate, std::string value) {
+inline v8::Local<v8::String> ToV8String(v8::Isolate* isolate,const std::string& value) {
     return v8::String::NewFromUtf8(isolate, value.c_str(), v8::NewStringType::kNormal, (int)value.length()).ToLocalChecked();
 }
+#ifdef __OBJC__
+inline v8::Local<v8::String> ToV8String(v8::Isolate* isolate,const NSString* value) {
+    /*
+     // TODO: profile if this is faster
+     // maybe have multiple conversion
+     if([value fastestEncoding] == NSUTF16StringEncoding) {
+        uint16_t static_buffer[256];
+        uint16_t* targetBuffer = static_buffer;
+        bool isDynamic = false;
+        auto length = [value maximumLengthOfBytesUsingEncoding:NSUTF16StringEncoding];
+        auto numberOfBytes = length * sizeof(uint16_t);
+        if (length > 256) {
+            targetBuffer = (uint16_t*)malloc(numberOfBytes);
+            isDynamic = true;
+        }
+        NSUInteger usedLength = 0;
+        NSRange range = NSMakeRange(0, [value length]);
+        [value getBytes:targetBuffer maxLength:numberOfBytes usedLength:&usedLength encoding:NSUTF16StringEncoding options:0 range:range remainingRange:NULL];
+        
+        auto result = v8::String::NewFromTwoByte(isolate, targetBuffer, v8::NewStringType::kNormal, (int)[value length]).ToLocalChecked();
+        if (isDynamic) {
+            free(targetBuffer);
+        }
+        return result;
+    }
+     */
+    return v8::String::NewFromUtf8(isolate, [value UTF8String], v8::NewStringType::kNormal, (int)[value lengthOfBytesUsingEncoding:NSUTF8StringEncoding]).ToLocalChecked();
+}
+#endif
 inline std::string ToString(v8::Isolate* isolate, const v8::Local<v8::Value>& value) {
     if (value.IsEmpty()) {
         return std::string();
@@ -35,8 +64,34 @@ inline std::string ToString(v8::Isolate* isolate, const v8::Local<v8::Value>& va
         return std::string();
     }
 
-    return std::string(*result);
+    return std::string(*result, result.length());
 }
+
+#ifdef __OBJC__
+inline NSString* ToNSString(const std::string& v) {
+    return [[NSString alloc] initWithBytes:v.c_str() length:v.length() encoding:NSUTF8StringEncoding];
+}
+// this method is a copy of ToString to avoid needless std::string<->NSString conversions
+inline NSString* ToNSString(v8::Isolate* isolate, const v8::Local<v8::Value>& value) {
+    if (value.IsEmpty()) {
+        return @"";
+    }
+
+    if (value->IsStringObject()) {
+        v8::Local<v8::String> obj = value.As<v8::StringObject>()->ValueOf();
+        return ToNSString(isolate, obj);
+    }
+
+    v8::String::Utf8Value result(isolate, value);
+
+    const char* val = *result;
+    if (val == nullptr) {
+        return @"";
+    }
+
+    return [[NSString alloc] initWithBytes:*result length:result.length() encoding:NSUTF8StringEncoding];
+}
+#endif
 std::u16string ToUtf16String(v8::Isolate* isolate, const v8::Local<v8::Value>& value);
 inline double ToNumber(v8::Isolate* isolate, const v8::Local<v8::Value>& value) {
     double result = NAN;

NativeScript/runtime/Interop.mm

@@ -265,8 +265,7 @@ inline bool isBool() {
         unichar c = (vector.size() == 0) ? 0 : vector[0];
         Interop::SetValue(dest, c);
     } else if (argHelper.isString() && (typeEncoding->type == BinaryTypeEncodingType::InterfaceDeclarationReference || typeEncoding->type == BinaryTypeEncodingType::IdEncoding)) {
-        std::string str = tns::ToString(isolate, arg);
-        NSString* result = [NSString stringWithUTF8String:str.c_str()];
+        NSString* result = tns::ToNSString(isolate, arg);
         Interop::SetValue(dest, result);
     } else if (Interop::IsNumbericType(typeEncoding->type) || tns::IsNumber(arg)) {
         double value = tns::ToNumber(isolate, arg);
@@ -603,8 +602,7 @@ inline bool isBool() {
     if (arg.IsEmpty() || arg->IsNullOrUndefined()) {
         return nil;
     } else if (tns::IsString(arg)) {
-        std::string value = tns::ToString(isolate, arg);
-        NSString* result = [NSString stringWithUTF8String:value.c_str()];
+        NSString* result = tns::ToNSString(isolate, arg);
         return result;
     } else if (tns::IsNumber(arg)) {
         double value = tns::ToNumber(isolate, arg);
@@ -1092,8 +1090,7 @@ inline bool isBool() {
 
             if (marshalToPrimitive) {
                 // Convert NSString instances to javascript strings for all instance method calls
-                const char* str = [result UTF8String];
-                return tns::ToV8String(isolate, str);
+                return tns::ToV8String(isolate, result);
             }
         }