WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom/VM/virtualmachine.cpp

 /***************************************************************************
  *   Copyright (C) December 10, 2008 by Mattias Runge                             *
  *   mattias@runge.se                                                      *
  *   virtualmachine.cpp                                            *
  *                                                                         *
  *   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.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 #include "virtualmachine.h"
 VirtualMachine* VirtualMachine::myInstance = NULL;
 VirtualMachine& VirtualMachine::getInstance()
+{
     if (myInstance == NULL)
+    {
         myInstance = new VirtualMachine();
+    }
     return *myInstance;
+}
 void VirtualMachine::deleteInstance()
+{
     if (myInstance != NULL)
+    {
         delete myInstance;
         myInstance = NULL;
+    }
+}
 VirtualMachine::VirtualMachine()
+{
     Thread<VirtualMachine>();
+}
 VirtualMachine::~VirtualMachine()
+{
     stop();
+}
 void VirtualMachine::run()
+{
     SyslogStream &slog = SyslogStream::getInstance();
     string basePath = Settings::get("BasePath") + "Services/";
     string scriptName = "Base.js";
     string scriptFileName = basePath + "System/" + scriptName;
     if (!file_exists(scriptFileName))
+    {
         slog << "Failed to load :" + scriptFileName + "\n";
+    }
     string scriptSource = file_get_contents(scriptFileName);
     Handle<String> source =  String::New(scriptSource.c_str(), scriptSource.length());
     //each script name must be unique , for this demo I just run one embedded script, so the name can be fixed
     Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
     // Create a template for the global object.
     myGlobal = ObjectTemplate::New();
     //associates "print" on script to the Print function
     myGlobal->Set(String::New("log"), FunctionTemplate::New(VirtualMachine_log));
     myGlobal->Set(String::New("sendCanMessage"), FunctionTemplate::New(VirtualMachine_sendCanMessage));
     myGlobal->Set(String::New("sendCanNMTMessage"), FunctionTemplate::New(VirtualMachine_sendCanNMTMessage));
     myGlobal->Set(String::New("loadScript"), FunctionTemplate::New(VirtualMachine_loadScript));
     myGlobal->Set(String::New("startIntervalThread"), FunctionTemplate::New(VirtualMachine_startIntervalThread));
     myGlobal->Set(String::New("stopIntervalThread"), FunctionTemplate::New(VirtualMachine_stopIntervalThread));
     myGlobal->Set(String::New("startSocketThread"), FunctionTemplate::New(VirtualMachine_startSocketThread));
     myGlobal->Set(String::New("stopSocketThread"), FunctionTemplate::New(VirtualMachine_stopSocketThread));
     myGlobal->Set(String::New("sendToSocketThread"), FunctionTemplate::New(VirtualMachine_sendToSocketThread));
     myGlobal->Set(String::New("uint2hex"), FunctionTemplate::New(VirtualMachine_uint2hex));
     //create context for the script
     myContext = Context::New(NULL, myGlobal);
     //access global context within this scope
     Context::Scope context_scope(myContext);
     //exception handler
-    TryCatch try_catch;
+    TryCatch tryCatch;
     //compile script to binary code - JIT
     Handle<Script> script = Script::Compile(source, name);
     //check if we got problems on compilation
     if (script.IsEmpty())
+    {
-        // Print errors that happened during compilation.
-        String::AsciiValue error(try_catch.Exception());
+        printException(&tryCatch);
-        string sError = *error;
+        slog << "\n";
-        slog << "Failed to compile script: " + sError + "\n";
+        return;
+    }
     else
+    {
         //no errors , let's continue
         Handle<Value> result = script->Run();
         //check if execution ended with errors
         if (result.IsEmpty())
+        {
-            // Print errors that happened during execution.
-            String::AsciiValue error(try_catch.Exception());
+            printException(&tryCatch);
-            string sError = *error;
+            slog << "\n";
-            slog << "Constructor: Failed to run script: " << sError << "\n";
+            return;
+        }
         else
+        {
             loadScript("System/Startup.js");
             if (file_exists(basePath + "Autostart.js"))
+            {
                 loadScript("Autostart.js");
+            }
             myFunctionHandleNMTMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleNMTMessage")));
             myFunctionOfflineCheck = Handle<Function>::Cast(myContext->Global()->Get(String::New("offlineCheck")));
             myFunctionHandleMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleMessage")));
             myFunctionStartup = Handle<Function>::Cast(myContext->Global()->Get(String::New("startup")));
+        }
+    }
     const int argc = 0;
     Handle<Value> argv[argc] = { };
     Handle<Value> result = myFunctionStartup->Call(myFunctionStartup, argc, argv); // argc and argv are your standard arguments to a function
     mySemaphore.lock();
     while (1)
+    {
         string expression;
         while (myExpressions.size() > 0)
+        {
             expression = myExpressions.pop();
             runExpression(expression);
+        }
         CanMessage canMessage;
         while (myCanMessages.size() > 0)
+        {
             canMessage = myCanMessages.pop();
             if (canMessage.getClassName() == "nmt")
+            {
                 callHandleNMTMessage(canMessage);
+            }
             else
+            {
                 callHandleMessage(canMessage);
             }
         }
         mySemaphore.wait();
+    }
     mySemaphore.unlock();
+}
 void VirtualMachine::queueCanMessage(CanMessage canMessage)
 {
     myCanMessages.push(canMessage);
     mySemaphore.broadcast();
 }
 void VirtualMachine::queueExpression(string expression)
+{
     myExpressions.push(expression);
     mySemaphore.broadcast();
+}
 bool VirtualMachine::loadScript(string scriptName)
 {
     SyslogStream &slog = SyslogStream::getInstance();
     string basePath = Settings::get("BasePath") + "Services/";
     string scriptFileName = basePath + scriptName;
     if (!file_exists(scriptFileName))
+    {
         slog << "Failed to load " + scriptFileName + "\n";
         return false;
     }
-    string scriptSource = file_get_contents(scriptFileName);
-    Handle<String> source =  String::New(scriptSource.c_str(), scriptSource.length());
-    //each script name must be unique , for this demo I just run one embedded script, so the name can be fixed
-    Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
-    //access global context within this scope
-    Context::Scope context_scope(myContext);
-    //exception handler
-    TryCatch try_catch;
-    //compile script to binary code - JIT
-    Handle<Script> script = Script::Compile(source, name);
-    //check if we got problems on compilation
-    if (script.IsEmpty())
-    {
-        // Print errors that happened during compilation.
-        String::AsciiValue error(try_catch.Exception());
-        string sError = *error;
-        slog << "loadScript: Failed to compile script: " + sError + "\n";
-        return false;
-    }
-    else
-    {
-        //no errors , let's continue
-        Handle<Value> result = script->Run();
-        //check if execution ended with errors
-        if (result.IsEmpty())
-        {
-            // Print errors that happened during execution.
-            String::AsciiValue error(try_catch.Exception());
-            string sError = *error;
-            slog << "loadScript: Failed to run script: " + sError + "\n";
-            return false;
-        }
+    string scriptSource = file_get_contents(scriptFileName);
+    Handle<String> source =  String::New(scriptSource.c_str(), scriptSource.length());
+    //each script name must be unique , for this demo I just run one embedded script, so the name can be fixed
+    Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
+    //access global context within this scope
+    Context::Scope context_scope(myContext);
+    //exception handler
+    TryCatch tryCatch;
+    //compile script to binary code - JIT
+    Handle<Script> script = Script::Compile(source, name);
+    //check if we got problems on compilation
+    if (script.IsEmpty())
+    {
+        printException(&tryCatch);
+        slog << "\n";
+        return false;
+    }
+    else
+    {
+        //no errors , let's continue
+        Handle<Value> result = script->Run();
+        //check if execution ended with errors
+        if (result.IsEmpty())
+        {
+            printException(&tryCatch);
+            slog << "\n";
+            return false;
+        }
         slog << "Loaded " + scriptName + "\n";
     }
     return true;
+}
 void VirtualMachine::callHandleNMTMessage(CanMessage canMessage)
+{
     const int argc = 3;
     string jsonData = canMessage.getJSONData();
     Handle<Value> argv[argc] = {String::New(canMessage.getClassName().c_str()),
                                 String::New(canMessage.getCommandName().c_str()),
                                 String::New(jsonData.c_str()) };
     Handle<Value> result = myFunctionHandleNMTMessage->Call(myFunctionHandleNMTMessage, argc, argv); // argc and argv are your standard arguments to a function
+}
 void VirtualMachine::callHandleMessage(CanMessage canMessage)
+{
     const int argc = 6;
     string jsonData = canMessage.getJSONData();
     Handle<Value> argv[argc] = {String::New(canMessage.getClassName().c_str()),
                                 String::New(canMessage.getDirectionFlag().c_str()),
                                 String::New(canMessage.getModuleName().c_str()),
                                 Integer::New(canMessage.getModuleId()),
                                 String::New(canMessage.getCommandName().c_str()),
                                 String::New(jsonData.c_str()) };
     Handle<Value> result = myFunctionHandleMessage->Call(myFunctionHandleMessage, argc, argv); // argc and argv are your standard arguments to a function
+}
 unsigned int VirtualMachine::startIntervalThread(unsigned int timeout)
+{
     IntervalThread intervalThread(timeout);
     myIntervalThreads[intervalThread.getId()] = intervalThread;
     myIntervalThreads[intervalThread.getId()].start();
     return intervalThread.getId();
+}
 bool VirtualMachine::stopIntervalThread(unsigned int id)
+{
     if (myIntervalThreads.find(id) != myIntervalThreads.end())
+    {
         myIntervalThreads.erase(id);
         return true;
+    }
     return false;
+}
 unsigned int VirtualMachine::startSocketThread(string address, int port, unsigned int reconnectTimeout)
+{
     SocketThread *socketThread = new SocketThread(address, port, reconnectTimeout);
     mySocketThreads[socketThread->getId()] = socketThread;
     mySocketThreads[socketThread->getId()]->start();
     return socketThread->getId();
+}
 bool VirtualMachine::stopSocketThread(unsigned int id)
+{
     if (mySocketThreads.find(id) != mySocketThreads.end())
+    {
         //mySocketThreads[id]->stop();
         delete mySocketThreads[id];
         mySocketThreads.erase(id);
         return true;
+    }
     return false;
+}
 void VirtualMachine::sendToSocketThread(unsigned int id, string data)
+{
     if (mySocketThreads.find(id) != mySocketThreads.end())
+    {
         mySocketThreads[id]->send(data);
+    }
+}
 bool VirtualMachine::runExpression(string expression)
 {
     SyslogStream &slog = SyslogStream::getInstance();
     string scriptName = "runExpression";
     Handle<String> source =  String::New(expression.c_str(), expression.length());
     //each script name must be unique , for this demo I just run one embedded script, so the name can be fixed
     Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
     //access global context within this scope
     Context::Scope context_scope(myContext);
     //exception handler
-    TryCatch try_catch;
+    TryCatch tryCatch;
     //compile script to binary code - JIT
     Handle<Script> script = Script::Compile(source, name);
     //check if we got problems on compilation
     if (script.IsEmpty())
     {
-        // Print errors that happened during compilation.
-        String::AsciiValue error(try_catch.Exception());
-        string sError = *error;
+        printException(&tryCatch);
-        slog << "runExpression: Failed to compile script: " + sError + "\n";
-        slog << expression << "\n\n";
+        slog << "\n";
         return false;
+    }
     else
+    {
         //no errors , let's continue
         Handle<Value> result = script->Run();
         //check if execution ended with errors
         if (result.IsEmpty())
+        {
-            // Print errors that happened during execution.
-            String::AsciiValue error(try_catch.Exception());
+            printException(&tryCatch);
-            string sError = *error;
+            slog << "\n";
-            slog << "runExpression: Failed to run script: " + sError + "\n";
             return false;
         }
     }
     return true;
+}
+void VirtualMachine::printException(TryCatch* tryCatch)
+{
+    SyslogStream &slog = SyslogStream::getInstance();
+    HandleScope handle_scope;
+    String::Utf8Value exception(tryCatch->Exception());
+    Handle<v8::Message> message = tryCatch->Message();
+    string strException = *exception;
+    if (message.IsEmpty())
+    {
+        // V8 didn't provide any extra information about this error; just print the exception.
+        slog << strException + "\n";
+    }
+    else
+    {
+        // Print (filename):(line number): (message).
+        String::Utf8Value filename(message->GetScriptResourceName());
+        int linenum = message->GetLineNumber();
+        string strFilename = *filename;
+        slog << strFilename + ":" + itos(linenum) + ": " + strException + "\n";
+        // Print line of source code.
+        String::Utf8Value sourceline(message->GetSourceLine());
+        string strSourceline = *sourceline;
+        slog << strSourceline + "\n";
+        string underline;
+        // Print wavy underline (GetUnderline is deprecated).
+        int start = message->GetStartColumn();
+        for (int i = 0; i < start; i++)
+        {
+            underline += " ";
+        }
+        int end = message->GetEndColumn();
+        for (int i = start; i < end; i++)
+        {
+            underline += "^";
+        }
+        slog << underline + "\n";
+    }
+}
 Handle<Value> VirtualMachine_log(const Arguments& args)
+{
     SyslogStream &slog = SyslogStream::getInstance();
     String::AsciiValue str(args[0]);
     slog << *str;
     return Undefined();
+}
 Handle<Value> VirtualMachine_sendCanMessage(const Arguments& args)
+{
     //SyslogStream &slog = SyslogStream::getInstance();
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     String::AsciiValue className(args[0]);
     canMessage.setClassName(*className);
     String::AsciiValue directionFlag(args[1]);
     canMessage.setDirectionFlag(*directionFlag);
     String::AsciiValue moduleName(args[2]);
     canMessage.setModuleName(*moduleName);
     canMessage.setModuleId(args[3]->Uint32Value());
     String::AsciiValue commandName(args[4]);
     canMessage.setCommandName(*commandName);
     String::AsciiValue dataString(args[5]);
     vector<string> parts = explode(",", trim(*dataString, ','));
     map<string, CanVariable> data;
     for (int n = 0; n < parts.size(); n++)
+    {
         vector<string> keyAndValue = explode(":", parts[n]);
         //string key = trim(keyAndValue[0], ' ');
         //string value = trim(keyAndValue[1], ' ');
         data[keyAndValue[0]] = CanVariable(keyAndValue[0], keyAndValue[1]);
+    }
     canMessage.setData(data);
     canMan.sendMessage(canMessage);
     return Undefined();
+}
 Handle<Value> VirtualMachine_sendCanNMTMessage(const Arguments& args)
+{
     //SyslogStream &slog = SyslogStream::getInstance();
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     String::AsciiValue className(args[0]);
     canMessage.setClassName(*className);
     String::AsciiValue commandName(args[1]);
     canMessage.setCommandName(*commandName);
     String::AsciiValue dataString(args[2]);
     vector<string> parts = explode(",", trim(*dataString, ','));
     map<string, CanVariable> data;
     for (int n = 0; n < parts.size(); n++)
+    {
         vector<string> keyAndValue = explode(":", parts[n]);
         //string key = trim(keyAndValue[0], ' ');
         //string value = trim(keyAndValue[1], ' ');
         data[keyAndValue[0]] = CanVariable(keyAndValue[0], keyAndValue[1]);
+    }
     canMessage.setData(data);
     canMan.sendMessage(canMessage);
     return Undefined();
+}
 Handle<Value> VirtualMachine_loadScript(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue str(args[0]);
     return Boolean::New(vm.loadScript(*str));
+}
 Handle<Value> VirtualMachine_startIntervalThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     unsigned int timeout = args[0]->Uint32Value();
     return Integer::New(vm.startIntervalThread(timeout));
+}
 Handle<Value> VirtualMachine_stopIntervalThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     unsigned int id = args[0]->Uint32Value();
     return Boolean::New(vm.stopIntervalThread(id));
+}
 Handle<Value> VirtualMachine_startSocketThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue address(args[0]);
     int port = args[1]->Uint32Value();
     unsigned int reconnectTimeout = args[2]->Uint32Value();
     return Integer::New(vm.startSocketThread(*address, port, reconnectTimeout));
+}
 Handle<Value> VirtualMachine_stopSocketThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     unsigned int id = args[0]->Uint32Value();
     return Boolean::New(vm.stopSocketThread(id));
+}
 Handle<Value> VirtualMachine_sendToSocketThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     unsigned int id = args[0]->Uint32Value();
     String::AsciiValue data(args[1]);
     vm.sendToSocketThread(id, *data);
     return Undefined();
+}
 Handle<Value> VirtualMachine_uint2hex(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     unsigned int id = args[0]->Uint32Value();
     unsigned int length = args[1]->Uint32Value();
     string hexId = uint2hex(id, length);
     return String::New(hexId.c_str());
+}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/VM/virtualmachine.cpp @ 995 – Rev 986 → 995