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

     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));
     myGlobal->Set(String::New("loadDataStore"), FunctionTemplate::New(VirtualMachine::_loadDataStore));
     myGlobal->Set(String::New("getFileContents"), FunctionTemplate::New(VirtualMachine::_getFileContents));
+    myGlobal->Set(String::New("uint2hex"), FunctionTemplate::New(VirtualMachine::_uint2hex));
+    myGlobal->Set(String::New("hex2bin"), FunctionTemplate::New(VirtualMachine::_hex2bin));
+    myGlobal->Set(String::New("bin2hex"), FunctionTemplate::New(VirtualMachine::_bin2hex));
+    myGlobal->Set(String::New("bin2float"), FunctionTemplate::New(VirtualMachine::_bin2float));
+    myGlobal->Set(String::New("float2bin"), FunctionTemplate::New(VirtualMachine::_float2bin));
+    myGlobal->Set(String::New("bin2uint"), FunctionTemplate::New(VirtualMachine::_bin2uint));
+    myGlobal->Set(String::New("uint2bin"), FunctionTemplate::New(VirtualMachine::_uint2bin));
+    myGlobal->Set(String::New("hex2uint"), FunctionTemplate::New(VirtualMachine::_hex2uint));
     myContext = Context::New(NULL, myGlobal);
     if (loadScript("System/Base.js"))
+    {
     scriptSource = "DataStore.addStore('" + storeName + "', " + str_replace("\n", "", scriptSource) + ");";
     Handle<String> source =  String::New(scriptSource.c_str(), scriptSource.length());
     Handle<String> name = String::New(scriptFileName.c_str(), scriptFileName.length());
     Context::Scope contextScope(myContext);
     TryCatch tryCatch;
     Handle<Script> script = Script::Compile(source, name);
     if (script.IsEmpty())
     {
         slog << formatException(&tryCatch);
         return false;
     }
     else
     {
         Handle<Value> result = script->Run();
         if (result.IsEmpty())
         {
             slog << formatException(&tryCatch);
             return false;
         }
         slog << "Loaded datastore " + storeName + "\n";
     }
     return true;
+}
 bool VirtualMachine::loadScript(string scriptName)
+{
     string scriptFileName = basePath + scriptName;
     if (!file_exists(scriptFileName))
+    {
         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());
     Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
         if (result.IsEmpty())
+        {
             slog << formatException(&tryCatch);
             return false;
         }
         slog << "Loaded " + scriptName + "\n";
+    }
     return true;
     myIntervalThreads[intervalThread->getId()] = intervalThread;
     myIntervalThreads[intervalThread->getId()]->start();
     return intervalThread->getId();
 }
 bool VirtualMachine::stopIntervalThread(unsigned int id)
+{
     if (myIntervalThreads.find(id) != myIntervalThreads.end())
+    {
     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();
     if (mySocketThreads.find(id) != mySocketThreads.end())
+    {
         delete mySocketThreads[id];
         mySocketThreads.erase(id);
         return true;
     }
     return false;
+}
 void VirtualMachine::sendToSocketThread(unsigned int id, string data)
+{
+}
 void VirtualMachine::disconnectCommandClient(unsigned int id)
+{
     myCommandThread.disconnectClient(id);
 }
 void VirtualMachine::sendToCommandClient(unsigned int id, string data)
+{
     myCommandThread.sendTo(id, data);
+}
+    }
     else
+    {
         VirtualMachine &vm = VirtualMachine::getInstance();
         vm.sendToCommandClient(id, data);
     }
 }
 bool VirtualMachine::runExpression(Expression expression)
+{
     string scriptName = "runExpression";
     Handle<String> source =  String::New(scriptData.c_str(), scriptData.length());
     Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
     Context::Scope contextScope(myContext);
     TryCatch tryCatch;
     Handle<Script> script = Script::Compile(source, name);
     if (script.IsEmpty())
     {
         print(expression.getTargetId(), formatException(&tryCatch));
         return false;
+    }
     else
     {
         Handle<Value> result = script->Run();
         if (result.IsEmpty())
         {
             print(expression.getTargetId(), formatException(&tryCatch));
             return false;
+        }
         else if (expression.getTargetId() != 0)
+        {
              String::AsciiValue ascii(result);
              string resultString = *ascii;
              if (resultString != "undefined")
+             {
                 print(expression.getTargetId(), resultString + "\n");
+             }
         }
     }
     return true;
 }
 Handle<Value> VirtualMachine::_quit(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     vm.disconnectCommandClient(args[0]->Uint32Value());
     return Undefined();
+}
 Handle<Value> VirtualMachine::_log(const Arguments& args)
+{
     SyslogStream &slog = SyslogStream::getInstance();
     String::AsciiValue str(args[0]);
     slog << *str;
     return Undefined();
+}
 Handle<Value> VirtualMachine::_print(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
+{
     string bin = uint2bin(args[0]->Uint32Value(), args[1]->Uint32Value());
     return String::New(bin.c_str());
+}
+Handle<Value> VirtualMachine::_hex2uint(const Arguments& args)
+{
+    String::AsciiValue hex(args[0]);
+    unsigned int num = hex2uint(*hex);
+    return Uint32::New(num);
+}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/src/VM/virtualmachine.cpp @ 1885 – Rev 1010 → 1011