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

+    }
+}
 VirtualMachine::VirtualMachine()
+{
-    Thread<VirtualMachine>();
+}
 VirtualMachine::~VirtualMachine()
+{
     stop();
+    ///FIXME: Verify that this works and does not cause segfaults
+    for (map<int, SocketThread*>::iterator iter = mySocketThreads.begin(); iter != mySocketThreads.end(); iter++)
+    {
+        delete iter->second;
+        mySocketThreads.erase(iter);
+    }
 }
 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 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;
-    }
-    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;
-        }
-        else
-        {
-            loadScript("System/Startup.js");
+    if (loadScript("System/Base.js"))
-            if (file_exists(basePath + "Autostart.js"))
+    {
+        loadScript("System/Startup.js");
-                loadScript("Autostart.js");
+        loadScript("Autostart.js");
-            }
+        Context::Scope contextScope(myContext);
-            myFunctionHandleNMTMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleNMTMessage")));
+        myFunctionHandleNMTMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleNMTMessage")));
-            myFunctionOfflineCheck = Handle<Function>::Cast(myContext->Global()->Get(String::New("offlineCheck")));
+        myFunctionOfflineCheck = Handle<Function>::Cast(myContext->Global()->Get(String::New("offlineCheck")));
-            myFunctionHandleMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleMessage")));
+        myFunctionHandleMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleMessage")));
-            myFunctionStartup = Handle<Function>::Cast(myContext->Global()->Get(String::New("startup")));
+        myFunctionStartup = Handle<Function>::Cast(myContext->Global()->Get(String::New("startup")));
-        }
+    }
+    else
+    {
+        ///FIXME: We should probably exit the application here
+        return;
+    }
     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
+    Handle<Value> result = myFunctionStartup->Call(myFunctionStartup, argc, argv);
     mySemaphore.lock();
-    while (1)
-    {
-        string expression;
+    string expression;
+    CanMessage canMessage;
+    while (true)
+    {
         while (myExpressions.size() > 0)
+        {
             expression = myExpressions.pop();
+            runExpression(expression);
+        }
+        while (myCanMessages.size() > 0)
+        {
+            canMessage = myCanMessages.pop();
+            if (canMessage.getClassName() == "nmt")
+            {
+                expression = "handleNMTMessage(";
+                expression += "'" + canMessage.getClassName() + "', ";
+                expression += "'" + canMessage.getCommandName() + "', ";
+                expression += canMessage.getJSONData();
+                expression += ");";
+                runExpression(expression);
+            }
+            else
+            {
+                expression = "handleMessage(";
+                expression += "'" + canMessage.getClassName() + "', ";
+                expression += "'" + canMessage.getDirectionFlag() + "', ";
+                expression += "'" + canMessage.getModuleName() + "', ";
+                expression += "" + itos(canMessage.getModuleId()) + ", ";
+                expression += "'" + canMessage.getCommandName() + "', ";
+                expression += canMessage.getJSONData();
+                expression += ");";
-            runExpression(expression);
+                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();
+}
     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 + ", file does not exist.\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);
+    Context::Scope contextScope(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()) };
     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);
+    Context::Scope contextScope(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;
+        }
+    }
     return true;
 void VirtualMachine::printException(TryCatch* tryCatch)
+{
     SyslogStream &slog = SyslogStream::getInstance();
-    HandleScope handle_scope;
+    HandleScope handleScope;
     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";
+        slog << strException + "\n\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";
+        slog << strFilename + ":" + itos(message->GetLineNumber()) + ": " + 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();
+        string underline = rpad("", message->GetStartColumn(), ' ');
-        for (int i = 0; i < start; i++)
-        {
-            underline += " ";
-        }
-        int end = message->GetEndColumn();
+        underline = rpad(underline, message->GetEndColumn(), '^');
-        for (int i = start; i < end; i++)
-        {
-            underline += "^";
-        }
-        slog << underline + "\n";
+        slog << underline + "\n\n";
+    }
+}
 Handle<Value> VirtualMachine_log(const Arguments& args)
     return Undefined();
+}
 Handle<Value> VirtualMachine_sendCanMessage(const Arguments& args)
+{
-    //SyslogStream &slog = SyslogStream::getInstance();
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     String::AsciiValue className(args[0]);
     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);
     return Undefined();
+}
 Handle<Value> VirtualMachine_sendCanNMTMessage(const Arguments& args)
+{
-    //SyslogStream &slog = SyslogStream::getInstance();
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     String::AsciiValue className(args[0]);
     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);

Subversion Repositories HomeAutomation

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