Rename RandomAccessFile.readList and RandomAccessFile.writeList to RandomAccessFile.readInto and Ra…

runtime/bin/file.cc

 // Copyright (c) 2013, 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"
@@ skipping 192 matching lines @@
   } 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) {
+void FUNCTION_NAME(File_ReadInto)(Dart_NativeArguments args) {
   Dart_EnterScope();
   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) <=
+  // start and end arguments are checked in Dart code to be
+  // integers and have the property that end <=
   // list.length. Therefore, it is safe to extract their value as
   // intptr_t.
-  intptr_t offset =
+  intptr_t start =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
-  intptr_t length =
+  intptr_t end =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
+  intptr_t length = end - start;
   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);
+  ASSERT(end <= array_len);
   uint8_t* buffer = new uint8_t[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);
+    result = Dart_ListSetAsBytes(buffer_obj, start, 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) {
+void FUNCTION_NAME(File_WriteFrom)(Dart_NativeArguments args) {
   Dart_EnterScope();
   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
   // intptr_t.
-  intptr_t offset =
+  intptr_t start =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
-  intptr_t length =
+  intptr_t end =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
+  intptr_t length = end - start;
   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);
+  ASSERT(end <= buffer_len);
   uint8_t* buffer = new uint8_t[length];
-  result = Dart_ListGetAsBytes(buffer_obj, offset, buffer, length);
+  result = Dart_ListGetAsBytes(buffer_obj, start, buffer, length);
   if (Dart_IsError(result)) {
     delete[] buffer;
     Dart_PropagateError(result);
   }
   int64_t bytes_written = file->Write(reinterpret_cast<void*>(buffer), length);
-  if (bytes_written >= 0) {
-    Dart_SetReturnValue(args, Dart_NewInteger(bytes_written));
-  } else {
+  if (bytes_written != length) {
     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) {
@@ skipping 638 matching lines @@
         return CObject::NewOSError();
       }
     } else {
       return CObject::FileClosedError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 
-static CObject* FileReadListRequest(const CObjectArray& request) {
+static CObject* FileReadIntoRequest(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]);
       Dart_CObject* io_buffer = CObject::NewIOBuffer(length);
       uint8_t* data = io_buffer->value.as_external_typed_data.data;
       int64_t bytes_read = file->Read(data, length);
@@ skipping 36 matching lines @@
     case Dart_CObject::kFloat64Array:
       return 8;
     default:
       break;
   }
   UNREACHABLE();
   return -1;
 }
 
 
-static CObject* FileWriteListRequest(const CObjectArray& request) {
+static CObject* FileWriteFromRequest(const CObjectArray& request) {
   if (request.Length() == 5 &&
       request[1]->IsIntptr() &&
       (request[2]->IsTypedData() || request[2]->IsArray()) &&
       request[3]->IsInt32OrInt64() &&
       request[4]->IsInt32OrInt64()) {
     File* file = CObjectToFilePointer(request[1]);
     ASSERT(file != NULL);
     if (!file->IsClosed()) {
-      int64_t offset = CObjectInt32OrInt64ToInt64(request[3]);
-      int64_t length = CObjectInt32OrInt64ToInt64(request[4]);
+      int64_t start = CObjectInt32OrInt64ToInt64(request[3]);
+      int64_t end = CObjectInt32OrInt64ToInt64(request[4]);
+      int64_t length = end - start;
       uint8_t* buffer_start;
       if (request[2]->IsTypedData()) {
         CObjectTypedData typed_data(request[2]);
-        offset = offset * SizeInBytes(typed_data.Type());
+        start = start * SizeInBytes(typed_data.Type());
         length = length * SizeInBytes(typed_data.Type());
-        buffer_start = typed_data.Buffer() + offset;
+        buffer_start = typed_data.Buffer() + start;
       } 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]);
+          if (array[i + start]->IsInt32OrInt64()) {
+            int64_t value = CObjectInt32OrInt64ToInt64(array[i + start]);
             buffer_start[i] = static_cast<uint8_t>(value & 0xFF);
           } else {
             // Unsupported type.
             delete[] buffer_start;
             return CObject::IllegalArgumentError();
           }
         }
-        offset = 0;
+        start = 0;
       }
       int64_t bytes_written =
           file->Write(reinterpret_cast<void*>(buffer_start), length);
       if (!request[2]->IsTypedData()) {
         delete[] buffer_start;
       }
       if (bytes_written >= 0) {
         return new CObjectInt64(CObject::NewInt64(bytes_written));
       } else {
         return CObject::NewOSError();
@@ skipping 89 matching lines @@
           break;
         case File::kReadByteRequest:
           response = FileReadByteRequest(request);
           break;
         case File::kWriteByteRequest:
           response = FileWriteByteRequest(request);
           break;
         case File::kReadRequest:
           response = FileReadRequest(request);
           break;
-        case File::kReadListRequest:
-          response = FileReadListRequest(request);
+        case File::kReadIntoRequest:
+          response = FileReadIntoRequest(request);
           break;
-        case File::kWriteListRequest:
-          response = FileWriteListRequest(request);
+        case File::kWriteFromRequest:
+          response = FileWriteFromRequest(request);
           break;
         case File::kDeleteLinkRequest:
           response = FileDeleteLinkRequest(request);
           break;
         case File::kCreateLinkRequest:
           response = FileCreateLinkRequest(request);
           break;
         default:
           UNREACHABLE();
       }
@@ skipping 13 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();
 }