Fix a number of int type issues in dart:io File implementation to avoid implicit conversions that c…

runtime/bin/file.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/file.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/io_buffer.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 #include "include/dart_api.h"
 
 static const int kMSPerSecond = 1000;
 
 dart::Mutex File::mutex_;
 int File::service_ports_size_ = 0;
 Dart_Port* File::service_ports_ = NULL;
 int File::service_ports_index_ = 0;
 
+
+// The file pointer has been passed into Dart as an intptr_t and it is safe
+// to pull it out of Dart as a 64-bit integer, cast it to an intptr_t and
+// from there to a File pointer.
+static File* GetFilePointer(Dart_Handle handle) {
+  intptr_t value = DartUtils::GetIntptrValue(handle);
+  return reinterpret_cast<File*>(value);
+}
+
+
 bool File::ReadFully(void* buffer, int64_t num_bytes) {
   int64_t remaining = num_bytes;
   char* current_buffer = reinterpret_cast<char*>(buffer);
   while (remaining > 0) {
     int bytes_read = Read(current_buffer, remaining);
     if (bytes_read <= 0) {
       return false;
     }
     remaining -= bytes_read;  // Reduce the number of remaining bytes.
     current_buffer += bytes_read;  // Move the buffer forward.
@@ skipping 28 matching lines @@
     return File::kWrite;
   }
   return File::kRead;
 }
 
 
 void FUNCTION_NAME(File_Open)(Dart_NativeArguments args) {
   Dart_EnterScope();
   const char* filename =
       DartUtils::GetStringValue(Dart_GetNativeArgument(args, 0));
-  int mode = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 1));
+  int64_t mode = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 1));
   File::DartFileOpenMode dart_file_mode =
       static_cast<File::DartFileOpenMode>(mode);
   File::FileOpenMode file_mode = File::DartModeToFileMode(dart_file_mode);
   // Check that the file exists before opening it only for
   // reading. This is to prevent the opening of directories as
   // files. Directories can be opened for reading using the posix
   // 'open' call.
   File* file = NULL;
   file = File::Open(filename, file_mode);
   if (file != NULL) {
@@ skipping 13 matching lines @@
   const char* filename =
       DartUtils::GetStringValue(Dart_GetNativeArgument(args, 0));
   bool exists = File::Exists(filename);
   Dart_SetReturnValue(args, Dart_NewBoolean(exists));
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_Close)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   delete file;
   Dart_SetReturnValue(args, Dart_NewInteger(0));
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_ReadByte)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   uint8_t buffer;
-  int bytes_read = file->Read(reinterpret_cast<void*>(&buffer), 1);
+  int64_t bytes_read = file->Read(reinterpret_cast<void*>(&buffer), 1);
   if (bytes_read == 1) {
     Dart_SetReturnValue(args, Dart_NewInteger(buffer));
   } else if (bytes_read == 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(-1));
   } else {
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_WriteByte)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t file_ptr =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(file_ptr);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
-  int64_t value = 0;
-  if (DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 1), &value)) {
-    uint8_t buffer = static_cast<uint8_t>(value & 0xff);
-    int bytes_written = file->Write(reinterpret_cast<void*>(&buffer), 1);
+  int64_t byte = 0;
+  if (DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 1), &byte)) {
+    uint8_t buffer = static_cast<uint8_t>(byte & 0xff);
+    int64_t bytes_written = file->Write(reinterpret_cast<void*>(&buffer), 1);
     if (bytes_written >= 0) {
       Dart_SetReturnValue(args, Dart_NewInteger(bytes_written));
     } else {
       Dart_Handle err = DartUtils::NewDartOSError();
       if (Dart_IsError(err)) Dart_PropagateError(err);
       Dart_SetReturnValue(args, err);
     }
   } else {
     OSError os_error(-1, "Invalid argument", OSError::kUnknown);
     Dart_Handle err = DartUtils::NewDartOSError(&os_error);
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_Read)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   Dart_Handle length_object = Dart_GetNativeArgument(args, 1);
   int64_t length = 0;
   if (DartUtils::GetInt64Value(length_object, &length)) {
     uint8_t* buffer = NULL;
     Dart_Handle external_array = IOBuffer::Allocate(length, &buffer);
-    int bytes_read = file->Read(reinterpret_cast<void*>(buffer), length);
+    int64_t bytes_read = file->Read(reinterpret_cast<void*>(buffer), length);
     if (bytes_read < 0) {
       Dart_Handle err = DartUtils::NewDartOSError();
       if (Dart_IsError(err)) Dart_PropagateError(err);
       Dart_SetReturnValue(args, err);
     } else {
       if (bytes_read < length) {
         // TODO(ager): cache the 'length' string if this becomes a bottle neck.
         Dart_SetField(external_array,
                       DartUtils::NewString("length"),
                       Dart_NewInteger(bytes_read));
       }
       Dart_SetReturnValue(args, external_array);
     }
   } else {
     OSError os_error(-1, "Invalid argument", OSError::kUnknown);
     Dart_Handle err = DartUtils::NewDartOSError(&os_error);
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_ReadList)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   ASSERT(Dart_IsList(buffer_obj));
   // Offset and length arguments are checked in Dart code to be
   // integers and have the property that (offset + length) <=
   // list.length. Therefore, it is safe to extract their value as
-  // 64-bit integers.
-  int64_t offset =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 2));
-  int64_t length =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 3));
+  // intptr_t.
+  intptr_t offset =
+      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
+  intptr_t length =
+      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
   intptr_t array_len = 0;
   Dart_Handle result = Dart_ListLength(buffer_obj, &array_len);
   if (Dart_IsError(result)) Dart_PropagateError(result);
   ASSERT((offset + length) <= array_len);
   uint8_t* buffer = new uint8_t[length];
-  int bytes_read = file->Read(reinterpret_cast<void*>(buffer), length);
+  int64_t bytes_read = file->Read(reinterpret_cast<void*>(buffer), length);
   if (bytes_read >= 0) {
     result = Dart_ListSetAsBytes(buffer_obj, offset, buffer, bytes_read);
     if (Dart_IsError(result)) {
       delete[] buffer;
       Dart_PropagateError(result);
     }
     Dart_SetReturnValue(args, Dart_NewInteger(bytes_read));
   } else {
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   delete[] buffer;
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_WriteList)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   ASSERT(Dart_IsList(buffer_obj));
   // Offset and length arguments are checked in Dart code to be
   // integers and have the property that (offset + length) <=
   // list.length. Therefore, it is safe to extract their value as
-  // 64-bit integers.
-  int64_t offset =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 2));
-  int64_t length =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 3));
+  // intptr_t.
+  intptr_t offset =
+      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
+  intptr_t length =
+      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
   intptr_t buffer_len = 0;
   Dart_Handle result = Dart_ListLength(buffer_obj, &buffer_len);
   if (Dart_IsError(result)) Dart_PropagateError(result);
   ASSERT((offset + length) <= buffer_len);
   uint8_t* buffer = new uint8_t[length];
   result = Dart_ListGetAsBytes(buffer_obj, offset, buffer, length);
   if (Dart_IsError(result)) {
     delete[] buffer;
     Dart_PropagateError(result);
   }
-  int bytes_written = file->Write(reinterpret_cast<void*>(buffer), length);
+  int64_t bytes_written = file->Write(reinterpret_cast<void*>(buffer), length);
   if (bytes_written >= 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(bytes_written));
   } else {
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   delete[] buffer;
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_Position)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   intptr_t return_value = file->Position();
   if (return_value >= 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(return_value));
   } else {
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_SetPosition)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   int64_t position = 0;
   if (DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 1), &position)) {
     if (file->SetPosition(position)) {
       Dart_SetReturnValue(args, Dart_True());
     } else {
       Dart_Handle err = DartUtils::NewDartOSError();
       if (Dart_IsError(err)) Dart_PropagateError(err);
       Dart_SetReturnValue(args, err);
     }
   } else {
     OSError os_error(-1, "Invalid argument", OSError::kUnknown);
     Dart_Handle err = DartUtils::NewDartOSError(&os_error);
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_Truncate)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   int64_t length = 0;
   if (DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 1), &length)) {
     if (file->Truncate(length)) {
       Dart_SetReturnValue(args, Dart_True());
     } else {
       Dart_Handle err = DartUtils::NewDartOSError();
       if (Dart_IsError(err)) Dart_PropagateError(err);
       Dart_SetReturnValue(args, err);
     }
   } else {
     OSError os_error(-1, "Invalid argument", OSError::kUnknown);
     Dart_Handle err = DartUtils::NewDartOSError(&os_error);
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_Length)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   intptr_t return_value = file->Length();
   if (return_value >= 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(return_value));
   } else {
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
@@ skipping 27 matching lines @@
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_Flush)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  intptr_t value =
-      DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = reinterpret_cast<File*>(value);
+  File* file = GetFilePointer(Dart_GetNativeArgument(args, 0));
   ASSERT(file != NULL);
   if (file->Flush()) {
     Dart_SetReturnValue(args, Dart_True());
   } else {
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
@@ skipping 62 matching lines @@
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_OpenStdio)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  int fd = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File* file = File::OpenStdio(fd);
+  int64_t fd = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
+  ASSERT(fd == 0 || fd == 1 || fd == 2);
+  File* file = File::OpenStdio(static_cast<int>(fd));
   Dart_SetReturnValue(args, Dart_NewInteger(reinterpret_cast<intptr_t>(file)));
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(File_GetStdioHandleType)(Dart_NativeArguments args) {
   Dart_EnterScope();
-  int fd = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
-  File::StdioHandleType type = File::GetStdioHandleType(fd);
+  int64_t fd = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 0));
+  ASSERT(fd == 0 || fd == 1 || fd == 2);
+  File::StdioHandleType type = File::GetStdioHandleType(static_cast<int>(fd));
   Dart_SetReturnValue(args, Dart_NewInteger(type));
   Dart_ExitScope();
 }
 
 
 static int64_t CObjectInt32OrInt64ToInt64(CObject* cobject) {
   ASSERT(cobject->IsInt32OrInt64());
   int64_t result;
   if (cobject->IsInt32()) {
     CObjectInt32 value(cobject);
@@ skipping 242 matching lines @@
   return CObject::IllegalArgumentError();
 }
 
 
 static CObject* FileReadByteRequest(const CObjectArray& request) {
   if (request.Length() == 2 && request[1]->IsIntptr()) {
     File* file = CObjectToFilePointer(request[1]);
     ASSERT(file != NULL);
     if (!file->IsClosed()) {
       uint8_t buffer;
-      int bytes_read = file->Read(reinterpret_cast<void*>(&buffer), 1);
+      int64_t bytes_read = file->Read(reinterpret_cast<void*>(&buffer), 1);
       if (bytes_read > 0) {
         return new CObjectIntptr(CObject::NewIntptr(buffer));
       } else if (bytes_read == 0) {
         return new CObjectIntptr(CObject::NewIntptr(-1));
       } else {
         return CObject::NewOSError();
       }
     } else {
       return CObject::FileClosedError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 
 static CObject* FileWriteByteRequest(const CObjectArray& request) {
   if (request.Length() == 3 &&
       request[1]->IsIntptr() &&
       request[2]->IsInt32OrInt64()) {
     File* file = CObjectToFilePointer(request[1]);
     ASSERT(file != NULL);
     if (!file->IsClosed()) {
       int64_t byte = CObjectInt32OrInt64ToInt64(request[2]);
       uint8_t buffer = static_cast<uint8_t>(byte & 0xff);
-      int bytes_written = file->Write(reinterpret_cast<void*>(&buffer), 1);
+      int64_t bytes_written = file->Write(reinterpret_cast<void*>(&buffer), 1);
       if (bytes_written > 0) {
-        return new CObjectIntptr(CObject::NewIntptr(bytes_written));
+        return new CObjectInt64(CObject::NewInt64(bytes_written));
       } else {
         return CObject::NewOSError();
       }
     } else {
       return CObject::FileClosedError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 
 static void FinalizeExternalByteArray(void* peer) {
   delete[] reinterpret_cast<uint8_t*>(peer);
 }
 
 
 static CObject* FileReadRequest(const CObjectArray& request) {
   if (request.Length() == 3 &&
       request[1]->IsIntptr() &&
       request[2]->IsInt32OrInt64()) {
     File* file = CObjectToFilePointer(request[1]);
     ASSERT(file != NULL);
     if (!file->IsClosed()) {
       int64_t length = CObjectInt32OrInt64ToInt64(request[2]);
       uint8_t* buffer = new uint8_t[length];
-      int bytes_read = file->Read(buffer, length);
+      int64_t bytes_read = file->Read(buffer, length);
       if (bytes_read >= 0) {
         void* peer = reinterpret_cast<void*>(buffer);
         CObject* external_array =
             new CObjectExternalUint8Array(
                 CObject::NewExternalUint8Array(bytes_read,
                                                buffer,
                                                peer,
                                                FinalizeExternalByteArray));
         CObjectArray* result = new CObjectArray(CObject::NewArray(2));
         result->SetAt(0, new CObjectIntptr(CObject::NewInt32(0)));
@@ skipping 12 matching lines @@
 
 static CObject* FileReadListRequest(const CObjectArray& request) {
   if (request.Length() == 3 &&
       request[1]->IsIntptr() &&
       request[2]->IsInt32OrInt64()) {
     File* file = CObjectToFilePointer(request[1]);
     ASSERT(file != NULL);
     if (!file->IsClosed()) {
       int64_t length = CObjectInt32OrInt64ToInt64(request[2]);
       uint8_t* buffer = new uint8_t[length];
-      int bytes_read = file->Read(buffer, length);
+      int64_t bytes_read = file->Read(buffer, length);
       if (bytes_read >= 0) {
         void* peer = reinterpret_cast<void*>(buffer);
         CObject* external_array =
             new CObjectExternalUint8Array(
                 CObject::NewExternalUint8Array(length,
                                                buffer,
                                                peer,
                                                FinalizeExternalByteArray));
         CObjectArray* result = new CObjectArray(CObject::NewArray(3));
         result->SetAt(0, new CObjectIntptr(CObject::NewInt32(0)));
-        result->SetAt(1, new CObjectIntptr(CObject::NewIntptr(bytes_read)));
+        result->SetAt(1, new CObjectInt64(CObject::NewInt64(bytes_read)));
         result->SetAt(2, external_array);
         return result;
       } else {
         return CObject::NewOSError();
       }
     } else {
       return CObject::FileClosedError();
     }
   }
   return CObject::IllegalArgumentError();
@@ skipping 14 matching lines @@
       uint8_t* buffer_start;
       if (request[2]->IsUint8Array()) {
         CObjectUint8Array byte_array(request[2]);
         buffer_start = byte_array.Buffer() + offset;
       } else {
         CObjectArray array(request[2]);
         buffer_start = new uint8_t[length];
         for (int i = 0; i < length; i++) {
           if (array[i + offset]->IsInt32OrInt64()) {
             int64_t value = CObjectInt32OrInt64ToInt64(array[i + offset]);
-            buffer_start[i] = value & 0xFF;
+            buffer_start[i] = static_cast<uint8_t>(value & 0xFF);
           } else {
             // Unsupported type.
             delete[] buffer_start;
             return CObject::IllegalArgumentError();
           }
         }
         offset = 0;
       }
       int64_t bytes_written =
           file->Write(reinterpret_cast<void*>(buffer_start), length);
       if (!request[2]->IsUint8Array()) {
         delete[] buffer_start;
       }
       if (bytes_written >= 0) {
-        return new CObjectIntptr(CObject::NewIntptr(bytes_written));
+        return new CObjectInt64(CObject::NewInt64(bytes_written));
       } else {
         return CObject::NewOSError();
       }
     } else {
       return CObject::FileClosedError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
@@ skipping 103 matching lines @@
   Dart_EnterScope();
   Dart_SetReturnValue(args, Dart_Null());
   Dart_Port service_port = File::GetServicePort();
   if (service_port != ILLEGAL_PORT) {
     // Return a send port for the service port.
     Dart_Handle send_port = Dart_NewSendPort(service_port);
     Dart_SetReturnValue(args, send_port);
   }
   Dart_ExitScope();
 }