Second step towards loading the core library scripts directly from the sources

runtime/bin/dartutils.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/dartutils.h"
 
 #include "bin/extensions.h"
 #include "bin/directory.h"
 #include "bin/file.h"
 #include "bin/io_buffer.h"
@@ skipping 173 matching lines @@
   }
   // Calculate the canonical path.
   const char* canon_url_str = GetCanonicalPath(library_url_str, url_str);
   Dart_Handle canon_url = NewString(canon_url_str);
   free(const_cast<char*>(canon_url_str));
 
   return canon_url;
 }
 
 
-static const uint8_t* ReadFile(const char* filename,
-                               intptr_t* file_len,
-                               const char** error_msg) {
-  File* file = File::Open(filename, File::kRead);
-  if (file == NULL) {
+void* DartUtils::OpenFile(const char* name, bool write) {
+  File* file = File::Open(name, write ? File::kWriteTruncate : File::kRead);
+  return reinterpret_cast<void*>(file);
+}
+
+
+void DartUtils::ReadFile(const uint8_t** data,
+                         intptr_t* file_len,
+                         void* stream) {
+  ASSERT(data != NULL);
+  ASSERT(file_len != NULL);
+  ASSERT(stream != NULL);
+  File* file_stream = reinterpret_cast<File*>(stream);
+  *file_len = file_stream->Length();
+  ASSERT(*file_len > 0);
+  uint8_t* text_buffer = reinterpret_cast<uint8_t*>(malloc(*file_len));
+  ASSERT(text_buffer != NULL);
+  if (!file_stream->ReadFully(text_buffer, *file_len)) {
+    *data = NULL;
+    *file_len = -1;  // Indicates read was not successful.
+    return;
+  }
+  *data = text_buffer;
+}
+
+
+void DartUtils::WriteFile(const void* buffer,
+                          intptr_t num_bytes,
+                          void* stream) {
+  ASSERT(stream != NULL);
+  File* file_stream = reinterpret_cast<File*>(stream);
+  bool bytes_written = file_stream->WriteFully(buffer, num_bytes);
+  ASSERT(bytes_written);
+}
+
+
+void DartUtils::CloseFile(void* stream) {
+  delete reinterpret_cast<File*>(stream);
+}
+
+
+static const uint8_t* ReadFileFully(const char* filename,
+                                    intptr_t* file_len,
+                                    const char** error_msg) {
+  void* stream = DartUtils::OpenFile(filename, false);
+  if (stream == NULL) {
     const char* format = "Unable to open file: %s";
     intptr_t len = snprintf(NULL, 0, format, filename);
     // TODO(iposva): Allocate from the zone instead of leaking error string
     // here. On the other hand the binary is about the exit anyway.
     char* msg = reinterpret_cast<char*>(malloc(len + 1));
     snprintf(msg, len + 1, format, filename);
     *error_msg = msg;
     return NULL;
   }
-  *file_len = file->Length();
-  uint8_t* text_buffer = reinterpret_cast<uint8_t*>(malloc(*file_len));
-  if (text_buffer == NULL) {
-    delete file;
-    *error_msg = "Unable to allocate buffer";
-    return NULL;
+  *file_len = -1;
+  const uint8_t* text_buffer = NULL;
+  DartUtils::ReadFile(&text_buffer, file_len, stream);
+  if (text_buffer == NULL || *file_len == -1) {
+    *error_msg = "Unable to read file contents";
+    text_buffer = NULL;
   }
-  if (!file->ReadFully(text_buffer, *file_len)) {
-    delete file;
-    free(text_buffer);
-    *error_msg = "Unable to fully read contents";
-    return NULL;
-  }
-  delete file;
+  DartUtils::CloseFile(stream);
   return text_buffer;
 }
 
 
 Dart_Handle DartUtils::ReadStringFromFile(const char* filename) {
   const char* error_msg = NULL;
   intptr_t len;
-  const uint8_t* text_buffer = ReadFile(filename, &len, &error_msg);
+  const uint8_t* text_buffer = ReadFileFully(filename, &len, &error_msg);
   if (text_buffer == NULL) {
     return Dart_Error(error_msg);
   }
   Dart_Handle str = Dart_NewStringFromUTF8(text_buffer, len);
   return str;
 }
 
 
 Dart_Handle DartUtils::ResolveScriptUri(Dart_Handle script_uri,
                                         Dart_Handle builtin_lib) {
@@ skipping 137 matching lines @@
   }
   Dart_Handle script_path = DartUtils::FilePathFromUri(resolved_script_uri,
                                                        builtin_lib);
   if (Dart_IsError(script_path)) {
     return script_path;
   }
   const char* script_path_cstr;
   Dart_StringToCString(script_path, &script_path_cstr);
   const char* error_msg = NULL;
   intptr_t len;
-  const uint8_t* text_buffer = ReadFile(script_path_cstr, &len, &error_msg);
+  const uint8_t* text_buffer = ReadFileFully(script_path_cstr,
+                                             &len,
+                                             &error_msg);
   if (text_buffer == NULL) {
     return Dart_Error(error_msg);
   }
   bool is_snapshot = false;
   text_buffer = SniffForMagicNumber(text_buffer, &len, &is_snapshot);
   if (is_snapshot) {
     return Dart_LoadScriptFromSnapshot(text_buffer, len);
   } else {
     Dart_Handle source = Dart_NewStringFromUTF8(text_buffer, len);
     if (Dart_IsError(source)) {
@@ skipping 354 matching lines @@
       new CObjectString(CObject::NewString(os_error->message()));
   CObjectArray* result = new CObjectArray(CObject::NewArray(3));
   result->SetAt(0, new CObjectInt32(CObject::NewInt32(kOSError)));
   result->SetAt(1, new CObjectInt32(CObject::NewInt32(os_error->code())));
   result->SetAt(2, error_message);
   return result;
 }
 
 }  // namespace bin
 }  // namespace dart