/*
*
* Copyright (C) 2010 Mattias Runge
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
#include "Manager.h"
#include <fstream>
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
namespace atom {
namespace vm {
Manager::Pointer Manager::instance_;
Manager::Manager() : LOG("vm::Manager")
{
}
Manager::~Manager()
{
this->io_service_.stop();
this->plugins_.clear();
this->context_.Dispose();
for (ImportFunctionList::iterator it = this->functions_.begin(); it != this->functions_.end(); it++)
{
it->second.Dispose();
}
}
void Manager::Create()
{
Manager::instance_ = Manager::Pointer(new Manager());
}
Manager::Pointer Manager::Instance()
{
return Manager::instance_;
}
void Manager::Delete()
{
Manager::instance_.reset();
}
void Manager::AddPlugin(Plugin::Pointer plugin)
{
this->plugins_[plugin->GetName()] = plugin;
}
void Manager::Start(std::string script_path)
{
this->script_path_ = script_path;
this->io_service_.post(boost::bind(&Manager::StartHandler, this));
}
void Manager::Call(std::string name, ArgumentListPointer arguments)
{
this->io_service_.post(boost::bind(&Manager::CallHandler, this, name, arguments));
}
bool Manager::LoadScript(std::string scriptname)
{
this->io_service_.post(boost::bind(&Manager::LoadScriptHandler, this, scriptname));
}
void Manager::CallHandler(std::string name, ArgumentListPointer arguments)
{
v8::Context::Scope context_scope(this->context_);
v8::TryCatch try_catch;
if (this->functions_.find(name) == this->functions_.end())
{
LOG.Error("No such function found, " + name);
return;
}
Value result = this->functions_[name]->Call(this->context_->Global(), arguments->size(), arguments->data());
if (result.IsEmpty())
{
LOG.Error(this->FormatException(try_catch));
}
}
void Manager::StartHandler()
{
v8::Handle<v8::ObjectTemplate> raw_template = v8::ObjectTemplate::New();
for (PluginList::iterator it = this->plugins_.begin(); it != this->plugins_.end(); it++)
{
ExportFunctionList export_functions = it->second->GetExportFunctions();
for (ExportFunctionList::iterator it = export_functions.begin(); it != export_functions.end(); it++)
{
raw_template->Set(v8::String::New(it->first.data()), v8::FunctionTemplate::New(it->second));
}
}
this->context_ = v8::Context::New(NULL, raw_template);
v8::Context::Scope context_scope(this->context_);
for (PluginList::iterator it = this->plugins_.begin(); it != this->plugins_.end(); it++)
{
std::string scriptname = "plugin/" + it->first + ".js";
if (this->LoadScriptHandler(scriptname))
{
FunctionNameList import_functions = it->second->GetImportFunctionNames();
for (unsigned int n = 0; n < import_functions.size(); n++)
{
v8::Handle<v8::String> process_name = v8::String::New(import_functions[n].data());
v8::Handle<v8::Value> process_val = this->context_->Global()->Get(process_name);
if (!process_val->IsFunction())
{
LOG.Error(import_functions[n] + " was not found to be a function!");
continue;
}
v8::Handle<v8::Function> process_fun = v8::Handle<v8::Function>::Cast(process_val);
this->functions_[import_functions[n]] = v8::Persistent<v8::Function>::New(process_fun);
}
}
}
this->object_template_ = v8::Persistent<v8::ObjectTemplate>::New(raw_template);
LOG.Info("VM initialized.");
for (PluginList::iterator it = this->plugins_.begin(); it != this->plugins_.end(); it++)
{
it->second->InitializeDone();
}
}
bool Manager::LoadScriptHandler(std::string scriptname)
{
std::string path = this->script_path_ + scriptname;
std::ifstream file(path.data());
if (!file.is_open())
{
file.close();
LOG.Warning("Could not load " + scriptname + ".");
return false;
}
std::string code = "";
std::string line;
while (!file.eof())
{
std::getline(file, line);
if (file.eof())
{
break;
}
code += line + "\n";
}
file.close();
v8::Context::Scope context_scope(this->context_);
v8::TryCatch try_catch;
v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(code.data(), code.length()),
v8::String::New(scriptname.data(), scriptname.length()));
if (script.IsEmpty())
{
LOG.Error(this->FormatException(try_catch));
false;
}
else
{
Value result = script->Run();
if (result.IsEmpty())
{
LOG.Error(this->FormatException(try_catch));
false;
}
}
LOG.Info("Loaded " + scriptname + " successfully!");
return true;
}
std::string Manager::FormatException(v8::TryCatch& try_catch)
{
std::string result;
v8::HandleScope handle_scope;
v8::String::Utf8Value exception(try_catch.Exception());
v8::Handle<v8::Message> message = try_catch.Message();
if (message.IsEmpty())
{
result = *exception;
}
else
{
v8::String::Utf8Value filename(message->GetScriptResourceName());
result = std::string(*filename) + ":" + boost::lexical_cast<std::string>(message->GetLineNumber()) + ": " + std::string(*exception);
/*v8::String::Utf8Value sourceline(message->GetSourceLine());
string strSourceline = *sourceline;
result += strSourceline + "\n";
string underline = rpad("", message->GetStartColumn(), ' ');
underline = rpad(underline, message->GetEndColumn(), '^');
result += underline + "\n";*/
}
return result;
}
}; // namespace vm
}; // namespace atom