WebSVN – Games.Chess Giants – Diff – //chessengine.cpp

 #include "common.h"
+#include <fcntl.h>
+// definitions used in this module only
+#define RD 0
+#define WR 1
+#define CLOSE_PIPE(pipe) if (pipe[RD] != -1) _close (pipe[RD]); pipe[RD] = -1; if (pipe[WR] != -1) _close (pipe[WR]); pipe[WR] = -1
 // global variables used in this module only
 static wchar_t chessenginemodule_path[MAX_PATH];
 static wchar_t chessenginemodule_pathname[MAX_PATH];
 static wchar_t chessengineinitfile_pathname[MAX_PATH];
 static PROCESS_INFORMATION PlayerEngine_pi;
-static HANDLE hChessEngineStdinRd;
+static int chessgiants_to_engine[2]; // RD and WR
-static HANDLE hChessEngineStdinWr;
-static HANDLE hChessEngineStdoutRd;
+static int engine_to_chessgiants[2]; // RD and WR
-static HANDLE hChessEngineStdoutWr;
 static int current_obstinacy;
 static bool is_hint_pending;
 // prototypes of local functions
 static void PlayerEngine_Recv (player_t *player);
    // stdout are redirected to the handles we give it, so that we may read/write to it.
    engineprogram_t *program;
    wchar_t widechar_buffer[256];
    SYSTEM_INFO sysinfo;
+   HANDLE hStdOut[2] = { NULL, NULL };
+   HANDLE hStdIn[2] = { NULL, NULL };
    SECURITY_ATTRIBUTES saAttr;
    STARTUPINFO si;
    int try_index;
    FILE *fp;
    // reset stuff first
-   hChessEngineStdinRd = NULL;
-   hChessEngineStdinWr = NULL;
-   hChessEngineStdoutRd = NULL;
-   hChessEngineStdoutWr = NULL;
    player->wants_hint = false;
    // quick access to engine program
    program = &options.engine.programs[options.engine.selected_program];
    // build the chess engine module path and pathname
    swprintf_s (chessenginemodule_path, WCHAR_SIZEOF (chessenginemodule_path), L"%s/engines/%s", app_path, program->folder);
    swprintf_s (chessenginemodule_pathname, WCHAR_SIZEOF (chessenginemodule_pathname), L"%s/engines/%s/%s", app_path, program->folder, program->cmdline);
-   // prepare the pipes' security attributes
+   // build the I/O pipes
-   memset (&saAttr, 0, sizeof (saAttr));
+   memset (&saAttr, 0, sizeof (saAttr)); // prepare the pipes' security attributes
    saAttr.nLength = sizeof (SECURITY_ATTRIBUTES);
    saAttr.bInheritHandle = true; // set the bInheritHandle flag so pipe handles are inherited
-   // create a pipe for the child process's stdout
+   CreatePipe (&hStdIn[RD], &hStdIn[WR], &saAttr, 0); // create a pipe for the child process's stdin
-   CreatePipe (&hChessEngineStdoutRd, &hChessEngineStdoutWr, &saAttr, 0);
+   CreatePipe (&hStdOut[RD], &hStdOut[WR], &saAttr, 0); // create a pipe for the child process's stdout
+   SetHandleInformation (hStdIn[WR], HANDLE_FLAG_INHERIT, 0); // ensure the write handle to the pipe for STDIN is not inherited
-   SetHandleInformation (hChessEngineStdoutRd, HANDLE_FLAG_INHERIT, 0); // ensure the read handle to the pipe for STDOUT is not inherited
+   SetHandleInformation (hStdOut[RD], HANDLE_FLAG_INHERIT, 0); // ensure the read handle to the pipe for STDOUT is not inherited
-   // create a pipe for the child process's stdin
+   engine_to_chessgiants[RD] = _open_osfhandle ((intptr_t) hStdOut[RD], _O_BINARY);
+   engine_to_chessgiants[WR] = _open_osfhandle ((intptr_t) hStdOut[WR], _O_BINARY | _O_APPEND);
-   CreatePipe (&hChessEngineStdinRd, &hChessEngineStdinWr, &saAttr, 0);
+   chessgiants_to_engine[RD] = _open_osfhandle ((intptr_t) hStdIn[RD], _O_BINARY);
-   SetHandleInformation (hChessEngineStdinWr, HANDLE_FLAG_INHERIT, 0); // ensure the write handle to the pipe for STDIN is not inherited.
+   chessgiants_to_engine[WR] = _open_osfhandle ((intptr_t) hStdIn[WR], _O_BINARY | _O_APPEND);
    // spawn the chess engine process with redirected input and output
    memset (&si, 0, sizeof (si));
    si.cb = sizeof (STARTUPINFOA);
    si.dwFlags = STARTF_USESTDHANDLES;
-   si.hStdInput = hChessEngineStdinRd;
+   si.hStdInput = hStdIn[RD];
-   si.hStdOutput = hChessEngineStdoutWr;
+   si.hStdOutput = hStdOut[WR];
-   si.hStdError = hChessEngineStdoutWr;
+   si.hStdError = hStdOut[WR];
    if (!CreateProcess (chessenginemodule_pathname, // module pathname
                        program->cmdline, // command line
                        NULL, NULL,
                        true, // handles are inherited
                        CREATE_NO_WINDOW | DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP,
    // send the engine a quit command
    Player_SendBuffer_Add (player, 1000, options.engine.programs[options.engine.selected_program].command_quit);
    Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
    PlayerEngine_Send (player);
-   // close the pipe handles
+   // close the pipes
-   if (hChessEngineStdinRd)
-      CloseHandle (hChessEngineStdinRd);
+   CLOSE_PIPE (chessgiants_to_engine);
-   hChessEngineStdinRd = NULL;
-   if (hChessEngineStdinWr)
-      CloseHandle (hChessEngineStdinWr);
-   hChessEngineStdinWr = NULL;
-   if (hChessEngineStdoutRd)
-      CloseHandle (hChessEngineStdoutRd);
-   hChessEngineStdoutRd = NULL;
+   CLOSE_PIPE (engine_to_chessgiants);
-   if (hChessEngineStdoutWr)
-      CloseHandle (hChessEngineStdoutWr);
-   hChessEngineStdoutWr = NULL;
    // check 10 times if the engine process has ended cleanly
    for (attempt_index = 0; attempt_index < 10; attempt_index++)
+   {
       if (GetExitCodeProcess (PlayerEngine_pi.hProcess, &exit_code) && (exit_code != STILL_ACTIVE))
 static void PlayerEngine_Recv (player_t *player)
+{
    // helper function to read data from the pipe communicating with the game engine process
-   unsigned long amount_to_read;
+   //unsigned long amount_to_read;
    unsigned long read_count;
-   int byte_index;
-   int rewrite_index;
    int length;
    unsigned int initial_pos;
    // get reception buffer's initial end position
    initial_pos = wcslen (player->recvbuffer);
+   length = initial_pos;
-   // as long as the pipe reports us there is data to read...
+   // as long as the pipe reports us there is data to read, read one byte at a time
-   while (PeekNamedPipe (hChessEngineStdoutRd, NULL, 0, NULL, &amount_to_read, NULL) && (amount_to_read > 0))
+   while (!_eof (engine_to_chessgiants[RD]))
+   {
-      if (!ReadFile (hChessEngineStdoutRd, player->ascii_recvbuffer, min (amount_to_read, (unsigned long) player->recvbuffer_size - 1), &read_count, NULL))
+      read_count = _read (engine_to_chessgiants[RD], player->ascii_recvbuffer, 1);
+      if (read_count == 0)
          break; // read the pipe; if it fails, stop trying
+      if ((player->ascii_recvbuffer[0] == '\r') || (player->ascii_recvbuffer[0] == '%'))
+         continue; // ignore carriage returns and percent signs
-      // parse all received data and eradicate all carriage returns and percent signs
+      // convert the received character to wide char and append it to recvbuffer
-      rewrite_index = 0;
-      for (byte_index = 0; byte_index < (int) read_count; byte_index++)
-         if ((player->ascii_recvbuffer[byte_index] != '\r') && (player->ascii_recvbuffer[byte_index] != '%'))
-         {
-            player->ascii_recvbuffer[rewrite_index] = player->ascii_recvbuffer[byte_index];
-            rewrite_index++;
-         }
-      player->ascii_recvbuffer[rewrite_index] = 0; // terminate the buffer ourselves
+      player->ascii_recvbuffer[1] = 0; // terminate the received string ourselves
-      // convert to wide char and append it to recvbuffer
-      length = wcslen (player->recvbuffer);
       ConvertToWideChar (&player->recvbuffer[length], player->recvbuffer_size - length, player->ascii_recvbuffer);
+      length++; // there's one more character in the player's recv buffer
+   }
    // write what we received (if we received anything)
    if (wcslen (player->recvbuffer) > initial_pos)
       Debug_Log (L"===================================RECEIVED:===================================\n%s\n", &player->recvbuffer[initial_pos]);
    line_pointer = player->sendbuffer; // start at the first character
    while ((line_pointer = wcsgets (widechar_buffer, WCHAR_SIZEOF (widechar_buffer), line_pointer)) != NULL)
+   {
       wcscat_s (widechar_buffer, WCHAR_SIZEOF (widechar_buffer), L"\n"); // put the carriage return back
       ConvertTo7BitASCII (ascii_buffer, sizeof (ascii_buffer), widechar_buffer); // convert to ASCII
-      WriteFile (hChessEngineStdinWr, ascii_buffer, strlen (ascii_buffer), &amount_written, NULL); // send data
+      amount_written = _write (chessgiants_to_engine[WR], ascii_buffer, strlen (ascii_buffer)); // send data
+   }
    player->sendbuffer[0] = 0; // what we had to send has been sent, reset the send buffer
    player->sendbuffer_locked = false; // and unlock it

Subversion Repositories Games.Chess Giants

Games.Chess Giants//chessengine.cpp – Rev 140 → 149