samples/lineprocessor.cc - v8/v8.git - Git at Google

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <v8.h>

 #ifdef ENABLE_DEBUGGER_SUPPORT
 #include <v8-debug.h>
 #endif  // ENABLE_DEBUGGER_SUPPORT

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

 /**
  * This sample program should demonstrate certain aspects of debugging
  * standalone V8-based application.
  *
  * The program reads input stream, processes it line by line and print
  * the result to output. The actual processing is done by custom JavaScript
  * script. The script is specified with command line parameters.
  *
  * The main cycle of the program will sequentially read lines from standard
  * input, process them and print to standard output until input closes.
  * There are 2 possible configuration in regard to main cycle.
  *
  * 1. The main cycle is on C++ side. Program should be run with
  * --main-cycle-in-cpp option. Script must declare a function named
  * "ProcessLine". The main cycle in C++ reads lines and calls this function
  * for processing every time. This is a sample script:

 function ProcessLine(input_line) {
   return ">>>" + input_line + "<<<";
 }

  *
  * 2. The main cycle is in JavaScript. Program should be run with
  * --main-cycle-in-js option. Script gets run one time at all and gets
  * API of 2 global functions: "read_line" and "print". It should read input
  * and print converted lines to output itself. This a sample script:

 while (true) {
   var line = read_line();
   if (!line) {
     break;
   }
   var res = line + " | " + line;
   print(res);
 }

  *
  * When run with "-p" argument, the program starts V8 Debugger Agent and
  * allows remote debugger to attach and debug JavaScript code.
  *
  * Interesting aspects:
  * 1. Wait for remote debugger to attach
  * Normally the program compiles custom script and immediately runs it.
  * If programmer needs to debug script from the very beginning, he should
  * run this sample program with "--wait-for-connection" command line parameter.
  * This way V8 will suspend on the first statement and wait for
  * debugger to attach.
  *
  * 2. Unresponsive V8
  * V8 Debugger Agent holds a connection with remote debugger, but it does
  * respond only when V8 is running some script. In particular, when this program
  * is waiting for input, all requests from debugger get deferred until V8
  * is called again. See how "--callback" command-line parameter in this sample
  * fixes this issue.
  */

 enum MainCycleType {
   CycleInCpp,
   CycleInJs
 };

 const char* ToCString(const v8::String::Utf8Value& value);
 void ReportException(v8::Isolate* isolate, v8::TryCatch* handler);
 v8::Handle<v8::String> ReadFile(const char* name);
 v8::Handle<v8::String> ReadLine();

 void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
 void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args);
 bool RunCppCycle(v8::Handle<v8::Script> script,
                  v8::Local<v8::Context> context,
                  bool report_exceptions);


 #ifdef ENABLE_DEBUGGER_SUPPORT
 v8::Persistent<v8::Context> debug_message_context;

 void DispatchDebugMessages() {
   // We are in some random thread. We should already have v8::Locker acquired
   // (we requested this when registered this callback). We was called
   // because new debug messages arrived; they may have already been processed,
   // but we shouldn't worry about this.
   //
   // All we have to do is to set context and call ProcessDebugMessages.
   //
   // We should decide which V8 context to use here. This is important for
   // "evaluate" command, because it must be executed some context.
   // In our sample we have only one context, so there is nothing really to
   // think about.
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate, debug_message_context);
   v8::Context::Scope scope(context);

   v8::Debug::ProcessDebugMessages();
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT


 int RunMain(int argc, char* argv[]) {
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);

   v8::Handle<v8::String> script_source;
   v8::Handle<v8::Value> script_name;
   int script_param_counter = 0;

 #ifdef ENABLE_DEBUGGER_SUPPORT
   int port_number = -1;
   bool wait_for_connection = false;
   bool support_callback = false;
 #endif  // ENABLE_DEBUGGER_SUPPORT

   MainCycleType cycle_type = CycleInCpp;

   for (int i = 1; i < argc; i++) {
     const char* str = argv[i];
     if (strcmp(str, "-f") == 0) {
       // Ignore any -f flags for compatibility with the other stand-
       // alone JavaScript engines.
       continue;
     } else if (strcmp(str, "--main-cycle-in-cpp") == 0) {
       cycle_type = CycleInCpp;
     } else if (strcmp(str, "--main-cycle-in-js") == 0) {
       cycle_type = CycleInJs;
 #ifdef ENABLE_DEBUGGER_SUPPORT
     } else if (strcmp(str, "--callback") == 0) {
       support_callback = true;
     } else if (strcmp(str, "--wait-for-connection") == 0) {
       wait_for_connection = true;
     } else if (strcmp(str, "-p") == 0 && i + 1 < argc) {
       port_number = atoi(argv[i + 1]);  // NOLINT
       i++;
 #endif  // ENABLE_DEBUGGER_SUPPORT
     } else if (strncmp(str, "--", 2) == 0) {
       printf("Warning: unknown flag %s.\nTry --help for options\n", str);
     } else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
       script_source = v8::String::New(argv[i + 1]);
       script_name = v8::String::New("unnamed");
       i++;
       script_param_counter++;
     } else {
       // Use argument as a name of file to load.
       script_source = ReadFile(str);
       script_name = v8::String::New(str);
       if (script_source.IsEmpty()) {
         printf("Error reading '%s'\n", str);
         return 1;
       }
       script_param_counter++;
     }
   }

   if (script_param_counter == 0) {
     printf("Script is not specified\n");
     return 1;
   }
   if (script_param_counter != 1) {
     printf("Only one script may be specified\n");
     return 1;
   }

   // Create a template for the global object.
   v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();

   // Bind the global 'print' function to the C++ Print callback.
   global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print));

   if (cycle_type == CycleInJs) {
     // Bind the global 'read_line' function to the C++ Print callback.
     global->Set(v8::String::New("read_line"),
                 v8::FunctionTemplate::New(ReadLine));
   }

   // Create a new execution environment containing the built-in
   // functions
   v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global);
   // Enter the newly created execution environment.
   v8::Context::Scope context_scope(context);

 #ifdef ENABLE_DEBUGGER_SUPPORT
   debug_message_context.Reset(isolate, context);

   v8::Locker locker(isolate);

   if (support_callback) {
     v8::Debug::SetDebugMessageDispatchHandler(DispatchDebugMessages, true);
   }

   if (port_number != -1) {
     v8::Debug::EnableAgent("lineprocessor", port_number, wait_for_connection);
   }
 #endif  // ENABLE_DEBUGGER_SUPPORT

   bool report_exceptions = true;

   v8::Handle<v8::Script> script;
   {
     // Compile script in try/catch context.
     v8::TryCatch try_catch;
     script = v8::Script::Compile(script_source, script_name);
     if (script.IsEmpty()) {
       // Print errors that happened during compilation.
       if (report_exceptions)
         ReportException(isolate, &try_catch);
       return 1;
     }
   }

   {
     v8::TryCatch try_catch;

     script->Run();
     if (try_catch.HasCaught()) {
       if (report_exceptions)
         ReportException(isolate, &try_catch);
       return 1;
     }
   }

   if (cycle_type == CycleInCpp) {
     bool res = RunCppCycle(script,
                            isolate->GetCurrentContext(),
                            report_exceptions);
     return !res;
   } else {
     // All is already done.
   }
   return 0;
 }


 bool RunCppCycle(v8::Handle<v8::Script> script,
                  v8::Local<v8::Context> context,
                  bool report_exceptions) {
   v8::Isolate* isolate = context->GetIsolate();
 #ifdef ENABLE_DEBUGGER_SUPPORT
   v8::Locker lock(isolate);
 #endif  // ENABLE_DEBUGGER_SUPPORT

   v8::Handle<v8::String> fun_name = v8::String::New("ProcessLine");
   v8::Handle<v8::Value> process_val = context->Global()->Get(fun_name);

   // If there is no Process function, or if it is not a function,
   // bail out
   if (!process_val->IsFunction()) {
     printf("Error: Script does not declare 'ProcessLine' global function.\n");
     return 1;
   }

   // It is a function; cast it to a Function
   v8::Handle<v8::Function> process_fun =
       v8::Handle<v8::Function>::Cast(process_val);


   while (!feof(stdin)) {
     v8::HandleScope handle_scope(isolate);

     v8::Handle<v8::String> input_line = ReadLine();
     if (input_line == v8::Undefined()) {
       continue;
     }

     const int argc = 1;
     v8::Handle<v8::Value> argv[argc] = { input_line };

     v8::Handle<v8::Value> result;
     {
       v8::TryCatch try_catch;
       result = process_fun->Call(isolate->GetCurrentContext()->Global(),
                                  argc, argv);
       if (try_catch.HasCaught()) {
         if (report_exceptions)
           ReportException(isolate, &try_catch);
         return false;
       }
     }
     v8::String::Utf8Value str(result);
     const char* cstr = ToCString(str);
     printf("%s\n", cstr);
   }

   return true;
 }


 int main(int argc, char* argv[]) {
   v8::V8::InitializeICU();
   int result = RunMain(argc, argv);
   v8::V8::Dispose();
   return result;
 }


 // Extracts a C string from a V8 Utf8Value.
 const char* ToCString(const v8::String::Utf8Value& value) {
   return *value ? *value : "<string conversion failed>";
 }


 // Reads a file into a v8 string.
 v8::Handle<v8::String> ReadFile(const char* name) {
   FILE* file = fopen(name, "rb");
   if (file == NULL) return v8::Handle<v8::String>();

   fseek(file, 0, SEEK_END);
   int size = ftell(file);
   rewind(file);

   char* chars = new char[size + 1];
   chars[size] = '\0';
   for (int i = 0; i < size;) {
     int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
     i += read;
   }
   fclose(file);
   v8::Handle<v8::String> result = v8::String::New(chars, size);
   delete[] chars;
   return result;
 }


 void ReportException(v8::Isolate* isolate, v8::TryCatch* try_catch) {
   v8::HandleScope handle_scope(isolate);
   v8::String::Utf8Value exception(try_catch->Exception());
   const char* exception_string = ToCString(exception);
   v8::Handle<v8::Message> message = try_catch->Message();
   if (message.IsEmpty()) {
     // V8 didn't provide any extra information about this error; just
     // print the exception.
     printf("%s\n", exception_string);
   } else {
     // Print (filename):(line number): (message).
     v8::String::Utf8Value filename(message->GetScriptResourceName());
     const char* filename_string = ToCString(filename);
     int linenum = message->GetLineNumber();
     printf("%s:%i: %s\n", filename_string, linenum, exception_string);
     // Print line of source code.
     v8::String::Utf8Value sourceline(message->GetSourceLine());
     const char* sourceline_string = ToCString(sourceline);
     printf("%s\n", sourceline_string);
     // Print wavy underline (GetUnderline is deprecated).
     int start = message->GetStartColumn();
     for (int i = 0; i < start; i++) {
       printf(" ");
     }
     int end = message->GetEndColumn();
     for (int i = start; i < end; i++) {
       printf("^");
     }
     printf("\n");
   }
 }


 // The callback that is invoked by v8 whenever the JavaScript 'print'
 // function is called.  Prints its arguments on stdout separated by
 // spaces and ending with a newline.
 void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
   bool first = true;
   for (int i = 0; i < args.Length(); i++) {
     v8::HandleScope handle_scope(args.GetIsolate());
     if (first) {
       first = false;
     } else {
       printf(" ");
     }
     v8::String::Utf8Value str(args[i]);
     const char* cstr = ToCString(str);
     printf("%s", cstr);
   }
   printf("\n");
   fflush(stdout);
 }


 // The callback that is invoked by v8 whenever the JavaScript 'read_line'
 // function is called. Reads a string from standard input and returns.
 void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() > 0) {
     v8::ThrowException(v8::String::New("Unexpected arguments"));
     return;
   }
   args.GetReturnValue().Set(ReadLine());
 }


 v8::Handle<v8::String> ReadLine() {
   const int kBufferSize = 1024 + 1;
   char buffer[kBufferSize];

   char* res;
   {
 #ifdef ENABLE_DEBUGGER_SUPPORT
     v8::Unlocker unlocker(v8::Isolate::GetCurrent());
 #endif  // ENABLE_DEBUGGER_SUPPORT
     res = fgets(buffer, kBufferSize, stdin);
   }
   if (res == NULL) {
     v8::Handle<v8::Primitive> t = v8::Undefined();
     return v8::Handle<v8::String>::Cast(t);
   }
   // Remove newline char
   for (char* pos = buffer; *pos != '\0'; pos++) {
     if (*pos == '\n') {
       *pos = '\0';
       break;
     }
   }
   return v8::String::New(buffer);
 }
	// Copyright 2012 the V8 project authors. All rights reserved.
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following
	// disclaimer in the documentation and/or other materials provided
	// with the distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived
	// from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#include <v8.h>

	#ifdef ENABLE_DEBUGGER_SUPPORT
	#include <v8-debug.h>
	#endif // ENABLE_DEBUGGER_SUPPORT

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

	/**
	* This sample program should demonstrate certain aspects of debugging
	* standalone V8-based application.
	*
	* The program reads input stream, processes it line by line and print
	* the result to output. The actual processing is done by custom JavaScript
	* script. The script is specified with command line parameters.
	*
	* The main cycle of the program will sequentially read lines from standard
	* input, process them and print to standard output until input closes.
	* There are 2 possible configuration in regard to main cycle.
	*
	* 1. The main cycle is on C++ side. Program should be run with
	* --main-cycle-in-cpp option. Script must declare a function named
	* "ProcessLine". The main cycle in C++ reads lines and calls this function
	* for processing every time. This is a sample script:

	function ProcessLine(input_line) {
	return ">>>" + input_line + "<<<";
	}

	*
	* 2. The main cycle is in JavaScript. Program should be run with
	* --main-cycle-in-js option. Script gets run one time at all and gets
	* API of 2 global functions: "read_line" and "print". It should read input
	* and print converted lines to output itself. This a sample script:

	while (true) {
	var line = read_line();
	if (!line) {
	break;
	}
	var res = line + " \| " + line;
	print(res);
	}

	*
	* When run with "-p" argument, the program starts V8 Debugger Agent and
	* allows remote debugger to attach and debug JavaScript code.
	*
	* Interesting aspects:
	* 1. Wait for remote debugger to attach
	* Normally the program compiles custom script and immediately runs it.
	* If programmer needs to debug script from the very beginning, he should
	* run this sample program with "--wait-for-connection" command line parameter.
	* This way V8 will suspend on the first statement and wait for
	* debugger to attach.
	*
	* 2. Unresponsive V8
	* V8 Debugger Agent holds a connection with remote debugger, but it does
	* respond only when V8 is running some script. In particular, when this program
	* is waiting for input, all requests from debugger get deferred until V8
	* is called again. See how "--callback" command-line parameter in this sample
	* fixes this issue.
	*/

	enum MainCycleType {
	CycleInCpp,
	CycleInJs
	};

	const char* ToCString(const v8::String::Utf8Value& value);
	void ReportException(v8::Isolate* isolate, v8::TryCatch* handler);
	v8::Handle<v8::String> ReadFile(const char* name);
	v8::Handle<v8::String> ReadLine();

	void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
	void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args);
	bool RunCppCycle(v8::Handle<v8::Script> script,
	v8::Local<v8::Context> context,
	bool report_exceptions);


	#ifdef ENABLE_DEBUGGER_SUPPORT
	v8::Persistent<v8::Context> debug_message_context;

	void DispatchDebugMessages() {
	// We are in some random thread. We should already have v8::Locker acquired
	// (we requested this when registered this callback). We was called
	// because new debug messages arrived; they may have already been processed,
	// but we shouldn't worry about this.
	//
	// All we have to do is to set context and call ProcessDebugMessages.
	//
	// We should decide which V8 context to use here. This is important for
	// "evaluate" command, because it must be executed some context.
	// In our sample we have only one context, so there is nothing really to
	// think about.
	v8::Isolate* isolate = v8::Isolate::GetCurrent();
	v8::HandleScope handle_scope(isolate);
	v8::Local<v8::Context> context =
	v8::Local<v8::Context>::New(isolate, debug_message_context);
	v8::Context::Scope scope(context);

	v8::Debug::ProcessDebugMessages();
	}
	#endif // ENABLE_DEBUGGER_SUPPORT


	int RunMain(int argc, char* argv[]) {
	v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
	v8::Isolate* isolate = v8::Isolate::GetCurrent();
	v8::HandleScope handle_scope(isolate);

	v8::Handle<v8::String> script_source;
	v8::Handle<v8::Value> script_name;
	int script_param_counter = 0;

	#ifdef ENABLE_DEBUGGER_SUPPORT
	int port_number = -1;
	bool wait_for_connection = false;
	bool support_callback = false;
	#endif // ENABLE_DEBUGGER_SUPPORT

	MainCycleType cycle_type = CycleInCpp;

	for (int i = 1; i < argc; i++) {
	const char* str = argv[i];
	if (strcmp(str, "-f") == 0) {
	// Ignore any -f flags for compatibility with the other stand-
	// alone JavaScript engines.
	continue;
	} else if (strcmp(str, "--main-cycle-in-cpp") == 0) {
	cycle_type = CycleInCpp;
	} else if (strcmp(str, "--main-cycle-in-js") == 0) {
	cycle_type = CycleInJs;
	#ifdef ENABLE_DEBUGGER_SUPPORT
	} else if (strcmp(str, "--callback") == 0) {
	support_callback = true;
	} else if (strcmp(str, "--wait-for-connection") == 0) {
	wait_for_connection = true;
	} else if (strcmp(str, "-p") == 0 && i + 1 < argc) {
	port_number = atoi(argv[i + 1]); // NOLINT
	i++;
	#endif // ENABLE_DEBUGGER_SUPPORT
	} else if (strncmp(str, "--", 2) == 0) {
	printf("Warning: unknown flag %s.\nTry --help for options\n", str);
	} else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
	script_source = v8::String::New(argv[i + 1]);
	script_name = v8::String::New("unnamed");
	i++;
	script_param_counter++;
	} else {
	// Use argument as a name of file to load.
	script_source = ReadFile(str);
	script_name = v8::String::New(str);
	if (script_source.IsEmpty()) {
	printf("Error reading '%s'\n", str);
	return 1;
	}
	script_param_counter++;
	}
	}

	if (script_param_counter == 0) {
	printf("Script is not specified\n");
	return 1;
	}
	if (script_param_counter != 1) {
	printf("Only one script may be specified\n");
	return 1;
	}

	// Create a template for the global object.
	v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();

	// Bind the global 'print' function to the C++ Print callback.
	global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print));

	if (cycle_type == CycleInJs) {
	// Bind the global 'read_line' function to the C++ Print callback.
	global->Set(v8::String::New("read_line"),
	v8::FunctionTemplate::New(ReadLine));
	}

	// Create a new execution environment containing the built-in
	// functions
	v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global);
	// Enter the newly created execution environment.
	v8::Context::Scope context_scope(context);

	#ifdef ENABLE_DEBUGGER_SUPPORT
	debug_message_context.Reset(isolate, context);

	v8::Locker locker(isolate);

	if (support_callback) {
	v8::Debug::SetDebugMessageDispatchHandler(DispatchDebugMessages, true);
	}

	if (port_number != -1) {
	v8::Debug::EnableAgent("lineprocessor", port_number, wait_for_connection);
	}
	#endif // ENABLE_DEBUGGER_SUPPORT

	bool report_exceptions = true;

	v8::Handle<v8::Script> script;
	{
	// Compile script in try/catch context.
	v8::TryCatch try_catch;
	script = v8::Script::Compile(script_source, script_name);
	if (script.IsEmpty()) {
	// Print errors that happened during compilation.
	if (report_exceptions)
	ReportException(isolate, &try_catch);
	return 1;
	}
	}

	{
	v8::TryCatch try_catch;

	script->Run();
	if (try_catch.HasCaught()) {
	if (report_exceptions)
	ReportException(isolate, &try_catch);
	return 1;
	}
	}

	if (cycle_type == CycleInCpp) {
	bool res = RunCppCycle(script,
	isolate->GetCurrentContext(),
	report_exceptions);
	return !res;
	} else {
	// All is already done.
	}
	return 0;
	}


	bool RunCppCycle(v8::Handle<v8::Script> script,
	v8::Local<v8::Context> context,
	bool report_exceptions) {
	v8::Isolate* isolate = context->GetIsolate();
	#ifdef ENABLE_DEBUGGER_SUPPORT
	v8::Locker lock(isolate);
	#endif // ENABLE_DEBUGGER_SUPPORT

	v8::Handle<v8::String> fun_name = v8::String::New("ProcessLine");
	v8::Handle<v8::Value> process_val = context->Global()->Get(fun_name);

	// If there is no Process function, or if it is not a function,
	// bail out
	if (!process_val->IsFunction()) {
	printf("Error: Script does not declare 'ProcessLine' global function.\n");
	return 1;
	}

	// It is a function; cast it to a Function
	v8::Handle<v8::Function> process_fun =
	v8::Handle<v8::Function>::Cast(process_val);


	while (!feof(stdin)) {
	v8::HandleScope handle_scope(isolate);

	v8::Handle<v8::String> input_line = ReadLine();
	if (input_line == v8::Undefined()) {
	continue;
	}

	const int argc = 1;
	v8::Handle<v8::Value> argv[argc] = { input_line };

	v8::Handle<v8::Value> result;
	{
	v8::TryCatch try_catch;
	result = process_fun->Call(isolate->GetCurrentContext()->Global(),
	argc, argv);
	if (try_catch.HasCaught()) {
	if (report_exceptions)
	ReportException(isolate, &try_catch);
	return false;
	}
	}
	v8::String::Utf8Value str(result);
	const char* cstr = ToCString(str);
	printf("%s\n", cstr);
	}

	return true;
	}


	int main(int argc, char* argv[]) {
	v8::V8::InitializeICU();
	int result = RunMain(argc, argv);
	v8::V8::Dispose();
	return result;
	}


	// Extracts a C string from a V8 Utf8Value.
	const char* ToCString(const v8::String::Utf8Value& value) {
	return value ? value : "<string conversion failed>";
	}


	// Reads a file into a v8 string.
	v8::Handle<v8::String> ReadFile(const char* name) {
	FILE* file = fopen(name, "rb");
	if (file == NULL) return v8::Handle<v8::String>();

	fseek(file, 0, SEEK_END);
	int size = ftell(file);
	rewind(file);

	char* chars = new char[size + 1];
	chars[size] = '\0';
	for (int i = 0; i < size;) {
	int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
	i += read;
	}
	fclose(file);
	v8::Handle<v8::String> result = v8::String::New(chars, size);
	delete[] chars;
	return result;
	}


	void ReportException(v8::Isolate* isolate, v8::TryCatch* try_catch) {
	v8::HandleScope handle_scope(isolate);
	v8::String::Utf8Value exception(try_catch->Exception());
	const char* exception_string = ToCString(exception);
	v8::Handle<v8::Message> message = try_catch->Message();
	if (message.IsEmpty()) {
	// V8 didn't provide any extra information about this error; just
	// print the exception.
	printf("%s\n", exception_string);
	} else {
	// Print (filename):(line number): (message).
	v8::String::Utf8Value filename(message->GetScriptResourceName());
	const char* filename_string = ToCString(filename);
	int linenum = message->GetLineNumber();
	printf("%s:%i: %s\n", filename_string, linenum, exception_string);
	// Print line of source code.
	v8::String::Utf8Value sourceline(message->GetSourceLine());
	const char* sourceline_string = ToCString(sourceline);
	printf("%s\n", sourceline_string);
	// Print wavy underline (GetUnderline is deprecated).
	int start = message->GetStartColumn();
	for (int i = 0; i < start; i++) {
	printf(" ");
	}
	int end = message->GetEndColumn();
	for (int i = start; i < end; i++) {
	printf("^");
	}
	printf("\n");
	}
	}


	// The callback that is invoked by v8 whenever the JavaScript 'print'
	// function is called. Prints its arguments on stdout separated by
	// spaces and ending with a newline.
	void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
	bool first = true;
	for (int i = 0; i < args.Length(); i++) {
	v8::HandleScope handle_scope(args.GetIsolate());
	if (first) {
	first = false;
	} else {
	printf(" ");
	}
	v8::String::Utf8Value str(args[i]);
	const char* cstr = ToCString(str);
	printf("%s", cstr);
	}
	printf("\n");
	fflush(stdout);
	}


	// The callback that is invoked by v8 whenever the JavaScript 'read_line'
	// function is called. Reads a string from standard input and returns.
	void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
	if (args.Length() > 0) {
	v8::ThrowException(v8::String::New("Unexpected arguments"));
	return;
	}
	args.GetReturnValue().Set(ReadLine());
	}


	v8::Handle<v8::String> ReadLine() {
	const int kBufferSize = 1024 + 1;
	char buffer[kBufferSize];

	char* res;
	{
	#ifdef ENABLE_DEBUGGER_SUPPORT
	v8::Unlocker unlocker(v8::Isolate::GetCurrent());
	#endif // ENABLE_DEBUGGER_SUPPORT
	res = fgets(buffer, kBufferSize, stdin);
	}
	if (res == NULL) {
	v8::Handle<v8::Primitive> t = v8::Undefined();
	return v8::Handle<v8::String>::Cast(t);
	}
	// Remove newline char
	for (char* pos = buffer; *pos != '\0'; pos++) {
	if (*pos == '\n') {
	*pos = '\0';
	break;
	}
	}
	return v8::String::New(buffer);
	}