OpenChess

Code: Select all

    
    // When using Standard C input functions, also check if there
    // is anything in the buffer. After a call to such functions,
    // the input waiting in the pipe will be copied to the buffer,
    // and the call to PeekNamedPipe can indicate no input available.
    // Setting stdin to unbuffered was not enough. [from Greko]
    if (stdin->_cnt > 0)
        return 1;

Code: Select all

        if (    (bestValue >= beta || vt == VALUE_TYPE_EXACT)
            && !pos.move_is_capture_or_promotion(move))
        {
            update_history(pos, move, depth, movesSearched, moveCount);
            update_killers(move, ss);
        }

Code: Select all

int InputAvailable()
{
        DWORD nchars;

        /* When using Standard C input functions, also check if there
        is anything in the buffer. After a call to such functions,
        the input waiting in the pipe will be copied to the buffer,
        and the call to PeekNamedPipe can indicate no input available.
        Setting stdin to unbuffered was not enough, IIRC */

        if (stdin->_cnt > 0)
                return 1;

        if (is_pipe)
        {
                /* When running under a GUI, you will end here. */

                if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))

                        /* Something went wrong. Probably the parent program exited.
                                Could call exit() here. Returning 1 will make the next call
                                to the input function return EOF, where this should be
                                catched then. */

                        return 1;

                return (nchars != 0);
        }
        else
                return _kbhit() != 0; /* In "text-mode" without GUI */

Code: Select all

bool input_available() {

#if defined(_WIN32) || defined(_WIN64)

   static bool init = false, is_pipe;
   static HANDLE stdin_h;
   DWORD val, error;

   // val = 0; // needed to make the compiler happy?

   // have a look at the "local" buffer first, *this time before init (no idea if it helps)*

   if (UseDebug && !init) printf("info string init=%d stdin->_cnt=%d\n",int(init),stdin->_cnt);

   if (stdin->_cnt > 0) return true; // HACK: assumes FILE internals

   // input init (only done once)

   if (!init) {

      init = true;

      stdin_h = GetStdHandle(STD_INPUT_HANDLE);

      if (UseDebug && (stdin_h == NULL || stdin_h == INVALID_HANDLE_VALUE)) {
         error = GetLastError();
         printf("info string GetStdHandle() failed, error=%d\n",error);
      }

      is_pipe = !GetConsoleMode(stdin_h,&val); // HACK: assumes pipe on failure

      if (UseDebug) printf("info string init=%d is_pipe=%d\n",int(init),int(is_pipe));

      if (UseDebug && is_pipe) { // GetConsoleMode() failed, everybody assumes pipe then
         error = GetLastError();
         printf("info string GetConsoleMode() failed, error=%d\n",error);
      }

      if (!is_pipe) {
         SetConsoleMode(stdin_h,val&~(ENABLE_MOUSE_INPUT|ENABLE_WINDOW_INPUT));
         FlushConsoleInputBuffer(stdin_h); // no idea if we can lose data doing this
      }
   }

   if (is_pipe) {

      if (!PeekNamedPipe(stdin_h,NULL,0,NULL,&val,NULL)) {

         if (UseDebug) { // PeekNamedPipe() failed, everybody assumes EOF then
            error = GetLastError();
            printf("info string PeekNamedPipe() failed, error=%d\n",error);
         }

         return true; // HACK: assumes EOF on failure
      }

      if (UseDebug && val < 0) printf("info string PeekNamedPipe(): val=%d\n",val);

      return val > 0; // != 0???

   } else {

      GetNumberOfConsoleInputEvents(stdin_h,&val);
      return val > 1; // no idea why 1
   }

   return false;

Code: Select all

void update_history(const Position& pos, Move move, Depth depth,
                     Move movesSearched[], int moveCount)
{
    Move m;
    H.success(pos.piece_on(move_from(move)), move_to(move), depth);
    for (int i = 0; i < moveCount - 1; i++)
    {
        m = movesSearched[i];
        assert(m != move); // FAILURE ?
        if (!pos.move_is_capture_or_promotion(m))
            H.failure(pos.piece_on(move_from(m)), move_to(m), depth); } }