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

  *   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 <map>
 #include "virtualmachine.h"
 VirtualMachine* VirtualMachine::myInstance = NULL;
+    {
         myInstance = new VirtualMachine();
+    }
     return *myInstance;
 }
 void VirtualMachine::deleteInstance()
+{
     if (myInstance != NULL)
+    {
         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";
+    }
     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("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);
 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 basePath = Settings::get("BasePath") + "Services/";
     string scriptFileName = basePath + scriptName;
     if (!file_exists(scriptFileName))
     {
-        slog << "Failed to load :" + scriptFileName + "\n";
+        slog << "Failed to load " + scriptFileName + "\n";
         return false;
+    }
     string scriptSource = file_get_contents(scriptFileName);
     Handle<String> source =  String::New(scriptSource.c_str(), scriptSource.length());
     //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();
+        {
             // 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;
         }
         slog << "Loaded " + scriptName + "\n";
     }
     return true;
 }
 void VirtualMachine::callHandleHeartbeat(int hardwareId)
 {
     const int argc = 1;
     Handle<Value> argv[argc] = { Integer::New(hardwareId) };
     Handle<Value> result = myFunctionHandleHeartbeat->Call(myFunctionHandleHeartbeat, 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(canMessage.getJSONData().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)
             String::AsciiValue error(try_catch.Exception());
             string sError = *error;
             slog << "runExpression: Failed to run script: " + sError + "\n";
             return false;
+        }
     }
     return true;
+}
 Handle<Value> VirtualMachine_log(const Arguments& args)
     String::AsciiValue str(args[0]);
     slog << *str;
     return Undefined();
 }
 Handle<Value> VirtualMachine_sendCanMessage(const Arguments& args)
+{
     //SyslogStream &slog = SyslogStream::getInstance();
     CanNetManager &canMan = CanNetManager::getInstance();
     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();
-    String::AsciiValue data(args[1]);
+    unsigned int length = args[1]->Uint32Value();
-    vm.sendToSocketThread(id, *data);
+    string hexId = uint2hex(id, length);
-    return Undefined();
+    return String::New(hexId.c_str());
+}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/VM/virtualmachine.cpp @ 981 – Rev 977 → 981