X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=engine.cpp;h=f5c53c673a7f8d8f179d58bd0543591b813d1d3f;hb=8c255c15cc55a2e5254152c8e07a8ab45b22b7af;hp=b5429d9d207721dced494e618c7a6c8ea1630075;hpb=64f72f31685ea1dff12b19b22cfaf7a53ccc079f;p=polyglot.git

diff --git a/engine.cpp b/engine.cpp
index b5429d9..f5c53c6 100644
--- a/engine.cpp
+++ b/engine.cpp
@@ -11,6 +11,7 @@
 #include <cstring>
 
 #include <sys/types.h>
+#include <sys/resource.h>
 #include <unistd.h>
 
 #include "engine.h"
@@ -21,7 +22,7 @@
 
 // constants
 
-static const int StringSize = 4096;
+static const unsigned int StringSize = 4096;
 
 // variables
 
@@ -123,10 +124,9 @@ void engine_open(engine_t * engine) {
 
       // set a low priority
 
-      if (option_get_bool("UseNice"))
-      {
+      if (option_get_bool("UseNice")) {
           my_log("POLYGLOT Adjust Engine Piority");
-          nice(+option_get_int("NiceValue"));
+          nice(option_get_int("NiceValue"));
       }
 
       // change the current directory
@@ -159,18 +159,57 @@ void engine_open(engine_t * engine) {
       engine->io->in_fd = from_engine[0];
       engine->io->out_fd = to_engine[1];
       engine->io->name = "Engine";
+      engine->pid=pid;
+      engine->state|=ENGINE_ACTIVE; // can we test if this really true?
 
       io_init(engine->io);
    }
 }
 
+// engine_active
+
+bool engine_active(engine_t *engine){
+    return (engine->state & ENGINE_ACTIVE)!=0;
+}
+
+// engine_eof
+
+bool engine_eof(engine_t *engine){
+    return (engine->state & ENGINE_EOF)!=0;
+}
+
+// engine_set_nice_value()
+
+void engine_set_nice_value(engine_t * engine, int value){
+    setpriority(PRIO_PROCESS,engine->pid,value);
+}
+
+
 // engine_close()
 
 void engine_close(engine_t * engine) {
 
    ASSERT(engine_is_ok(engine));
 
+   char string[StringSize];
    io_close(engine->io);
+       // TODO: timeout
+   while (!engine_eof(engine)) {
+       engine_get(engine,string,StringSize); 
+   }
+
+}
+
+// engine_get_non_blocking()
+
+bool engine_get_non_blocking(engine_t * engine, char string[], int size){
+    if(io_line_ready(engine->io)){
+        engine_get(engine,string,StringSize);
+        return true;
+    }else{
+        string[0]='\0';
+        return false;
+    }
 }
 
 // engine_get()
@@ -186,8 +225,7 @@ void engine_get(engine_t * engine, char string[], int size) {
    }
 
    if (!io_get_line(engine->io,string,size)) { // EOF
-       my_log("POLYGLOT *** EOF from Engine ***\n");
-      exit(EXIT_SUCCESS);
+       engine->state|=ENGINE_EOF;
    }
 }
 
@@ -304,67 +342,90 @@ IDLE_PRIORITY_CLASS         0x00000040
 
 void set_affinity(engine_t *engine, int affin){
 	if(affin==-1) return;
-    SetProcessAffinityMask((engine->pipeEngine).hProcess,affin);
+    SetProcessAffinityMask((engine->io).hProcess,affin);
 }
 
+// Eric Mullins!
+
+void engine_set_nice_value(engine_t *engine, int value){
+    SetPriorityClass((engine->io).hProcess,
+                     GetWin32Priority(value));
+}
 
 
 void engine_send_queue(engine_t * engine,const char *szFormat, ...) {
-  nQueuePtr += vsprintf(szQueueString + nQueuePtr, szFormat, (va_list) (&szFormat + 1));
+    nQueuePtr += vsprintf(szQueueString + nQueuePtr, szFormat, (va_list) (&szFormat + 1));
 }
 
 void engine_send(engine_t * engine, const char *szFormat, ...) {
     vsprintf(szQueueString + nQueuePtr, szFormat, (va_list) (&szFormat + 1));
-    (engine->pipeEngine).LineOutput(szQueueString);
+    (engine->io).LineOutput(szQueueString);
     my_log("Adapter->Engine: %s\n",szQueueString);
     nQueuePtr = 0;
 }
 
 void engine_close(engine_t * engine){
-    (engine->pipeEngine).Close();
+    char string[StringSize];
+    (engine->io).Close();
+        // TODO: Timeout
+    while (!engine_eof(Engine)) { 
+        engine_get_non_blocking(Engine,string,StringSize);
+        Idle();
+    }
+    (engine->io).Kill();
 }
 
 
 void engine_open(engine_t * engine){
-   int affinity;
+    int affinity;
     char *my_dir;
+    engine->state=0;
     if( (my_dir = _getcwd( NULL, 0 )) == NULL )
         my_fatal("Can't build path: %s\n",strerror(errno));
     SetCurrentDirectory(option_get_string("EngineDir"));
-    (engine->pipeEngine).Open(option_get_string("EngineCommand"));
-        //play with affinity (bad idea) 
-    affinity=option_get_int("Affinity");
-    if(affinity!=-1) set_affinity(engine,affinity); //AAA
-        //lets go back
-    SetCurrentDirectory(my_dir);
-        // set a low priority
-    if (option_get_bool("UseNice")){
-          my_log("POLYGLOT Adjust Engine Piority\n");
-          SetPriorityClass((engine->pipeEngine).hProcess,
-                           GetWin32Priority(option_get_int("NiceValue")));
+    (engine->io).Open(option_get_string("EngineCommand"));
+    if((engine->io).Active()){
+        engine->state|=ENGINE_ACTIVE;
+            //play with affinity (bad idea)
+        affinity=option_get_int("Affinity");
+        if(affinity!=-1) set_affinity(engine,affinity); //AAA
+            //lets go back
+        SetCurrentDirectory(my_dir);
+            // set a low priority
+        if (option_get_bool("UseNice")){
+            my_log("POLYGLOT Adjust Engine Piority\n");
+            engine_set_nice_value(engine, option_get_int("NiceValue"));
+        }
     }
     
 }
 
+bool engine_active(engine_t *engine){
+    return (engine->state & ENGINE_ACTIVE)!=0;
+}
+
+bool engine_eof(engine_t *engine){
+    return (engine->state & ENGINE_EOF)!=0;
+}
+
 bool engine_get_non_blocking(engine_t * engine, char *szLineStr, int size){
-	if ((engine->pipeEngine).LineInput(szLineStr)) {
+    if(engine_eof(engine)){ return false;}
+	if ((engine->io).GetBuffer(szLineStr)) {
         my_log("Engine->Adapter: %s\n",szLineStr);
         return true;
     } else {
         szLineStr[0]='\0';
+        if(engine->io.EOF_()){
+            engine->state|=ENGINE_EOF;
+        }
         return false;
     }
 }
 
 void engine_get(engine_t * engine, char *szLineStr, int size){
-    bool data_available;
-    while(true){
-        data_available=engine_get_non_blocking(engine,szLineStr,size);
-        if(!data_available){
-            Idle();
-        }else{
-            break;
-        }
+    (engine->io).LineInput(szLineStr);
+    if(engine->io.EOF_()){
+        engine->state|=ENGINE_EOF;
     }
 }