| // Copyright (c) 2016, 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 <dart_api.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "bin/log.h" |
| #include "platform/assert.h" |
| |
| const char* kBuiltinScript = |
| "_printString(String line) native \"Builtin_PrintString\";\n" |
| "_getPrintClosure() => _printString;\n"; |
| |
| const char* kHelloWorldScript = "main() { print(\"Hello, Fuchsia!\"); }"; |
| |
| namespace dart { |
| namespace bin { |
| |
| // vm_isolate_snapshot_buffer points to a snapshot for the vm isolate if we |
| // link in a snapshot otherwise it is initialized to NULL. |
| extern const uint8_t* vm_isolate_snapshot_buffer; |
| |
| // isolate_snapshot_buffer points to a snapshot for an isolate if we link in a |
| // snapshot otherwise it is initialized to NULL. |
| extern const uint8_t* isolate_snapshot_buffer; |
| |
| static void Builtin_PrintString(Dart_NativeArguments args) { |
| intptr_t length = 0; |
| uint8_t* chars = NULL; |
| Dart_Handle str = Dart_GetNativeArgument(args, 0); |
| Dart_Handle result = Dart_StringToUTF8(str, &chars, &length); |
| if (Dart_IsError(result)) { |
| Dart_PropagateError(result); |
| } |
| // Uses fwrite to support printing NUL bytes. |
| intptr_t res = fwrite(chars, 1, length, stdout); |
| ASSERT(res == length); |
| fputs("\n", stdout); |
| fflush(stdout); |
| } |
| |
| static Dart_NativeFunction NativeLookup(Dart_Handle name, |
| int argument_count, |
| bool* auto_setup_scope) { |
| const char* function_name = NULL; |
| Dart_Handle err = Dart_StringToCString(name, &function_name); |
| DART_CHECK_VALID(err); |
| *auto_setup_scope = true; |
| if (strcmp(function_name, "Builtin_PrintString") == 0) { |
| return reinterpret_cast<Dart_NativeFunction>(Builtin_PrintString); |
| } |
| return NULL; |
| } |
| |
| static const uint8_t* NativeSymbol(Dart_NativeFunction nf) { |
| if (reinterpret_cast<Dart_NativeFunction>(Builtin_PrintString) == nf) { |
| return reinterpret_cast<const uint8_t*>("Builtin_PrintString"); |
| } |
| return NULL; |
| } |
| |
| static Dart_Handle PrepareBuiltinLibrary(const char* script) { |
| Log::Print("Creating builtin library uri\n"); |
| Dart_Handle builtin_uri = Dart_NewStringFromCString("builtin_uri"); |
| DART_CHECK_VALID(builtin_uri); |
| |
| Log::Print("Creating builtin library script string\n"); |
| Dart_Handle builtin_script = Dart_NewStringFromCString(script); |
| DART_CHECK_VALID(builtin_script); |
| |
| Log::Print("Loading builtin library\n"); |
| Dart_Handle status = Dart_LoadLibrary(builtin_uri, builtin_script, 0, 0); |
| DART_CHECK_VALID(status); |
| |
| Log::Print("Looking up builtin library\n"); |
| Dart_Handle builtin_library = Dart_LookupLibrary(builtin_uri); |
| DART_CHECK_VALID(builtin_library); |
| |
| Log::Print("Setting up native resolver for builtin library\n"); |
| status = Dart_SetNativeResolver(builtin_library, NativeLookup, NativeSymbol); |
| DART_CHECK_VALID(status); |
| |
| return builtin_library; |
| } |
| |
| static Dart_Handle PrepareScriptLibrary(const char* script) { |
| Log::Print("Creating script URI string\n"); |
| Dart_Handle script_uri = Dart_NewStringFromCString("script_uri"); |
| DART_CHECK_VALID(script_uri); |
| |
| Log::Print("Creating script string\n"); |
| Dart_Handle script_string = Dart_NewStringFromCString(script); |
| DART_CHECK_VALID(script_string); |
| |
| Log::Print("Loading script into new library\n"); |
| Dart_Handle status = Dart_LoadLibrary(script_uri, script_string, 0, 0); |
| DART_CHECK_VALID(status); |
| |
| Log::Print("Looking up script library\n"); |
| Dart_Handle library = Dart_LookupLibrary(script_uri); |
| DART_CHECK_VALID(library); |
| |
| return library; |
| } |
| |
| static Dart_Handle LoadInternalLibrary() { |
| Log::Print("Creating internal library uri string\n"); |
| Dart_Handle url = Dart_NewStringFromCString("dart:_internal"); |
| DART_CHECK_VALID(url); |
| |
| Log::Print("Looking up internal library\n"); |
| Dart_Handle internal_library = Dart_LookupLibrary(url); |
| DART_CHECK_VALID(internal_library); |
| |
| return internal_library; |
| } |
| |
| static void PreparePrintClosure(Dart_Handle builtin_library, |
| Dart_Handle internal_library) { |
| Log::Print("Creating _getPrintClosure name string\n"); |
| Dart_Handle get_print_closure_name = |
| Dart_NewStringFromCString("_getPrintClosure"); |
| DART_CHECK_VALID(get_print_closure_name); |
| |
| Log::Print("Invoking _getPrintClosure\n"); |
| Dart_Handle print_closure = Dart_Invoke( |
| builtin_library, get_print_closure_name, 0, NULL); |
| DART_CHECK_VALID(print_closure); |
| |
| Log::Print("Creating _printClosure name string\n"); |
| Dart_Handle print_closure_name = Dart_NewStringFromCString("_printClosure"); |
| DART_CHECK_VALID(print_closure_name); |
| |
| Log::Print("Setting _printClosure to result of _getPrintClosure\n"); |
| Dart_Handle status = Dart_SetField( |
| internal_library, print_closure_name, print_closure); |
| DART_CHECK_VALID(status); |
| } |
| |
| int Main() { |
| Log::Print("Calling Dart_SetVMFlags\n"); |
| if (!Dart_SetVMFlags(0, NULL)) { |
| FATAL("Failed to set flags\n"); |
| } |
| Log::Print("Calling Dart_Initialize\n"); |
| char* error = Dart_Initialize( |
| vm_isolate_snapshot_buffer, NULL, NULL, |
| NULL, NULL, NULL, NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL); |
| if (error != NULL) { |
| FATAL1("VM initialization failed: %s\n", error); |
| } |
| |
| Log::Print("Creating Isolate\n"); |
| Dart_Isolate isolate = Dart_CreateIsolate( |
| "script_uri", |
| "main", |
| isolate_snapshot_buffer, |
| NULL, |
| NULL, |
| &error); |
| if (isolate == NULL) { |
| FATAL1("Dart_CreateIsolate failed: %s\n", error); |
| } |
| |
| Log::Print("Entering Scope\n"); |
| Dart_EnterScope(); |
| |
| Dart_Handle library = PrepareScriptLibrary(kHelloWorldScript); |
| |
| Dart_Handle builtin_library = PrepareBuiltinLibrary(kBuiltinScript); |
| |
| Log::Print("Finalizing loading\n"); |
| Dart_Handle status = Dart_FinalizeLoading(false); |
| DART_CHECK_VALID(status); |
| |
| Dart_Handle internal_library = LoadInternalLibrary(); |
| |
| PreparePrintClosure(builtin_library, internal_library); |
| |
| Log::Print("Creating main string\n"); |
| Dart_Handle main_name = Dart_NewStringFromCString("main"); |
| DART_CHECK_VALID(main_name); |
| |
| Log::Print("---- Invoking main() ----\n"); |
| status = Dart_Invoke(library, main_name, 0, NULL); |
| DART_CHECK_VALID(status); |
| Log::Print("---- main() returned ----\n"); |
| |
| Log::Print("Exiting Scope\n"); |
| Dart_ExitScope(); |
| Log::Print("Shutting down the isolate\n"); |
| Dart_ShutdownIsolate(); |
| |
| Log::Print("Calling Dart_Cleanup\n"); |
| error = Dart_Cleanup(); |
| if (error != NULL) { |
| FATAL1("VM Cleanup failed: %s\n", error); |
| } |
| |
| Log::Print("Success!\n"); |
| return 0; |
| } |
| |
| } // namespace bin |
| } // namespace dart |
| |
| int main(void) { |
| return dart::bin::Main(); |
| } |