path: root/shell/igt-shell.cc

#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/utsname.h>
#include <unistd.h>

#include <iostream>
#include <fstream>
#include <sstream>

#include "v8.h"
#include "libplatform/libplatform.h"

#include "igt-shell.h"
#include "v8-helpers.h"

#include "../lib/version.h"
#include "../config.h"

using namespace v8;

static const char* ToCString(const String::Utf8Value& value) {
  return *value ? *value : "<invalid string>";
}

static void ReportException(Isolate* iso, TryCatch* try_catch)
{
  HandleScope handle_scope(iso);
  String::Utf8Value exception(iso, try_catch->Exception());
  const char* exception_string = ToCString(exception);

  Local<Message> message = try_catch->Message();
  if (message.IsEmpty()) {
    fprintf(stderr, "%s\n", exception_string);
  } else {
    String::Utf8Value filename(iso,
                               message->GetScriptOrigin().ResourceName());
    Local<Context> ctx(iso->GetCurrentContext());
    fprintf(stderr, "%s:%i: %s\n",
            ToCString(filename),
            message->GetLineNumber(ctx).FromJust(),
            exception_string);

    String::Utf8Value sourceline(iso,
                                 message->GetSourceLine(ctx).ToLocalChecked());
    fprintf(stderr, "%s\n", ToCString(sourceline));

    int start = message->GetStartColumn(ctx).FromJust();
    for (int i = 0; i < start; i++)
      fprintf(stderr, " ");
    int end = message->GetEndColumn(ctx).FromJust();
    for (int i = start; i < end; i++)
      fprintf(stderr, "^");
    fprintf(stderr, "\n");

    Local<Value> stack_trace_string;
    if (try_catch->StackTrace(ctx).ToLocal(&stack_trace_string) &&
        stack_trace_string->IsString() &&
        Local<String>::Cast(stack_trace_string)->Length() > 0) {
      String::Utf8Value stack_trace(iso, stack_trace_string);
      fprintf(stderr, "%s\n", ToCString(stack_trace));
    }
  }
}

static bool ExecuteString(Isolate* iso, Local<String> source,
                          Local<Value> name, bool print_result,
                          bool report_exceptions)
{
  HandleScope handle_scope(iso);
  TryCatch try_catch(iso);

  ScriptOrigin origin(name);
  Local<Context> ctx(iso->GetCurrentContext());
  Local<Script> script;
  if (!Script::Compile(ctx, source, &origin).ToLocal(&script)) {
    if (report_exceptions)
      ReportException(iso, &try_catch);
    return false;
  }

  Local<Value> result;
  if (!script->Run(ctx).ToLocal(&result)) {
    if (report_exceptions)
      ReportException(iso, &try_catch);
    return false;
  }

  if (print_result && !result->IsUndefined()) {
    String::Utf8Value str(iso, result);
    printf("%s\n", ToCString(str));
  }

  return true;
}

static void Print(const FunctionCallbackInfo<Value>& args)
{
  auto iso = args.GetIsolate();
  HandleScope handle_scope(iso);

  for (int i = 0; i < args.Length(); i++) {
    String::Utf8Value str(iso, args[i]);
    printf("%s%s", i ? " " : "", ToCString(str));
  }
  printf("\n");
  fflush(stdout);
}

static MaybeLocal<String> ReadStream(Isolate* iso, std::istream &in)
{
  std::stringstream out;
  out << in.rdbuf();
  std::string str = out.str();
  return String::NewFromUtf8(iso, str.c_str(), NewStringType::kNormal,
                             str.length());
}


MaybeLocal<String> ReadFile(Isolate* iso, const char* filename)
{
  std::ifstream stream(filename);
  if (!stream)
    iso->ThrowException(AsString(iso, "Error opening file").ToLocalChecked());

  return ReadStream(iso, stream);
}

static void Read(const FunctionCallbackInfo<Value>& args)
{
  auto iso = args.GetIsolate();

  if (args.Length() != 1) {
    iso->ThrowException(AsString(iso, "Bad parameters").ToLocalChecked());
    return;
  }

  String::Utf8Value filename(iso, args[0]);
  if (*filename == NULL) {
    iso->ThrowException(AsString(iso, "Bad parameters").ToLocalChecked());
    return;
  }

  Local<String> source;
  if (!ReadFile(iso, *filename).ToLocal(&source)) {
    iso->ThrowException(AsString(iso, "Error reading file").ToLocalChecked());
    return;
  }

  args.GetReturnValue().Set(source);
}

static void Load(const FunctionCallbackInfo<Value>& args)
{
  auto iso = args.GetIsolate();

  for (int i = 0; i < args.Length(); i++) {
    HandleScope handle_scope(iso);
    String::Utf8Value filename(iso, args[i]);
    if (*filename == NULL) {
      iso->ThrowException(AsString(iso, "Bad parameters").ToLocalChecked());
      return;
    }

    Local<String> source;
    if (!ReadFile(iso, *filename).ToLocal(&source)) {
      iso->ThrowException(AsString(iso, "Error loading file").ToLocalChecked());
      return;
    }

    if (!ExecuteString(iso, source, args[i], false, false)) {
      iso->ThrowException(AsString(iso, "Error executing file").ToLocalChecked());
      return;
    }
  }
}

static void Quit(const FunctionCallbackInfo<Value>& args)
{
  int exit_code =
      args[0]->Int32Value(args.GetIsolate()->GetCurrentContext()).FromMaybe(0);
  fflush(stdout);
  fflush(stderr);
  exit(exit_code);
}

static struct igt_builtin *globals;

void igt_register_global(struct igt_builtin *b)
{
  b->next = globals;
  globals = b;
}

static void shell_template(Isolate *iso, Local<ObjectTemplate> global)
{
  static const v8_helper_fn funcs[] = {
    { "print", Print },
    { "read", Read },
    { "load", Load },
    { "quit", Quit },
    { },
  };
  v8_helper_funcs(iso, global, funcs);
}

static Local<Context> ShellContext(Isolate* iso)
{
  Local<ObjectTemplate> global = ObjectTemplate::New(iso);

  shell_template(iso, global); /* XXX defer to shell */
  for (auto *b = globals; b; b = b->next)
	  b->ctor(iso, global);

  return Context::New(iso, NULL, global);
}

static void print_welcome()
{
  struct utsname uts;

  uname(&uts);
  printf("IGT Version: %s-%s (%s) (%s: %s %s)\n",
         PACKAGE_VERSION, IGT_GIT_SHA1, TARGET_CPU_PLATFORM,
         uts.sysname, uts.release, uts.machine);
  printf("V8: %s\n", V8::GetVersion());
}

static int do_eval(Isolate *iso, Platform *p, const char *str)
{
  Handle<String> filename = AsString(iso, "eval").ToLocalChecked();
  Handle<String> source = AsString(iso, str).ToLocalChecked();

  bool success = ExecuteString(iso, source, filename, false, true);
  while (platform::PumpMessageLoop(p, iso))
          ;

  return !success;
}

static int run(Isolate *iso, Platform *p, int argc, char **argv)
{
  while (++optind < argc) {
    HandleScope handle_scope(iso);
    const char *str = argv[optind];

    Local<String> source;
    if (!strcmp(str, "-")) {
      if (!ReadStream(iso, std::cin).ToLocal(&source)) {
        fprintf(stderr, "Error reading '%s'\n", str);
        return 1;
      }
    } else {
      if (!ReadFile(iso, str).ToLocal(&source)) {
        fprintf(stderr, "Error reading '%s'\n", str);
        return 1;
      }
    }

    Local<String> filename = AsString(iso, str).ToLocalChecked();
    if (!ExecuteString(iso, source, filename, true, true))
      return 1;

    while (platform::PumpMessageLoop(p, iso))
      ;
  }

  return 0;
}

static int shell(Isolate *iso, Platform *p, int argc, char **argv)
{
  print_welcome();

  HandleScope outer(iso);
  Local<String> name(AsString(iso, "(shell)").ToLocalChecked());

  while (true) {
    char buf[256];

    printf("igt> ");
    char *str = fgets(buf, sizeof(buf), stdin);
    if (!str)
	    break;

    HandleScope inner(iso);
    ExecuteString(iso,
                  AsString(iso, str).ToLocalChecked(),
                  name, true, true);

    while (platform::PumpMessageLoop(p, iso))
      ;
  }
  printf("\n");

  return 0;
}

int main(int argc, char* argv[])
{
  V8::InitializeICUDefaultLocation(argv[0]);
  V8::InitializeExternalStartupData(argv[0]);

  std::unique_ptr<Platform> p = platform::NewDefaultPlatform();
  V8::InitializePlatform(p.get());

  V8::Initialize();
  V8::SetFlagsFromCommandLine(&argc, argv, true);

  Isolate::CreateParams create_params;
  create_params.array_buffer_allocator =
      ArrayBuffer::Allocator::NewDefaultAllocator();
  Isolate *iso = Isolate::New(create_params);

  int err, opt;

  {
    Isolate::Scope isolate_scope(iso);
    HandleScope handle_scope(iso);
    Local<Context> ctx = ShellContext(iso);
    if (ctx.IsEmpty()) {
      fprintf(stderr, "Error creating ctx\n");
      return 1;
    }

    Context::Scope context_scope(ctx);
    while ((opt = getopt(argc, argv, "e:")) != -1) {
      switch (opt) {
      case 'e':
        if (do_eval(iso, p.get(), optarg)) {
          err = 1;
          goto err;
        }
        break;
      }
    }
    if (optind < argc) {
      static const struct target {
        const char *name;
        int (*fn)(Isolate*, Platform*, int argc, char **argv);
      } targets[] = {
        { "shell", shell },
        { "run", run },
        { }
      };
      for (typeof(*targets) *t = targets; t->name; t++) {
        if (!strcmp(argv[optind], t->name)) {
          err = t->fn(iso, p.get(), argc, argv);
          goto err;
        }
      }
      fprintf(stderr, "Unrecognised command '%s'\n", argv[optind]);
    } else {
      err = shell(iso, p.get(), 0, NULL);
    }
  }

err:
  iso->Dispose();
  V8::Dispose();
  V8::ShutdownPlatform();
  delete create_params.array_buffer_allocator;

  return err;
}