mojo/dart/embedder/builtin_natives.cc - mojo-tools - Git at Google

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "crypto/random.h"
 #include "dart/runtime/include/dart_api.h"
 #include "mojo/dart/embedder/builtin.h"
 #include "mojo/dart/embedder/mojo_natives.h"

 namespace mojo {
 namespace dart {

 // Lists the native functions implementing basic functionality in
 // the Mojo embedder dart, such as printing, and file I/O.
 #define BUILTIN_NATIVE_LIST(V)                                                 \
   V(Crypto_GetRandomBytes, 1)                                                  \
   V(Logger_PrintString, 1)                                                     \
   V(Builtin_ReadSync, 1)                                                       \
   V(Builtin_EnumerateFiles, 1)                                                 \
   V(Builtin_LoadScript, 4)                                                     \
   V(Builtin_AsyncLoadError, 3)                                                 \
   V(Builtin_DoneLoading, 0)

 BUILTIN_NATIVE_LIST(DECLARE_FUNCTION);

 static struct NativeEntries {
   const char* name;
   Dart_NativeFunction function;
   int argument_count;
 } BuiltinEntries[] = {BUILTIN_NATIVE_LIST(REGISTER_FUNCTION)};

 Dart_NativeFunction Builtin::NativeLookup(Dart_Handle name,
                                           int argument_count,
                                           bool* auto_setup_scope) {
   const char* function_name = nullptr;
   Dart_Handle result = Dart_StringToCString(name, &function_name);
   DART_CHECK_VALID(result);
   DCHECK(function_name != nullptr);
   DCHECK(auto_setup_scope != nullptr);
   *auto_setup_scope = true;
   size_t num_entries = arraysize(BuiltinEntries);
   for (size_t i = 0; i < num_entries; i++) {
     const struct NativeEntries& entry = BuiltinEntries[i];
     if (!strcmp(function_name, entry.name) &&
         (entry.argument_count == argument_count)) {
       return entry.function;
     }
   }
   return nullptr;
 }

 const uint8_t* Builtin::NativeSymbol(Dart_NativeFunction nf) {
   size_t num_entries = arraysize(BuiltinEntries);
   for (size_t i = 0; i < num_entries; i++) {
     const struct NativeEntries& entry = BuiltinEntries[i];
     if (entry.function == nf) {
       return reinterpret_cast<const uint8_t*>(entry.name);
     }
   }
   return nullptr;
 }

 // Implementation of native functions which are used for some
 // test/debug functionality in standalone dart mode.
 void Logger_PrintString(Dart_NativeArguments args) {
   intptr_t length = 0;
   uint8_t* chars = nullptr;
   Dart_Handle str = Dart_GetNativeArgument(args, 0);
   Dart_Handle result = Dart_StringToUTF8(str, &chars, &length);
   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   } else {
     // Uses fwrite to support printing NUL bytes.
     fwrite(chars, 1, length, stdout);
     fputs("\n", stdout);
   }
   fflush(stdout);
 }

 void Builtin_ReadSync(Dart_NativeArguments args) {
   intptr_t chars_length = 0;
   uint8_t* chars = nullptr;
   Dart_Handle file_uri = Dart_GetNativeArgument(args, 0);
   if (!Dart_IsString(file_uri)) {
     Dart_PropagateError(file_uri);
   }

   intptr_t file_uri_length = 0;
   Dart_Handle result = Dart_StringLength(file_uri, &file_uri_length);

   result = Dart_StringToUTF8(file_uri, &chars, &chars_length);
   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   }
   chars[file_uri_length] = '\0';

   base::FilePath path(base::FilePath::FromUTF8Unsafe(
       std::string(reinterpret_cast<char*>(chars))));

   std::string source;
   if (ReadFileToString(path, &source)) {
     Dart_Handle data =
         Dart_NewTypedData(Dart_TypedData_kUint8, source.length());
     char* source_chars = const_cast<char*>(source.c_str());
     Dart_ListSetAsBytes(data, 0, reinterpret_cast<uint8_t*>(source_chars),
                         source.length());
     Dart_SetReturnValue(args, data);
     return;
   }
   LOG(ERROR) << "Failed to read path: " << chars;
   Dart_SetReturnValue(args, Dart_Null());
 }

 void Builtin_EnumerateFiles(Dart_NativeArguments args) {
   intptr_t chars_length = 0;
   uint8_t* chars = nullptr;
   Dart_Handle path = Dart_GetNativeArgument(args, 0);
   if (!Dart_IsString(path)) {
     Dart_PropagateError(path);
   }

   intptr_t path_length = 0;
   Dart_Handle result = Dart_StringLength(path, &path_length);
   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   }

   result = Dart_StringToUTF8(path, &chars, &chars_length);
   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   }

   chars[path_length] = '\0';
   base::FilePath dir_path(base::FilePath::FromUTF8Unsafe(
       std::string(reinterpret_cast<char*>(chars))));

   std::vector<std::string> entries;
   base::FileEnumerator enumerator(dir_path, false, base::FileEnumerator::FILES);
   while (true) {
     base::FilePath file_path = enumerator.Next();
     std::string file_path_string = file_path.AsUTF8Unsafe();
     if (file_path_string == "") {
       break;
     }
     entries.push_back(file_path_string);
   }

   Dart_Handle list = Dart_NewList(entries.size());
   for (uintptr_t i = 0; i < entries.size(); i++) {
     Dart_Handle entry = Dart_NewStringFromUTF8(
         reinterpret_cast<const uint8_t*>(entries[i].data()),
         entries[i].length());
     Dart_ListSetAt(list, i, entry);
   }
   Dart_SetReturnValue(args, list);
 }

 // Callback function, gets called from asynchronous script and library
 // reading code when there is an i/o error.
 void Builtin_AsyncLoadError(Dart_NativeArguments args) {
   //  Dart_Handle source_uri = Dart_GetNativeArgument(args, 0);
   Dart_Handle library_uri = Dart_GetNativeArgument(args, 1);
   Dart_Handle error = Dart_GetNativeArgument(args, 2);
   Dart_Handle library = Dart_LookupLibrary(library_uri);
   // If a library with the given uri exists, give it a chance to handle
   // the error. If the load requests stems from a deferred library load,
   // an IO error is not fatal.
   if (!Dart_IsError(library)) {
     DCHECK(Dart_IsLibrary(library));
     Dart_Handle res = Dart_LibraryHandleError(library, error);
     if (Dart_IsNull(res)) {
       return;
     }
   }
   // The error was not handled above. Propagate an unhandled exception.
   error = Dart_NewUnhandledExceptionError(error);
   Dart_PropagateError(error);
 }

 static const uint8_t* SniffForMagicNumber(const uint8_t* text_buffer,
                                           intptr_t* buffer_len,
                                           bool* is_snapshot) {
   intptr_t len = sizeof(Builtin::snapshot_magic_number);
   for (intptr_t i = 0; i < len; i++) {
     if (text_buffer[i] != Builtin::snapshot_magic_number[i]) {
       *is_snapshot = false;
       return text_buffer;
     }
   }
   *is_snapshot = true;
   DCHECK_GT(*buffer_len, len);
   *buffer_len -= len;
   return text_buffer + len;
 }

 // Callback function called when the asynchronous load request of a
 // script, library or part is complete.
 void Builtin_LoadScript(Dart_NativeArguments args) {
   Dart_Handle tag_in = Dart_GetNativeArgument(args, 0);
   Dart_Handle resolved_script_uri = Dart_GetNativeArgument(args, 1);
   Dart_Handle library_uri = Dart_GetNativeArgument(args, 2);
   Dart_Handle source_data = Dart_GetNativeArgument(args, 3);

   Dart_TypedData_Type type = Dart_GetTypeOfExternalTypedData(source_data);
   bool external = type == Dart_TypedData_kUint8;
   uint8_t* data = nullptr;
   intptr_t num_bytes;
   Dart_Handle result = Dart_TypedDataAcquireData(
       source_data, &type, reinterpret_cast<void**>(&data), &num_bytes);
   if (Dart_IsError(result))
     Dart_PropagateError(result);

   scoped_ptr<uint8_t[]> buffer_copy;
   if (!external) {
     // If the buffer is not external, take a copy.
     buffer_copy.reset(new uint8_t[num_bytes]);
     memmove(buffer_copy.get(), data, num_bytes);
     data = buffer_copy.get();
   }

   Dart_TypedDataReleaseData(source_data);

   if (Dart_IsNull(tag_in) && Dart_IsNull(library_uri)) {
     // No tag and a null library_uri indicates this is
     // a top-level script, check if it is a snapshot or a regular
     // script file and load accordingly.
     bool is_snapshot = false;
     const uint8_t* payload =
         SniffForMagicNumber(data, &num_bytes, &is_snapshot);

     if (is_snapshot) {
       result = Dart_LoadScriptFromSnapshot(payload, num_bytes);
     } else {
       Dart_Handle source = Dart_NewStringFromUTF8(data, num_bytes);
       if (Dart_IsError(source)) {
         result = Builtin::NewError("%s is not a valid UTF-8 script",
                                    resolved_script_uri);
       } else {
         result = Dart_LoadScript(resolved_script_uri, source, 0, 0);
       }
     }
   } else {
     int64_t tag = Builtin::GetIntegerValue(tag_in);

     Dart_Handle source = Dart_NewStringFromUTF8(data, num_bytes);
     if (Dart_IsError(source)) {
       result = Builtin::NewError("%s is not a valid UTF-8 script",
                                  resolved_script_uri);
     } else {
       if (tag == Dart_kImportTag) {
         result = Dart_LoadLibrary(resolved_script_uri, source, 0, 0);
       } else {
         DCHECK_EQ(tag, Dart_kSourceTag);
         Dart_Handle library = Dart_LookupLibrary(library_uri);
         DART_CHECK_VALID(library);
         result = Dart_LoadSource(library, resolved_script_uri, source, 0, 0);
       }
     }
   }

   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   }
 }

 // Callback function that gets called from dartutils when there are
 // no more outstanding load requests.
 void Builtin_DoneLoading(Dart_NativeArguments args) {
   Dart_Handle res = Dart_FinalizeLoading(true);
   if (Dart_IsError(res)) {
     Dart_PropagateError(res);
   }
 }

 static bool GetInt64Value(Dart_Handle value_obj, int64_t* value) {
   bool valid = Dart_IsInteger(value_obj);
   if (valid) {
     Dart_Handle result = Dart_IntegerFitsIntoInt64(value_obj, &valid);
     if (Dart_IsError(result))
       Dart_PropagateError(result);
   }
   if (!valid)
     return false;
   Dart_Handle result = Dart_IntegerToInt64(value_obj, value);
   if (Dart_IsError(result))
     Dart_PropagateError(result);
   return true;
 }

 void Crypto_GetRandomBytes(Dart_NativeArguments args) {
   Dart_Handle count_obj = Dart_GetNativeArgument(args, 0);
   const int64_t kMaxRandomBytes = 4096;
   int64_t count64 = 0;
   if (!GetInt64Value(count_obj, &count64) || (count64 < 0) ||
       (count64 > kMaxRandomBytes)) {
     Dart_Handle error = Dart_NewStringFromCString(
         "Invalid argument: count must be a positive int "
         "less than or equal to 4096.");
     Dart_ThrowException(error);
   }
   intptr_t count = static_cast<intptr_t>(count64);
   scoped_ptr<uint8_t[]> buffer(new uint8_t[count]);

   crypto::RandBytes(reinterpret_cast<void*>(buffer.get()), count);

   Dart_Handle result = Dart_NewTypedData(Dart_TypedData_kUint8, count);
   if (Dart_IsError(result)) {
     Dart_Handle error = Dart_NewStringFromCString(
         "Failed to allocate storage.");
     Dart_ThrowException(error);
   }
   Dart_ListSetAsBytes(result, 0, buffer.get(), count);
   Dart_SetReturnValue(args, result);
 }

 }  // namespace bin
 }  // namespace dart
	// Copyright 2014 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "base/files/file_enumerator.h"
	#include "base/files/file_path.h"
	#include "base/files/file_util.h"
	#include "base/logging.h"
	#include "base/macros.h"
	#include "base/memory/scoped_ptr.h"
	#include "crypto/random.h"
	#include "dart/runtime/include/dart_api.h"
	#include "mojo/dart/embedder/builtin.h"
	#include "mojo/dart/embedder/mojo_natives.h"

	namespace mojo {
	namespace dart {

	// Lists the native functions implementing basic functionality in
	// the Mojo embedder dart, such as printing, and file I/O.
	#define BUILTIN_NATIVE_LIST(V) \
	V(Crypto_GetRandomBytes, 1) \
	V(Logger_PrintString, 1) \
	V(Builtin_ReadSync, 1) \
	V(Builtin_EnumerateFiles, 1) \
	V(Builtin_LoadScript, 4) \
	V(Builtin_AsyncLoadError, 3) \
	V(Builtin_DoneLoading, 0)

	BUILTIN_NATIVE_LIST(DECLARE_FUNCTION);

	static struct NativeEntries {
	const char* name;
	Dart_NativeFunction function;
	int argument_count;
	} BuiltinEntries[] = {BUILTIN_NATIVE_LIST(REGISTER_FUNCTION)};

	Dart_NativeFunction Builtin::NativeLookup(Dart_Handle name,
	int argument_count,
	bool* auto_setup_scope) {
	const char* function_name = nullptr;
	Dart_Handle result = Dart_StringToCString(name, &function_name);
	DART_CHECK_VALID(result);
	DCHECK(function_name != nullptr);
	DCHECK(auto_setup_scope != nullptr);
	*auto_setup_scope = true;
	size_t num_entries = arraysize(BuiltinEntries);
	for (size_t i = 0; i < num_entries; i++) {
	const struct NativeEntries& entry = BuiltinEntries[i];
	if (!strcmp(function_name, entry.name) &&
	(entry.argument_count == argument_count)) {
	return entry.function;
	}
	}
	return nullptr;
	}

	const uint8_t* Builtin::NativeSymbol(Dart_NativeFunction nf) {
	size_t num_entries = arraysize(BuiltinEntries);
	for (size_t i = 0; i < num_entries; i++) {
	const struct NativeEntries& entry = BuiltinEntries[i];
	if (entry.function == nf) {
	return reinterpret_cast<const uint8_t*>(entry.name);
	}
	}
	return nullptr;
	}

	// Implementation of native functions which are used for some
	// test/debug functionality in standalone dart mode.
	void Logger_PrintString(Dart_NativeArguments args) {
	intptr_t length = 0;
	uint8_t* chars = nullptr;
	Dart_Handle str = Dart_GetNativeArgument(args, 0);
	Dart_Handle result = Dart_StringToUTF8(str, &chars, &length);
	if (Dart_IsError(result)) {
	Dart_PropagateError(result);
	} else {
	// Uses fwrite to support printing NUL bytes.
	fwrite(chars, 1, length, stdout);
	fputs("\n", stdout);
	}
	fflush(stdout);
	}

	void Builtin_ReadSync(Dart_NativeArguments args) {
	intptr_t chars_length = 0;
	uint8_t* chars = nullptr;
	Dart_Handle file_uri = Dart_GetNativeArgument(args, 0);
	if (!Dart_IsString(file_uri)) {
	Dart_PropagateError(file_uri);
	}

	intptr_t file_uri_length = 0;
	Dart_Handle result = Dart_StringLength(file_uri, &file_uri_length);

	result = Dart_StringToUTF8(file_uri, &chars, &chars_length);
	if (Dart_IsError(result)) {
	Dart_PropagateError(result);
	}
	chars[file_uri_length] = '\0';

	base::FilePath path(base::FilePath::FromUTF8Unsafe(
	std::string(reinterpret_cast<char*>(chars))));

	std::string source;
	if (ReadFileToString(path, &source)) {
	Dart_Handle data =
	Dart_NewTypedData(Dart_TypedData_kUint8, source.length());
	char* source_chars = const_cast<char*>(source.c_str());
	Dart_ListSetAsBytes(data, 0, reinterpret_cast<uint8_t*>(source_chars),
	source.length());
	Dart_SetReturnValue(args, data);
	return;
	}
	LOG(ERROR) << "Failed to read path: " << chars;
	Dart_SetReturnValue(args, Dart_Null());
	}

	void Builtin_EnumerateFiles(Dart_NativeArguments args) {
	intptr_t chars_length = 0;
	uint8_t* chars = nullptr;
	Dart_Handle path = Dart_GetNativeArgument(args, 0);
	if (!Dart_IsString(path)) {
	Dart_PropagateError(path);
	}

	intptr_t path_length = 0;
	Dart_Handle result = Dart_StringLength(path, &path_length);
	if (Dart_IsError(result)) {
	Dart_PropagateError(result);
	}

	result = Dart_StringToUTF8(path, &chars, &chars_length);
	if (Dart_IsError(result)) {
	Dart_PropagateError(result);
	}

	chars[path_length] = '\0';
	base::FilePath dir_path(base::FilePath::FromUTF8Unsafe(
	std::string(reinterpret_cast<char*>(chars))));

	std::vector<std::string> entries;
	base::FileEnumerator enumerator(dir_path, false, base::FileEnumerator::FILES);
	while (true) {
	base::FilePath file_path = enumerator.Next();
	std::string file_path_string = file_path.AsUTF8Unsafe();
	if (file_path_string == "") {
	break;
	}
	entries.push_back(file_path_string);
	}

	Dart_Handle list = Dart_NewList(entries.size());
	for (uintptr_t i = 0; i < entries.size(); i++) {
	Dart_Handle entry = Dart_NewStringFromUTF8(
	reinterpret_cast<const uint8_t*>(entries[i].data()),
	entries[i].length());
	Dart_ListSetAt(list, i, entry);
	}
	Dart_SetReturnValue(args, list);
	}

	// Callback function, gets called from asynchronous script and library
	// reading code when there is an i/o error.
	void Builtin_AsyncLoadError(Dart_NativeArguments args) {
	// Dart_Handle source_uri = Dart_GetNativeArgument(args, 0);
	Dart_Handle library_uri = Dart_GetNativeArgument(args, 1);
	Dart_Handle error = Dart_GetNativeArgument(args, 2);
	Dart_Handle library = Dart_LookupLibrary(library_uri);
	// If a library with the given uri exists, give it a chance to handle
	// the error. If the load requests stems from a deferred library load,
	// an IO error is not fatal.
	if (!Dart_IsError(library)) {
	DCHECK(Dart_IsLibrary(library));
	Dart_Handle res = Dart_LibraryHandleError(library, error);
	if (Dart_IsNull(res)) {
	return;
	}
	}
	// The error was not handled above. Propagate an unhandled exception.
	error = Dart_NewUnhandledExceptionError(error);
	Dart_PropagateError(error);
	}

	static const uint8_t* SniffForMagicNumber(const uint8_t* text_buffer,
	intptr_t* buffer_len,
	bool* is_snapshot) {
	intptr_t len = sizeof(Builtin::snapshot_magic_number);
	for (intptr_t i = 0; i < len; i++) {
	if (text_buffer[i] != Builtin::snapshot_magic_number[i]) {
	*is_snapshot = false;
	return text_buffer;
	}
	}
	*is_snapshot = true;
	DCHECK_GT(*buffer_len, len);
	*buffer_len -= len;
	return text_buffer + len;
	}

	// Callback function called when the asynchronous load request of a
	// script, library or part is complete.
	void Builtin_LoadScript(Dart_NativeArguments args) {
	Dart_Handle tag_in = Dart_GetNativeArgument(args, 0);
	Dart_Handle resolved_script_uri = Dart_GetNativeArgument(args, 1);
	Dart_Handle library_uri = Dart_GetNativeArgument(args, 2);
	Dart_Handle source_data = Dart_GetNativeArgument(args, 3);

	Dart_TypedData_Type type = Dart_GetTypeOfExternalTypedData(source_data);
	bool external = type == Dart_TypedData_kUint8;
	uint8_t* data = nullptr;
	intptr_t num_bytes;
	Dart_Handle result = Dart_TypedDataAcquireData(
	source_data, &type, reinterpret_cast<void**>(&data), &num_bytes);
	if (Dart_IsError(result))
	Dart_PropagateError(result);

	scoped_ptr<uint8_t[]> buffer_copy;
	if (!external) {
	// If the buffer is not external, take a copy.
	buffer_copy.reset(new uint8_t[num_bytes]);
	memmove(buffer_copy.get(), data, num_bytes);
	data = buffer_copy.get();
	}

	Dart_TypedDataReleaseData(source_data);

	if (Dart_IsNull(tag_in) && Dart_IsNull(library_uri)) {
	// No tag and a null library_uri indicates this is
	// a top-level script, check if it is a snapshot or a regular
	// script file and load accordingly.
	bool is_snapshot = false;
	const uint8_t* payload =
	SniffForMagicNumber(data, &num_bytes, &is_snapshot);

	if (is_snapshot) {
	result = Dart_LoadScriptFromSnapshot(payload, num_bytes);
	} else {
	Dart_Handle source = Dart_NewStringFromUTF8(data, num_bytes);
	if (Dart_IsError(source)) {
	result = Builtin::NewError("%s is not a valid UTF-8 script",
	resolved_script_uri);
	} else {
	result = Dart_LoadScript(resolved_script_uri, source, 0, 0);
	}
	}
	} else {
	int64_t tag = Builtin::GetIntegerValue(tag_in);

	Dart_Handle source = Dart_NewStringFromUTF8(data, num_bytes);
	if (Dart_IsError(source)) {
	result = Builtin::NewError("%s is not a valid UTF-8 script",
	resolved_script_uri);
	} else {
	if (tag == Dart_kImportTag) {
	result = Dart_LoadLibrary(resolved_script_uri, source, 0, 0);
	} else {
	DCHECK_EQ(tag, Dart_kSourceTag);
	Dart_Handle library = Dart_LookupLibrary(library_uri);
	DART_CHECK_VALID(library);
	result = Dart_LoadSource(library, resolved_script_uri, source, 0, 0);
	}
	}
	}

	if (Dart_IsError(result)) {
	Dart_PropagateError(result);
	}
	}

	// Callback function that gets called from dartutils when there are
	// no more outstanding load requests.
	void Builtin_DoneLoading(Dart_NativeArguments args) {
	Dart_Handle res = Dart_FinalizeLoading(true);
	if (Dart_IsError(res)) {
	Dart_PropagateError(res);
	}
	}

	static bool GetInt64Value(Dart_Handle value_obj, int64_t* value) {
	bool valid = Dart_IsInteger(value_obj);
	if (valid) {
	Dart_Handle result = Dart_IntegerFitsIntoInt64(value_obj, &valid);
	if (Dart_IsError(result))
	Dart_PropagateError(result);
	}
	if (!valid)
	return false;
	Dart_Handle result = Dart_IntegerToInt64(value_obj, value);
	if (Dart_IsError(result))
	Dart_PropagateError(result);
	return true;
	}

	void Crypto_GetRandomBytes(Dart_NativeArguments args) {
	Dart_Handle count_obj = Dart_GetNativeArgument(args, 0);
	const int64_t kMaxRandomBytes = 4096;
	int64_t count64 = 0;
	if (!GetInt64Value(count_obj, &count64) \|\| (count64 < 0) \|\|
	(count64 > kMaxRandomBytes)) {
	Dart_Handle error = Dart_NewStringFromCString(
	"Invalid argument: count must be a positive int "
	"less than or equal to 4096.");
	Dart_ThrowException(error);
	}
	intptr_t count = static_cast<intptr_t>(count64);
	scoped_ptr<uint8_t[]> buffer(new uint8_t[count]);

	crypto::RandBytes(reinterpret_cast<void*>(buffer.get()), count);

	Dart_Handle result = Dart_NewTypedData(Dart_TypedData_kUint8, count);
	if (Dart_IsError(result)) {
	Dart_Handle error = Dart_NewStringFromCString(
	"Failed to allocate storage.");
	Dart_ThrowException(error);
	}
	Dart_ListSetAsBytes(result, 0, buffer.get(), count);
	Dart_SetReturnValue(args, result);
	}

	} // namespace bin
	} // namespace dart