WebSVN – Games.Chess Giants – Diff – //engine-crafty/utility.c

  *   on a single cache line rather than being split across two, assuming the   *
  *   structure is 64 bytes or less of course.                                  *
  *                                                                             *
  *******************************************************************************
  */
 void AlignedMalloc(void **pointer, int alignment, size_t size) {
   segments[nsegments][0] = malloc(size + alignment - 1);
   segments[nsegments][1] =
       (void *) (((uintptr_t) segments[nsegments][0] + alignment -
 ) & ~(alignment - 1));
+}
 /*
  *******************************************************************************
  *                                                                             *
- *   atoiKM() is used to read in an integer value that can have a "K" or "M"   *
+ *   atoiKMB() is used to read in an integer value that can have a "K" or "M"  *
  *   appended to it to multiply by 1024 or 1024*1024.  It returns a 64 bit     *
  *   value since memory sizes can exceed 4gb on modern hardware.               *
  *                                                                             *
  *******************************************************************************
  */
-uint64_t atoiKM(char *input) {
+uint64_t atoiKMB(char *input) {
   uint64_t size;
   size = atoi(input);
   if (strchr(input, 'K') || strchr(input, 'k'))
     size *= 1 << 10;
   if (strchr(input, 'M') || strchr(input, 'm'))
     size *= 1 << 20;
+  if (strchr(input, 'B') || strchr(input, 'b') || strchr(input, 'G') ||
+      strchr(input, 'g'))
+    size *= 1 << 30;
   return size;
+}
 /*
  *******************************************************************************
  *   AlignedRemalloc() is used to change the size of a memory block that has   *
  *   previously been allocated using AlignedMalloc().                          *
  *                                                                             *
  *******************************************************************************
  */
 void AlignedRemalloc(void **pointer, int alignment, size_t size) {
   int i;
   for (i = 0; i < nsegments; i++)
     if (segments[i][1] == *pointer)
       break;
   if (i == nsegments) {
     Print(4095, "ERROR  AlignedRemalloc() given an invalid pointer\n");
  *   without any endian issues.                                                *
  *                                                                             *
  *******************************************************************************
  */
 void BookClusterIn(FILE * file, int positions, BOOK_POSITION * buffer) {
-  char file_buffer[BOOK_CLUSTER_SIZE * BOOK_POSITION_SIZE];
   int i;
+  char file_buffer[BOOK_CLUSTER_SIZE * sizeof(BOOK_POSITION)];
-  fread(file_buffer, positions, BOOK_POSITION_SIZE, file);
+  i = fread(file_buffer, positions, sizeof(BOOK_POSITION), file);
+  if (i <= 0)
+    perror("BookClusterIn fread error: ");
   for (i = 0; i < positions; i++) {
     buffer[i].position =
-        BookIn64((unsigned char *) (file_buffer + i * BOOK_POSITION_SIZE));
+        BookIn64((unsigned char *) (file_buffer + i * sizeof(BOOK_POSITION)));
     buffer[i].status_played =
-        BookIn32((unsigned char *) (file_buffer + i * BOOK_POSITION_SIZE +
+        BookIn32((unsigned char *) (file_buffer + i * sizeof(BOOK_POSITION) +
 ));
     buffer[i].learn =
-        BookIn32f((unsigned char *) (file_buffer + i * BOOK_POSITION_SIZE +
+        BookIn32f((unsigned char *) (file_buffer + i * sizeof(BOOK_POSITION) +
 ));
+  }
+}
 /*
  *   Endian-independent.                                                       *
  *                                                                             *
  *******************************************************************************
  */
 void BookClusterOut(FILE * file, int positions, BOOK_POSITION * buffer) {
-  char file_buffer[BOOK_CLUSTER_SIZE * BOOK_POSITION_SIZE];
   int i;
+  char file_buffer[BOOK_CLUSTER_SIZE * sizeof(BOOK_POSITION)];
   for (i = 0; i < positions; i++) {
-    memcpy(file_buffer + i * BOOK_POSITION_SIZE,
+    memcpy(file_buffer + i * sizeof(BOOK_POSITION),
         BookOut64(buffer[i].position), 8);
-    memcpy(file_buffer + i * BOOK_POSITION_SIZE + 8,
+    memcpy(file_buffer + i * sizeof(BOOK_POSITION) + 8,
         BookOut32(buffer[i].status_played), 4);
-    memcpy(file_buffer + i * BOOK_POSITION_SIZE + 12,
+    memcpy(file_buffer + i * sizeof(BOOK_POSITION) + 12,
         BookOut32f(buffer[i].learn), 4);
+  }
-  fwrite(file_buffer, positions, BOOK_POSITION_SIZE, file);
+  fwrite(file_buffer, positions, sizeof(BOOK_POSITION), file);
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   BookIn32f() is used to convert 4 bytes from the book file into a valid 32 *
- *   bit binary value.  this eliminates endian worries that make the binary    *
+ *   bit binary value.  This eliminates endian worries that make the binary    *
  *   book non-portable across many architectures.                              *
  *                                                                             *
  *******************************************************************************
  */
 float BookIn32f(unsigned char *ch) {
   int i;
   static int init = 0, pipe;
   static HANDLE inh;
   DWORD dw;
-  if (!xboard && !_isatty(_fileno(stdin))) // Pierre-Marie Baty -- use ISO C++ conformant names
+  if (!xboard && !_isatty(_fileno(stdin))) // Pierre-Marie Baty -- ISO C++ names fix
     return 0;
   if (batch_mode)
     return 0;
   if (strchr(cmd_buffer, '\n'))
     return 1;
  *   search path information in it.                                            *
  *                                                                             *
  *******************************************************************************
  */
 void ClearHashTableScores(void) {
-  size_t i; // Pierre-Marie Baty -- fixed type
+  int i;
-  if (trans_ref)
+  if (hash_table)
-    for (i = 0; i < hash_table_size; i++) {
+    for (i = 0; i < (int)hash_table_size; i++) { // Pierre-Marie Baty -- added type cast
-      (trans_ref + i)->word2 ^= (trans_ref + i)->word1;
+      (hash_table + i)->word2 ^= (hash_table + i)->word1;
-      (trans_ref + i)->word1 =
+      (hash_table + i)->word1 =
-          ((trans_ref + i)->word1 & mask_clear_entry) | (uint64_t) 65536;
+          ((hash_table + i)->word1 & mask_clear_entry) | (uint64_t) 65536;
-      (trans_ref + i)->word2 ^= (trans_ref + i)->word1;
+      (hash_table + i)->word2 ^= (hash_table + i)->word1;
+    }
+}
 /* last modified 02/28/14 */
 /*
  */
 void CraftyExit(int exit_type) {
   int proc;
   for (proc = 1; proc < CPUS; proc++)
-    thread[proc].tree = (TREE *) - 1;
+    thread[proc].terminate = 1;
   while (smp_threads);
   exit(exit_type);
+}
 /*
   for (i = 56; i >= 0; i -= 8) {
     x = (board >> i) & 255;
     for (j = 1; j < 256; j = j << 1)
       if (x & j)
-        printf("X ");
+        Print(4095, "X ");
       else
-        printf("- ");
+        Print(4095, "- ");
-    printf("\n");
+    Print(4095, "\n");
+  }
+}
 /*
  *******************************************************************************
  *   is nearly ready for display as is.                                        *
  *                                                                             *
  *******************************************************************************
  */
 void DisplayChessBoard(FILE * display_file, POSITION pos) {
-  int display_board[64];
+  int display_board[64], i, j;
   static const char display_string[16][4] =
       { "<K>", "<Q>", "<R>", "<B>", "<N>", "<P>", "   ",
     "-P-", "-N-", "-B-", "-R-", "-Q-", "-K-", " . "
   };
-  int i, j;
 /*
  ************************************************************
  *                                                          *
  *  First, convert square values to indices to the proper   *
       fprintf(display_file, "|%s", display_string[display_board[i * 8 + j]]);
     fprintf(display_file, "|\n");
     fprintf(display_file, "       +---+---+---+---+---+---+---+---+\n");
+  }
   fprintf(display_file, "         a   b   c   d   e   f   g   h\n\n");
+}
+/*
+ *******************************************************************************
+ *                                                                             *
+ *   DisplayChessMove() is a debugging function that displays a chess move in  *
+ *   a very simple (non-algebraic) form.                                       *
+ *                                                                             *
+ *******************************************************************************
+ */
+void DisplayChessMove(char *title, int move) {
+  Print(4095, "%s  piece=%d, from=%d, to=%d, captured=%d, promote=%d\n",
+      title, Piece(move), From(move), To(move), Captured(move),
+      Promote(move));
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   look nice and aligned.                                                    *
  *                                                                             *
  *******************************************************************************
  */
 char *DisplayEvaluation(int value, int wtm) {
-  static char out[10];
   int tvalue;
+  static char out[10];
   tvalue = (wtm) ? value : -value;
   if (!MateScore(value))
-    sprintf_s(out, sizeof (out), "%7.2f", ((float) tvalue) / 100.0); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%7.2f", ((float) tvalue) / 100.0);
   else if (Abs(value) > MATE) {
     if (tvalue < 0)
-      sprintf_s(out, sizeof (out), " -infnty"); // Pierre-Marie Baty -- use safe version
+      sprintf(out, " -infnty");
     else
-      sprintf_s(out, sizeof (out), " +infnty"); // Pierre-Marie Baty -- use safe version
+      sprintf(out, " +infnty");
   } else if (value == MATE - 2 && wtm)
-    sprintf_s(out, sizeof (out), "   Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "   Mate");
   else if (value == MATE - 2 && !wtm)
-    sprintf_s(out, sizeof (out), "  -Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "  -Mate");
   else if (value == -(MATE - 1) && wtm)
-    sprintf_s(out, sizeof (out), "  -Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "  -Mate");
   else if (value == -(MATE - 1) && !wtm)
-    sprintf_s(out, sizeof (out), "   Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "   Mate");
   else if (value > 0 && wtm)
-    sprintf_s(out, sizeof (out), "  Mat%.2d", (MATE - value) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "  Mat%.2d", (MATE - value) / 2);
   else if (value > 0 && !wtm)
-    sprintf_s(out, sizeof (out), " -Mat%.2d", (MATE - value) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, " -Mat%.2d", (MATE - value) / 2);
   else if (wtm)
-    sprintf_s(out, sizeof (out), " -Mat%.2d", (MATE - Abs(value)) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, " -Mat%.2d", (MATE - Abs(value)) / 2);
   else
-    sprintf_s(out, sizeof (out), "  Mat%.2d", (MATE - Abs(value)) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "  Mat%.2d", (MATE - Abs(value)) / 2);
   return out;
+}
 /*
  *******************************************************************************
  *   whispers will look nicer.                                                 *
  *                                                                             *
  *******************************************************************************
  */
 char *DisplayEvaluationKibitz(int value, int wtm) {
-  static char out[10];
   int tvalue;
+  static char out[10];
   tvalue = (wtm) ? value : -value;
   if (!MateScore(value))
-    sprintf_s(out, sizeof (out), "%+.2f", ((float) tvalue) / 100.0); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%+.2f", ((float) tvalue) / 100.0);
   else if (Abs(value) > MATE) {
     if (tvalue < 0)
-      sprintf_s(out, sizeof (out), "-infnty"); // Pierre-Marie Baty -- use safe version
+      sprintf(out, "-infnty");
     else
-      sprintf_s(out, sizeof (out), "+infnty"); // Pierre-Marie Baty -- use safe version
+      sprintf(out, "+infnty");
   } else if (value == MATE - 2 && wtm)
-    sprintf_s(out, sizeof (out), "Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "Mate");
   else if (value == MATE - 2 && !wtm)
-    sprintf_s(out, sizeof (out), "-Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "-Mate");
   else if (value == -(MATE - 1) && wtm)
-    sprintf_s(out, sizeof (out), "-Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "-Mate");
   else if (value == -(MATE - 1) && !wtm)
-    sprintf_s(out, sizeof (out), "Mate"); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "Mate");
   else if (value > 0 && wtm)
-    sprintf_s(out, sizeof (out), "Mat%.2d", (MATE - value) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "Mat%.2d", (MATE - value) / 2);
   else if (value > 0 && !wtm)
-    sprintf_s(out, sizeof (out), "-Mat%.2d", (MATE - value) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "-Mat%.2d", (MATE - value) / 2);
   else if (wtm)
-    sprintf_s(out, sizeof (out), "-Mat%.2d", (MATE - Abs(value)) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "-Mat%.2d", (MATE - Abs(value)) / 2);
   else
-    sprintf_s(out, sizeof (out), "Mat%.2d", (MATE - Abs(value)) / 2); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "Mat%.2d", (MATE - Abs(value)) / 2);
   return out;
+}
+/*
+ *******************************************************************************
+ *                                                                             *
+ *   DisplayPath() is used to display a PV during the root move search.        *
+ *                                                                             *
+ *******************************************************************************
+ */
+char *DisplayPath(TREE * RESTRICT tree, int wtm, PATH * pv) {
+  static char buffer[4096];
+  int i, t_move_number;
+/*
+ ************************************************************
+ *                                                          *
+ *  Initialize.                                             *
+ *                                                          *
+ ************************************************************
+ */
+  t_move_number = move_number;
+  sprintf(buffer, " %d.", move_number);
+  if (!wtm)
+    sprintf(buffer + strlen(buffer), " ...");
+  for (i = 1; i < (int) pv->pathl; i++) {
+    if (i > 1 && wtm)
+      sprintf(buffer + strlen(buffer), " %d.", t_move_number);
+    sprintf(buffer + strlen(buffer), " %s", OutputMove(tree, i, wtm,
+            pv->path[i]));
+    MakeMove(tree, i, wtm, pv->path[i]);
+    wtm = Flip(wtm);
+    if (wtm)
+      t_move_number++;
+  }
+  if (pv->pathh == 1)
+    sprintf(buffer + strlen(buffer), " <HT>             ");
+  else if (pv->pathh == 2)
+    sprintf(buffer + strlen(buffer), " <EGTB>           ");
+  else if (pv->pathh == 3)
+    sprintf(buffer + strlen(buffer), " <3-fold>         ");
+  else if (pv->pathh == 4)
+    sprintf(buffer + strlen(buffer), " <50-move>        ");
+  if (strlen(buffer) < 30)
+    for (i = 0; i < 30 - (int) strlen(buffer); i++) // Pierre-Marie Baty -- added type cast
+      strcat(buffer, " ");
+  strcpy(kibitz_text, buffer);
+  for (i = pv->pathl - 1; i > 0; i--) {
+    wtm = Flip(wtm);
+    UnmakeMove(tree, i, wtm, pv->path[i]);
+  }
+  return buffer;
+}
+/*
+ *******************************************************************************
+ *                                                                             *
+ *   DisplayFail() is used to display a PV (moves only) during the search.     *
+ *                                                                             *
+ *******************************************************************************
+ */
+void DisplayFail(TREE * RESTRICT tree, int type, int level, int wtm, int time,
+    int move, int value, int force) {
+  char buffer[4096], *fh_indicator;
+/*
+ ************************************************************
+ *                                                          *
+ *  If we have not used "noise_level" units of time, we     *
+ *  return immediately.  Otherwise we add the fail high/low *
+ *  indicator (++/--) and then display the times.           *
+ *                                                          *
+ ************************************************************
+ */
+  if (time < (int) noise_level) // Pierre-Marie Baty -- added type cast
+    return;
+  if (type == 1)
+    fh_indicator = (wtm) ? "++" : "--";
+  else
+    fh_indicator = (wtm) ? "--" : "++";
+  Print(4, "         %2i   %s     %2s   ", iteration,
+      Display2Times(end_time - start_time), fh_indicator);
+/*
+ ************************************************************
+ *                                                          *
+ *  If we are pondering, we need to add the (ponder-move)   *
+ *  to the front of the buffer, correcting the move number  *
+ *  if necessary.  Then fill in the move number and the     *
+ *  fail high/low bound.                                    *
+ *                                                          *
+ ************************************************************
+ */
+  if (!pondering) {
+    sprintf(buffer, "%d.", move_number);
+    if (!wtm)
+      sprintf(buffer + strlen(buffer), " ...");
+  } else {
+    if (wtm)
+      sprintf(buffer, "%d. ... (%s) %d.", move_number - 1, ponder_text,
+          move_number);
+    else
+      sprintf(buffer, "%d. (%s)", move_number, ponder_text);
+  }
+  sprintf(buffer + strlen(buffer), " %s%c", OutputMove(tree, 1, wtm, move),
+      (type == 1) ? '!' : '?');
+  strcpy(kibitz_text, buffer);
+  if (time >= (int) noise_level || force) { // Pierre-Marie Baty -- added type cast
+    noise_block = 0;
+    Lock(lock_io);
+    Print(4, "%s", buffer);
+    Unlock(lock_io);
+    if (type == 1)
+      Print(4, " (%c%s)                   \n", (wtm) ? '>' : '<',
+          DisplayEvaluationKibitz(value, wtm));
+    else
+      Print(4, " (%c%s)                   \n", (wtm) ? '<' : '>',
+          DisplayEvaluationKibitz(value, wtm));
+  }
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   DisplayPV() is used to display a PV during the search.                    *
  *                                                                             *
  *******************************************************************************
  */
-void DisplayPV(TREE * RESTRICT tree, int level, int wtm, int time, PATH * pv) {
+void DisplayPV(TREE * RESTRICT tree, int level, int wtm, int time, PATH * pv,
+    int force) {
   char buffer[4096], *buffp, *bufftemp;
-  int /*i, */t_move_number, type;
-  unsigned int i, buflen; // Pierre-Marie Baty -- fixed type
+  char blanks[40] = { "                                        " };
-  int nskip = 0, twtm = wtm, pv_depth = pv->pathd;;
+  int i, len, t_move_number, nskip = 0, twtm = wtm, pv_depth = pv->pathd;;
+  unsigned int idle_time;
 /*
  ************************************************************
  *                                                          *
  *  Initialize.                                             *
  *                                                          *
  ************************************************************
  */
-  for (i = 0; i < (unsigned int) n_root_moves; i++) // Pierre-Marie Baty -- part of type fix
+  for (i = 0; i < n_root_moves; i++)
-    if (!(root_moves[i].status & 8) && !(root_moves[i].status & 4))
+    if (root_moves[i].status & 4)
       nskip++;
-  if (level == 5)
+  for (i = 0; i < 4096; i++)
-    type = 4;
+    buffer[i] = ' ';
-  else
-    type = 2;
   t_move_number = move_number;
-  if (display_options & 64)
+  if (!pondering || analyze_mode) {
-    sprintf_s(buffer, sizeof (buffer), " %d.", move_number); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer, "%d.", move_number);
+    if (!wtm)
+      sprintf(buffer + strlen(buffer), " ...");
-  else
+  } else {
-    buffer[0] = 0;
+    if (wtm)
-  if ((display_options & 64) && !wtm)
-    strcat_s(buffer, sizeof (buffer), " ..."); // Pierre-Marie Baty -- use safe version
+      sprintf(buffer, "%d. ... (%s) %d.", move_number - 1, ponder_text,
-  for (i = 1; i < (unsigned int) pv->pathl; i++) { // Pierre-Marie Baty -- part of type fix
-    if ((display_options & 64) && i > 1 && wtm) {
+          move_number);
-      buflen = strlen (buffer);
+    else
-      sprintf_s(buffer + buflen, sizeof (buffer) - buflen, " %d.", t_move_number); // Pierre-Marie Baty -- use safe version
+      sprintf(buffer, "%d. (%s)", move_number, ponder_text);
-    }
+  }
+  for (i = 1; i < (int) pv->pathl; i++) {
-    buflen = strlen (buffer);
+    if (i > 1 && wtm)
+      sprintf(buffer + strlen(buffer), " %d.", t_move_number);
-    sprintf_s(buffer + buflen, sizeof (buffer) - buflen, " %s", OutputMove(tree, pv->path[i], i, // Pierre-Marie Baty -- use safe version
+    sprintf(buffer + strlen(buffer), " %s", OutputMove(tree, i, wtm,
-            wtm));
+            pv->path[i]));
-    MakeMove(tree, i, pv->path[i], wtm);
+    MakeMove(tree, i, wtm, pv->path[i]);
     wtm = Flip(wtm);
     if (wtm)
       t_move_number++;
+  }
   if (pv->pathh == 1)
-    strcat_s(buffer, sizeof (buffer), " <HT>           "); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer + strlen(buffer), " <HT>");
   else if (pv->pathh == 2)
-    strcat_s(buffer, sizeof (buffer), " <EGTB>         "); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer + strlen(buffer), " <EGTB>");
-  if (strlen(buffer) < 30)
+  else if (pv->pathh == 3)
-    for (i = 0; i < 30 - strlen(buffer); i++)
+    sprintf(buffer + strlen(buffer), " <3-fold>");
-      strcat_s(buffer, sizeof (buffer), " "); // Pierre-Marie Baty -- use safe version
+  else if (pv->pathh == 3)
-  strcpy_s(kibitz_text, sizeof (kibitz_text), buffer); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer + strlen(buffer), " <50-move>");
-  if (nskip > 1 && smp_max_threads > 1) {
+  if (nskip > 1 && smp_max_threads > 1)
+    sprintf(buffer + strlen(buffer), " (s=%d)", nskip);
+  if (strlen(buffer) < 30) {
-    buflen = strlen (buffer);
+    len = 30 - strlen(buffer);
+    for (i = 0; i < len; i++)
-    sprintf_s(buffer + buflen, sizeof (buffer) - buflen, " (s=%d)", nskip); // Pierre-Marie Baty -- use safe version
+      strcat(buffer, " ");
+  }
-  if (tree->nodes_searched > noise_level) {
+  strcpy(kibitz_text, buffer);
+  if (time >= (int) noise_level || force) { // Pierre-Marie Baty -- added type cast
     noise_block = 0;
     Lock(lock_io);
-    Print(type, "         ");
+    Print(2, "         ");
     if (level == 6)
-      Print(type, "%2i   %s%s   ", pv_depth, Display2Times(time),
+      Print(2, "%2i   %s%s   ", pv_depth, Display2Times(time),
           DisplayEvaluation(pv->pathv, twtm));
     else
-      Print(type, "%2i-> %s%s   ", pv_depth, Display2Times(time)
+      Print(2, "%2i-> %s%s   ", pv_depth, Display2Times(time)
           , DisplayEvaluation(pv->pathv, twtm));
-    buffp = buffer + 1;
+    buffp = buffer;
     do {
-      if ((int) strlen(buffp) > line_length - 42)
+      if ((int) strlen(buffp) > line_length - 38) {
-        bufftemp = strchr(buffp + line_length - 42, ' ');
+        bufftemp = buffp + line_length - 38;
+        while (*bufftemp != ' ')
+          bufftemp--;
+        if (*(bufftemp - 1) == '.')
+          while (*(--bufftemp) != ' ');
-      else
+      } else
         bufftemp = 0;
       if (bufftemp)
         *bufftemp = 0;
-      Print(type, "%s\n", buffp);
+      Print(2, "%s\n", buffp);
       buffp = bufftemp + 1;
       if (bufftemp)
+        if (!strncmp(buffp, blanks, strlen(buffp)))
+          bufftemp = 0;
+      if (bufftemp)
-        Print(type, "                                     ");
+        Print(2, "                                     ");
     } while (bufftemp);
+    idle_time = 0;
+    for (i = 0; i < (int) smp_max_threads; i++) // Pierre-Marie Baty -- added type cast
+      idle_time += thread[i].idle;
-    idle_percent =
+    busy_percent =
 - Min(100,
 * idle_time / (smp_max_threads * (end_time - start_time) + 1));
     Kibitz(level, twtm, pv_depth, end_time - start_time, pv->pathv,
-        tree->nodes_searched, idle_percent, tree->egtb_probes_successful,
+        tree->nodes_searched, busy_percent, (int) tree->egtb_hits, kibitz_text); // Pierre-Marie Baty -- added type cast
-        kibitz_text);
     Unlock(lock_io);
+  }
   for (i = pv->pathl - 1; i > 0; i--) {
     wtm = Flip(wtm);
-    UnmakeMove(tree, i, pv->path[i], wtm);
+    UnmakeMove(tree, i, wtm, pv->path[i]);
+  }
+}
 /*
  *******************************************************************************
  *   just nnn.n seconds.                                                       *
  *                                                                             *
  *******************************************************************************
  */
 char *DisplayHHMMSS(unsigned int time) {
-  static char out[10];
+  static char out[32];
   time = time / 100;
-  sprintf_s(out, sizeof (out), "%3u:%02u:%02u", time / 3600, time / 60, time % 60); // Pierre-Marie Baty -- use safe version
+  sprintf(out, "%3u:%02u:%02u", time / 3600, (time % 3600) / 60, time % 60);
   return out;
+}
 /*
  *******************************************************************************
  */
 char *DisplayHHMM(unsigned int time) {
   static char out[10];
   time = time / 6000;
-  sprintf_s(out, sizeof (out), "%3u:%02u", time / 60, time % 60); // Pierre-Marie Baty -- use safe version
+  sprintf(out, "%3u:%02u", time / 60, time % 60);
   return out;
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   DisplayKMB() takes an integer value that represents nodes per second, or  *
  *   just total nodes, and converts it into a more compact form, so that       *
- *   instead of nps=57200931, we get nps=57M.                                  *
+ *   instead of nps=57200931, we get nps=57.2M.  We use units of "K", "M",     *
+ *   "B" and "T".  If type==0, K=1000, etc.  If type=1, K=1024, etc.           *
  *                                                                             *
  *******************************************************************************
  */
-char *DisplayKMB(uint64_t val) {
+char *DisplayKMB(uint64_t val, int type) {
   static char out[10];
+  if (type == 0) {
-  if (val < 1000)
+    if (val < 1000)
-    sprintf_s(out, sizeof (out), "%" PRIu64, val); // Pierre-Marie Baty -- use safe version
+      sprintf(out, "%" PRIu64, val);
-  else if (val < 1000000)
+    else if (val < 1000000)
-    sprintf_s(out, sizeof (out), "%.1fK", (double) (val + 500) / 1000); // Pierre-Marie Baty -- use safe version
+      sprintf(out, "%.1fK", (double) val / 1000);
-  else if (val < 1000000000)
+    else if (val < 1000000000)
-    sprintf_s(out, sizeof (out), "%.1fM", (double) (val + 500000) / 1000000); // Pierre-Marie Baty -- use safe version
+      sprintf(out, "%.1fM", (double) val / 1000000);
-  else
+    else
-    sprintf_s(out, sizeof (out), "%.1fB", (double) (val + 500000000) / 1000000000); // Pierre-Marie Baty -- use safe version
+      sprintf(out, "%.1fB", (double) val / 1000000000);
+  } else {
+    if (val > 0 && !(val & 0x000000003fffffffULL))
+      sprintf(out, "%dG", (int) (val / (1 << 30)));
+    else if (val > 0 && !(val & 0x00000000000fffffULL))
+      sprintf(out, "%dM", (int) (val / (1 << 20)));
+    else if (val > 0 && !(val & 0x00000000000003ffULL))
+      sprintf(out, "%dK", (int) (val / (1 << 10)));
+    else
+      sprintf(out, "%" PRIu64, val);
+  }
   return out;
+}
 /*
  *******************************************************************************
  */
 char *DisplayTime(unsigned int time) {
   static char out[10];
   if (time < 6000)
-    sprintf_s(out, sizeof (out), "%6.2f", (float) time / 100.0); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%6.2f", (float) time / 100.0);
   else {
     time = time / 100;
-    sprintf_s(out, sizeof (out), "%3u:%02u", time / 60, time % 60); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%3u:%02u", time / 60, time % 60);
+  }
   return out;
+}
 /*
  *   roughly when the move will be announced.                                  *
  *                                                                             *
  *******************************************************************************
  */
 char *Display2Times(unsigned int time) {
+  int ttime, c, spaces;
   static char out[20], tout[10];
-  int ttime;
-  int c, spaces;
   if (time < 6000)
-    sprintf_s(out, sizeof (out), "%6.2f", (float) time / 100.0); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%6.2f", (float) time / 100.0);
   else {
     time = time / 100;
-    sprintf_s(out, sizeof (out), "%3u:%02u", time / 60, time % 60); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%3u:%02u", time / 60, time % 60);
+  }
   if (search_time_limit)
     ttime = search_time_limit;
   else
     ttime = difficulty * time_limit / 100;
   if (ttime < 360000) {
     if (ttime < 6000)
-      sprintf_s(tout, sizeof (tout), "%6.2f", (float) ttime / 100.0); // Pierre-Marie Baty -- use safe version
+      sprintf(tout, "%6.2f", (float) ttime / 100.0);
     else {
       ttime = ttime / 100;
-      sprintf_s(tout, sizeof (tout), "%3u:%02u", ttime / 60, ttime % 60); // Pierre-Marie Baty -- use safe version
+      sprintf(tout, "%3u:%02u", ttime / 60, ttime % 60);
+    }
     c = strspn(tout, " ");
-    strcat_s(out, sizeof (out), "/"); // Pierre-Marie Baty -- use safe version
+    strcat(out, "/");
-    strcat_s(out, sizeof (out), tout + c); // Pierre-Marie Baty -- use safe version
+    strcat(out, tout + c);
+  }
   spaces = 13 - strlen(out);
   for (c = 0; c < spaces; c++)
-    strcat_s(out, sizeof (out), " "); // Pierre-Marie Baty -- use safe version
+    strcat(out, " ");
   return out;
+}
 /*
  *******************************************************************************
  */
 char *DisplayTimeKibitz(unsigned int time) {
   static char out[10];
   if (time < 6000)
-    sprintf_s(out, sizeof (out), "%.2f", (float) time / 100.0); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%.2f", (float) time / 100.0);
   else {
     time = time / 100;
-    sprintf_s(out, sizeof (out), "%u:%02u", time / 60, time % 60); // Pierre-Marie Baty -- use safe version
+    sprintf(out, "%u:%02u", time / 60, time % 60);
+  }
   return out;
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   DisplayTreeState() is a debugging procedure used to provide some basic    *
- *   information about how the parallel search is progressing.  It is invoked  *
- *   by typing a "." (no quotes) while in console mode.                        *
- *                                                                             *
- *******************************************************************************
- */
-void DisplayTreeState(TREE * RESTRICT tree, int sply, int spos, int maxply) {
-  int left, i, *mvp, parallel = 0;
-  char buf[1024];
-  buf[0] = 0;
-  if (sply == 1) {
-    left = 0;
-    for (i = 0; i < n_root_moves; i++)
-      if (!(root_moves[i].status & 8))
-        left++;
-    sprintf_s(buf, sizeof (buf), "%d:%d/%d  ", 1, left, n_root_moves); // Pierre-Marie Baty -- use safe version
-  } else {
-    for (i = 0; i < spos - 6; i++)
-      strcat_s(buf, sizeof (buf), " "); // Pierre-Marie Baty -- use safe version
-    sprintf(buf + strlen(buf), "[p%2d] ", tree->thread_id);
-  }
-  for (i = Max(sply, 2); i <= maxply; i++) {
-    left = 0;
-    for (mvp = tree->last[i - 1]; mvp < tree->last[i]; mvp++)
-      if (*mvp)
-        left++;
-    sprintf(buf + strlen(buf), "%d:%d/%d  ", i, left,
-        (int) (tree->last[i] - tree->last[i - 1]));
-    if (!(i % 8))
-      strcat_s(buf, sizeof (buf), "\n"); // Pierre-Marie Baty -- use safe version
-    if (tree->nprocs > 1 && tree->ply == i) {
-      parallel = strlen(buf);
-      break;
-    }
-    if (sply > 1)
-      break;
-  }
-  printf("%s\n", buf);
-  if (sply == 1 && tree->nprocs) {
-    for (i = 0; i < smp_max_threads; i++)
-      if (tree->siblings[i])
-        DisplayTreeState(tree->siblings[i], tree->ply + 1, parallel, maxply);
-  }
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   DisplayType3() prints personality parameters that use an 8x8 board for    *
- *   their base values.  This prints them side by side with rank/file labels   *
- *   to make it easier to read.                                                *
- *                                                                             *
- *******************************************************************************
- */
-void DisplayType3(int *array, int *array2) {
-  int i, j;
-  printf("    ----------- Middlegame -----------   ");
-  printf("    ------------- Endgame -----------\n");
-  for (i = 0; i < 8; i++) {
-    printf("    ");
-    for (j = 0; j < 8; j++)
-      printf("%3d ", array[64 + (7 - i) * 8 + j]);
-    printf("  |  %d  |", 8 - i);
-    printf("  ");
-    for (j = 0; j < 8; j++)
-      printf("%3d ", array2[64 + (7 - i) * 8 + j]);
-    printf("\n");
-  }
-  printf
-      ("    ----------------------------------       ---------------------------------\n");
-  printf("      a   b   c   d   e   f   g   h        ");
-  printf("      a   b   c   d   e   f   g   h\n");
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   DisplayType4() prints personality parameters that use an 8x8 board for    *
- *   their base values.  This prints them side by side with rank/file labels   *
- *   to make it easier to read.                                                *
- *                                                                             *
- *******************************************************************************
- */
-void DisplayType4(int *array, int *array2) {
-  int i, j;
-  printf("    ----------- Middlegame -----------   ");
-  printf("    ------------- Endgame -----------\n");
-  for (i = 0; i < 8; i++) {
-    printf("    ");
-    for (j = 0; j < 8; j++)
-      printf("%3d ", array[(7 - i) * 8 + j]);
-    printf("  |  %d  |", 8 - i);
-    printf("  ");
-    for (j = 0; j < 8; j++)
-      printf("%3d ", array2[(7 - i) * 8 + j]);
-    printf("\n");
-  }
-  printf
-      ("    ----------------------------------       ---------------------------------\n");
-  printf("      a   b   c   d   e   f   g   h        ");
-  printf("      a   b   c   d   e   f   g   h\n");
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   DisplayType5() prints personality parameters that use an array[size].     *
- *                                                                             *
- *******************************************************************************
- */
-void DisplayType5(int *array, int size) {
-  int i;
-  printf("   ");
-  for (i = 0; i < size; i++)
-    printf("%4d ", array[i]);
-  printf("\n");
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   DisplayType6() prints personality parameters that use an array[mg][8]     *
- *   format.                                                                   *
- *                                                                             *
- *******************************************************************************
- */
-void DisplayType6(int *array) {
-  int i;
-  printf("    ----------- Middlegame ------------ ");
-  printf("    ------------- Endgame ------------\n");
-  printf("    ");
-  for (i = 0; i < 8; i++)
-    printf("%3d ", array[i]);
-  printf("  |     |");
-  printf("  ");
-  for (i = 8; i < 16; i++)
-    printf("%3d ", array[i]);
-  printf("\n");
+}
 /*
  *******************************************************************************
  *                                                                             *
  *                                                                             *
  *******************************************************************************
  */
 #if !defined(NOEGTB)
 void EGTBPV(TREE * RESTRICT tree, int wtm) {
+  uint64_t hk[1024], phk[1024], pos[1024];
-  int moves[1024], current[256];
+  unsigned moves[1024], current[256], *last;
-  uint64_t hk[1024], phk[1024];
+  int value, ply, i, j, nmoves;
+  int t_move_number, best = 0, bestmv = 0, optimal_mv = 0, legal;
   char buffer[16384], *next;
-  uint64_t pos[1024];
-  int value;
-  int ply, i, j, nmoves, *last, t_move_number;
-  int best = 0, bestmv = 0, optimal_mv = 0;
-  int legal;
 /*
  ************************************************************
  *                                                          *
  *  First, see if this is a known EGTB position.  If not,   *
   if (Castle(1, white) + Castle(1, white))
     return;
   if (!EGTBProbe(tree, 1, wtm, &value))
     return;
   t_move_number = move_number;
-  if (display_options & 64)
-    sprintf_s(buffer, sizeof (buffer), "%d.", move_number); // Pierre-Marie Baty -- use safe version
+  sprintf(buffer, "%d.", move_number);
-  else
+  if (!wtm)
-    buffer[0] = 0;
-  if ((display_options & 64) && !wtm)
-    strcat_s(buffer, sizeof (buffer), " ..."); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer + strlen(buffer), " ...");
 /*
  ************************************************************
  *                                                          *
  *  The rest is simple, but messy.  Generate all moves,     *
  *  then find the move with the best egtb score and make it *
     last = GenerateNoncaptures(tree, 1, wtm, last);
     nmoves = last - current;
     best = -MATE - 1;
     legal = 0;
     for (i = 0; i < nmoves; i++) {
-      MakeMove(tree, 1, current[i], wtm);
+      MakeMove(tree, 1, wtm, current[i]);
       if (!Check(wtm)) {
         legal++;
         if (TotalAllPieces == 2 || EGTBProbe(tree, 2, Flip(wtm), &value)) {
           if (TotalAllPieces > 2)
             value = -value;
             optimal_mv = 1;
           } else if (value == best)
             optimal_mv = 0;
+        }
+      }
-      UnmakeMove(tree, 1, current[i], wtm);
+      UnmakeMove(tree, 1, wtm, current[i]);
+    }
     if (best > -MATE - 1) {
       moves[ply] = bestmv;
-      if ((display_options & 64) && ply > 1 && wtm)
+      if (ply > 1 && wtm)
         sprintf(buffer + strlen(buffer), " %d.", t_move_number);
-      sprintf(buffer + strlen(buffer), " %s", OutputMove(tree, bestmv, 1,
+      sprintf(buffer + strlen(buffer), " %s", OutputMove(tree, 1, wtm,
-              wtm));
+              bestmv));
       if (!strchr(buffer, '#') && legal > 1 && optimal_mv)
-        strcat_s(buffer, sizeof (buffer), "!"); // Pierre-Marie Baty -- use safe version
+        sprintf(buffer + strlen(buffer), "!");
       hk[ply] = HashKey;
       phk[ply] = PawnHashKey;
-      MakeMove(tree, 1, bestmv, wtm);
+      MakeMove(tree, 1, wtm, bestmv);
       tree->status[1] = tree->status[2];
       wtm = Flip(wtm);
       for (j = 2 - (ply & 1); j < ply; j += 2)
         if (pos[ply] == pos[j])
           break;
   nmoves = ply;
   for (; ply > 0; ply--) {
     wtm = Flip(wtm);
     tree->save_hash_key[1] = hk[ply];
     tree->save_pawn_hash_key[1] = phk[ply];
-    UnmakeMove(tree, 1, moves[ply], wtm);
+    UnmakeMove(tree, 1, wtm, moves[ply]);
     tree->status[2] = tree->status[1];
+  }
   next = buffer;
   while (nmoves) {
     if ((int) strlen(next) > line_length) { // Pierre-Marie Baty -- added type cast
       break;
+    }
+  }
+}
 #endif
-/*
- *******************************************************************************
- *                                                                             *
- *   DisplayChessMove() is a debugging function that displays a chess move in  *
- *   a very simple (non-algebraic) form.                                       *
- *                                                                             *
- *******************************************************************************
- */
-void DisplayChessMove(char *title, int move) {
-  Print(4095, "%s  piece=%d, from=%d, to=%d, captured=%d, promote=%d\n",
-      title, Piece(move), From(move), To(move), Captured(move),
-      Promote(move));
-}
 /*
  *******************************************************************************
  *                                                                             *
  *   FormatPV() is used to display a PV during the search.  It will also note  *
  *   when the PV was terminated by a hash table hit.                           *
  *                                                                             *
  *******************************************************************************
  */
 char *FormatPV(TREE * RESTRICT tree, int wtm, PATH pv) {
+  int i, t_move_number;
   static char buffer[4096];
-  int i, t_move_number;
 /*
  ************************************************************
  *                                                          *
  *  Initialize.                                             *
  *                                                          *
  ************************************************************
  */
   t_move_number = move_number;
-  if (display_options & 64)
-    sprintf_s(buffer, sizeof (buffer), " %d.", move_number); // Pierre-Marie Baty -- use safe version
+  sprintf(buffer, " %d.", move_number);
-  else
+  if (!wtm)
-    buffer[0] = 0;
-  if ((display_options & 64) && !wtm)
-    strcat_s(buffer, sizeof (buffer), " ..."); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer + strlen(buffer), " ...");
   for (i = 1; i < (int) pv.pathl; i++) {
-    if ((display_options & 64) && i > 1 && wtm)
+    if (i > 1 && wtm)
       sprintf(buffer + strlen(buffer), " %d.", t_move_number);
-    sprintf(buffer + strlen(buffer), " %s", OutputMove(tree, pv.path[i], i,
+    sprintf(buffer + strlen(buffer), " %s", OutputMove(tree, i, wtm,
-            wtm));
+            pv.path[i]));
-    MakeMove(tree, i, pv.path[i], wtm);
+    MakeMove(tree, i, wtm, pv.path[i]);
     wtm = Flip(wtm);
     if (wtm)
       t_move_number++;
+  }
   for (i = pv.pathl - 1; i > 0; i--) {
     wtm = Flip(wtm);
-    UnmakeMove(tree, i, pv.path[i], wtm);
+    UnmakeMove(tree, i, wtm, pv.path[i]);
+  }
   return buffer;
+}
 /* last modified 02/26/14 */
  *   to terminate the game.                                                    *
  *                                                                             *
  *******************************************************************************
  */
 int GameOver(int wtm) {
-  int *mvp, *lastm, rmoves[256];
   TREE *const tree = block[0];
-  int over = 1;
+  unsigned *mvp, *lastm, rmoves[256], over = 1;
 /*
  ************************************************************
  *                                                          *
  *  First, use GenerateMoves() to generate the set of       *
  *  officially over.                                        *
  *                                                          *
  ************************************************************
  */
   for (mvp = rmoves; mvp < lastm; mvp++) {
-    MakeMove(tree, 1, *mvp, wtm);
+    MakeMove(tree, 1, wtm, *mvp);
     if (!Check(wtm))
       over = 0;
-    UnmakeMove(tree, 1, *mvp, wtm);
+    UnmakeMove(tree, 1, wtm, *mvp);
+  }
 /*
  ************************************************************
  *                                                          *
  *  If we did not make it thru the complete move list, we   *
 unsigned int ReadClock(void) {
 #if defined(UNIX)
   struct timeval timeval;
   struct timezone timezone;
 #else
-//  HANDLE hThread;
+  //HANDLE hThread; // Pierre-Marie Baty -- unreferenced variable
-//  FILETIME ftCreate, ftExit, ftKernel, ftUser; // Pierre-Marie Baty -- unused variables
+  //FILETIME ftCreate, ftExit, ftKernel, ftUser; // Pierre-Marie Baty -- unreferenced variables
-//  uint64_t tUser64;
+  //uint64_t tUser64; // Pierre-Marie Baty -- unreferenced variable
 #endif
 #if defined(UNIX)
   gettimeofday(&timeval, &timezone);
   return timeval.tv_sec * 100 + (timeval.tv_usec / 10000);
 #else
+}
 /*
  *******************************************************************************
  *                                                                             *
- *   FindBlockID() converts a thread block pointer into an ID that is easier to*
+ *   FindBlockID() converts a thread block pointer into an ID that is easier   *
- *   understand when debugging.                                                *
+ *   to understand when debugging.                                             *
  *                                                                             *
  *******************************************************************************
  */
 int FindBlockID(TREE * RESTRICT which) {
   int i;
-  for (i = 0; i < MAX_BLOCKS + 1; i++)
+  for (i = 0; i <= (int) smp_max_threads * 64; i++) // Pierre-Marie Baty -- added type cast
     if (which == block[i])
       return i;
   return -1;
+}
  *   squares, and the like.                                                    *
  *                                                                             *
  *******************************************************************************
  */
 int InvalidPosition(TREE * RESTRICT tree) {
-  int error = 0;
-  int wp, wn, wb, wr, wq, bp, bn, bb, br, bq;
+  int error = 0, wp, wn, wb, wr, wq, wk, bp, bn, bb, br, bq, bk;
   wp = PopCnt(Pawns(white));
   wn = PopCnt(Knights(white));
   wb = PopCnt(Bishops(white));
   wr = PopCnt(Rooks(white));
   wq = PopCnt(Queens(white));
+  wk = PopCnt(Kings(white));
   bp = PopCnt(Pawns(black));
   bn = PopCnt(Knights(black));
   bb = PopCnt(Bishops(black));
   br = PopCnt(Rooks(black));
   bq = PopCnt(Queens(black));
+  bk = PopCnt(Kings(black));
   if (wp > 8) {
     Print(4095, "illegal position, too many white pawns\n");
     error = 1;
+  }
-  if (wp + wn > 10) {
+  if (wn && wp + wn > 10) {
     Print(4095, "illegal position, too many white knights\n");
     error = 1;
+  }
-  if (wp + wb > 10) {
+  if (wb && wp + wb > 10) {
     Print(4095, "illegal position, too many white bishops\n");
     error = 1;
+  }
-  if (wp + wr > 10) {
+  if (wr && wp + wr > 10) {
     Print(4095, "illegal position, too many white rooks\n");
     error = 1;
+  }
-  if (wp + wq > 10) {
+  if (wq && wp + wq > 10) {
     Print(4095, "illegal position, too many white queens\n");
     error = 1;
+  }
-  if (KingSQ(white) > 63) {
+  if (wk == 0) {
     Print(4095, "illegal position, no white king\n");
     error = 1;
+  }
+  if (wk > 1) {
+    Print(4095, "illegal position, multiple white kings\n");
+    error = 1;
+  }
-  if (wp + wn + wb + wr + wq > 15) {
+  if ((wn + wb + wr + wq) && wp + wn + wb + wr + wq > 15) {
     Print(4095, "illegal position, too many white pieces\n");
     error = 1;
+  }
   if (Pawns(white) & (rank_mask[RANK1] | rank_mask[RANK8])) {
     Print(4095, "illegal position, white pawns on first/eighth rank(s)\n");
+  }
   if (bp > 8) {
     Print(4095, "illegal position, too many black pawns\n");
     error = 1;
+  }
-  if (bp + bn > 10) {
+  if (bn && bp + bn > 10) {
     Print(4095, "illegal position, too many black knights\n");
     error = 1;
+  }
-  if (bp + bb > 10) {
+  if (bb && bp + bb > 10) {
     Print(4095, "illegal position, too many black bishops\n");
     error = 1;
+  }
-  if (bp + br > 10) {
+  if (br && bp + br > 10) {
     Print(4095, "illegal position, too many black rooks\n");
     error = 1;
+  }
-  if (bp + bq > 10) {
+  if (bq && bp + bq > 10) {
     Print(4095, "illegal position, too many black queens\n");
     error = 1;
+  }
-  if (KingSQ(black) > 63) {
+  if (bk == 0) {
     Print(4095, "illegal position, no black king\n");
     error = 1;
+  }
+  if (bk > 1) {
+    Print(4095, "illegal position, multiple black kings\n");
+    error = 1;
+  }
-  if (bp + bn + bb + br + bq > 15) {
+  if ((bn + bb + br + bq) && bp + bn + bb + br + bq > 15) {
     Print(4095, "illegal position, too many black pieces\n");
     error = 1;
+  }
   if (Pawns(black) & (rank_mask[RANK1] | rank_mask[RANK8])) {
     Print(4095, "illegal position, black pawns on first/eighth rank(s)\n");
  *   the setup needed to start a new game.                                     *
  *                                                                             *
  *******************************************************************************
  */
 void NewGame(int save) {
-  static int save_book_selection_width = 5;
+  TREE *const tree = block[0];
-  static int save_kibitz = 0;
+  static int save_book_selection_width = 5, save_kibitz = 0;
   static int save_resign = 0, save_resign_count = 0, save_draw_count = 0;
-  static int save_learning = 0;
-  static int save_learn = 0;
-  static int save_accept_draws = 0;
+  static int save_learning = 0, save_learn = 0, save_accept_draws = 0;
   int id;
-  TREE *const tree = block[0];
   new_game = 0;
   if (save) {
     save_book_selection_width = book_selection_width;
     save_kibitz = kibitz;
     learn_value = 0;
     ponder_move = 0;
     last_search_value = 0;
     last_pv.pathd = 0;
     last_pv.pathl = 0;
-    initial_position[0] = 0; // Pierre-Marie Baty -- use safe version
+    strcpy(initial_position, "");
     InitializeChessBoard(tree);
-    InitializeHashTables();
+    InitializeHashTables(0);
     force = 0;
     books_file = normal_bs_file;
     draw_score[0] = 0;
     draw_score[1] = 0;
     game_wtm = 1;
     if (move_actually_played) {
       if (log_file) {
         fclose(log_file);
         fclose(history_file);
         id = InitializeGetLogID();
-        sprintf_s(log_filename, sizeof (log_filename), "%s/log.%03d", log_path, id); // Pierre-Marie Baty -- use safe version
+        sprintf(log_filename, "%s/log.%03d", log_path, id);
-        sprintf_s(history_filename, sizeof (history_filename), "%s/game.%03d", log_path, id); // Pierre-Marie Baty -- use safe version
+        sprintf(history_filename, "%s/game.%03d", log_path, id);
-        fopen_s (&log_file, log_filename, "w"); // Pierre-Marie Baty -- use safe version
+        log_file = fopen(log_filename, "w");
-        fopen_s (&history_file, history_filename, "w+"); // Pierre-Marie Baty -- use safe version
+        history_file = fopen(history_filename, "w+");
         if (!history_file) {
           printf("ERROR, unable to open game history file, exiting\n");
           CraftyExit(1);
+        }
+      }
  *   time resolution.                                                          *
  *                                                                             *
  *******************************************************************************
  */
 int ParseTime(char *string) {
-  int time = 0;
-  int minutes = 0;
+  int time = 0, minutes = 0;
   while (*string) {
     switch (*string) {
       case '0':
       case '1':
  *   the side whose turn it is to move.                                        *
  *                                                                             *
  *******************************************************************************
  */
 void Pass(void) {
-  char buffer[128];
   const int halfmoves_done = 2 * (move_number - 1) + (1 - game_wtm);
   int prev_pass = 0;
+  char buffer[128];
 /* Was previous move a pass? */
   if (halfmoves_done > 0) {
     if (history_file) {
       fseek(history_file, (halfmoves_done - 1) * 10, SEEK_SET);
-      if (fscanf_s(history_file, "%s", buffer, sizeof (buffer)) == 0 ||
+      if (fscanf(history_file, "%s", buffer) == 0 ||
           strcmp(buffer, "pass") == 0)
         prev_pass = 1;
+    }
+  }
   if (prev_pass) {
  */
 void Print(int vb, char *fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
-  if (vb & display_options)
+  if (vb == 4095 || vb & display_options) {
     vprintf(fmt, ap);
-  fflush(stdout);
+    fflush(stdout);
+  }
-  if (time_limit > -99 || tc_time_remaining[root_wtm] > 6000 || vb == 4095) {
+  if (time_limit > 5 || tc_time_remaining[root_wtm] > 1000 || vb == 4095) {
     va_start(ap, fmt);
-    if (log_file)
+    if (log_file) {
       vfprintf(log_file, fmt, ap);
-    if (log_file)
       fflush(log_file);
+    }
+  }
   va_end(ap);
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   PrintKM() converts a binary value to a real K/M type value, rather than   *
- *   the more common K=1000, M=1000000 type output.  This is used for info     *
- *   about the hash table sizes for one thing.                                 *
- *                                                                             *
- *******************************************************************************
- */
-char *PrintKM(size_t val, int realK) {
-  static char buf[32];
-  if (realK) {
-    if (val >= 1 << 20 && !(val & ((1 << 20) - 1)))
-      sprintf_s(buf, sizeof (buf), "%dM", (int) (val / (1 << 20))); // Pierre-Marie Baty -- use safe version
-    else if (val >= 1 << 10)
-      sprintf_s(buf, sizeof (buf), "%dK", (int) (val / (1 << 10))); // Pierre-Marie Baty -- use safe version
-    else
-      sprintf_s(buf, sizeof (buf), "%d", (int) val); // Pierre-Marie Baty -- use safe version
-    return buf;
-  } else {
-    if (val >= 1000000 && !(val % 1000000))
-      sprintf_s(buf, sizeof (buf), "%dM", (int) (val / 1000000)); // Pierre-Marie Baty -- use safe version
-    else if (val >= 1000)
-      sprintf_s(buf, sizeof (buf), "%dK", (int) (val / 1000)); // Pierre-Marie Baty -- use safe version
-    else
-      sprintf_s(buf, sizeof (buf), "%d", (int) val); // Pierre-Marie Baty -- use safe version
-    return buf;
-  }
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   Read() copies data from the command_buffer into a local buffer, and then  *
  *   uses ReadParse to break this command up into tokens for processing.       *
  *                                                                             *
  *******************************************************************************
  */
-int Read(int wait, char *buffer, size_t buffer_size) {
+int Read(int wait, char *buffer) {
   char *eol, *ret, readdata;
   *buffer = 0;
 /*
  case 1:  We have a complete command line, with terminating
   eol = strchr(cmd_buffer, '\n');
   *eol = 0;
   ret = strchr(cmd_buffer, '\r');
   if (ret)
     *ret = ' ';
-  strcpy_s(buffer, buffer_size, cmd_buffer); // Pierre-Marie Baty -- use safe version
+  strcpy(buffer, cmd_buffer);
   memmove(cmd_buffer, eol + 1, strlen(eol + 1) + 1);
   return 1;
+}
 /*
  *******************************************************************************
  *                                                                             *
- *   ReadClear() clears the input buffer when input_stream is being switched to*
+ *   ReadClear() clears the input buffer when input_stream is being switched   *
- *   a file, since we have info buffered up from a different input stream.     *
+ *   to a file, since we have info buffered up from a different input stream.  *
  *                                                                             *
  *******************************************************************************
  */
 void ReadClear() {
   cmd_buffer[0] = 0;
  *   delimit fields.                                                           *
  *                                                                             *
  *******************************************************************************
  */
 int ReadParse(char *buffer, char *args[], char *delims) {
-  char *next, tbuffer[4096];
   int nargs;
+  char *next, tbuffer[4096];
-  strcpy_s(tbuffer, sizeof (tbuffer), buffer); // Pierre-Marie Baty -- use safe version
+  strcpy(tbuffer, buffer);
   for (nargs = 0; nargs < 512; nargs++)
     *(args[nargs]) = 0;
   next = strtok(tbuffer, delims);
   if (!next)
     return 0;
  *   command_buffer for later processing.                                      *
  *                                                                             *
  *******************************************************************************
  */
 int ReadInput(void) {
-  char buffer[4096], *end;
   int bytes;
+  char buffer[4096], *end;
   do
-    bytes = _read(_fileno(input_stream), buffer, 2048); // Pierre-Marie Baty -- use ISO C++ conformant names
+    bytes = _read(_fileno(input_stream), buffer, 2048); // Pierre-Marie Baty -- POSIX/ISO C++ names fixes
   while (bytes < 0 && errno == EINTR);
   if (bytes == 0) {
     if (input_stream != stdin)
       fclose(input_stream);
     input_stream = stdin;
+}
 /*
  *******************************************************************************
  *                                                                             *
- *   ReadChessMove() is used to read a move from an input file.  The main issue*
+ *   ReadChessMove() is used to read a move from an input file.  The main      *
- *   is to skip over "trash" like move numbers, times, comments, and so forth, *
+ *   issue is to skip over "trash" like move numbers, times, comments, and so  *
- *   and find the next actual move.                                            *
+ *   forth, and find the next actual move.                                     *
  *                                                                             *
  *******************************************************************************
  */
 int ReadChessMove(TREE * RESTRICT tree, FILE * input, int wtm, int one_move) {
+  int move = 0, status;
   static char text[128];
   char *tmove;
-  int move = 0, status;
   while (move == 0) {
     status = fscanf(input, "%s", text);
     if (status <= 0)
       return -1;
     if (((tmove[0] >= 'a' && tmove[0] <= 'z') || (tmove[0] >= 'A' &&
                 tmove[0] <= 'Z')) || !strcmp(tmove, "0-0")
         || !strcmp(tmove, "0-0-0")) {
       if (!strcmp(tmove, "exit"))
         return -1;
-      move = InputMove(tree, tmove, 0, wtm, 1, 0);
+      move = InputMove(tree, 0, wtm, 1, 0, tmove);
+    }
     if (one_move)
       break;
+  }
   return move;
   if (((tmove[0] >= 'a' && tmove[0] <= 'z') || (tmove[0] >= 'A' &&
               tmove[0] <= 'Z')) || !strcmp(tmove, "0-0")
       || !strcmp(tmove, "0-0-0")) {
     if (!strcmp(tmove, "exit"))
       return -1;
-    move = InputMove(tree, tmove, ply, wtm, 1, 0);
+    move = InputMove(tree, ply, wtm, 1, 0, tmove);
+  }
   return move;
+}
 /*
  *                                                                             *
  *******************************************************************************
  */
 int ReadPGN(FILE * input, int option) {
   static int data = 0, lines_read = 0;
+  int braces = 0, parens = 0, brackets = 0, analysis = 0, last_good_line;
   static char input_buffer[4096];
   char *eof, analysis_move[64];
-  int braces = 0, parens = 0, brackets = 0, analysis = 0, last_good_line;
 /*
  ************************************************************
  *                                                          *
  *  If the line counter is being requested, return it with  *
           else if (strstr(input_buffer, "Black"))
             strcpy(pgn_black, value);
           else if (strstr(input_buffer, "Result"))
             strcpy(pgn_result, value);
           else if (strstr(input_buffer, "FEN")) {
-            sprintf_s(buffer, sizeof (buffer), "setboard %s", value); // Pierre-Marie Baty -- use safe version
+            sprintf(buffer, "setboard %s", value);
-            (void) Option(block[0]);
+            Option(block[0]);
             continue;
+          }
           return 1;
         } while (0);
       data = 1;
           memmove(input_buffer, skip, strlen(skip) + 1);
+      }
 /*
  ************************************************************
  *                                                          *
- *  This skips over nested {} or () characters and finds the*
+ *  This skips over nested {} or () characters and finds    *
- *  'mate', before returning any more moves.  It also stops *
+ *  the 'mate', before returning any more moves.  It also   *
- *  if a PGN header is encountered, probably due to an      *
+ *  stops if a PGN header is encountered, probably due to   *
- *  incorrectly bracketed analysis variation.               *
+ *  an incorrectly bracketed analysis variation.            *
  *                                                          *
  ************************************************************
  */
       last_good_line = lines_read;
       analysis_move[0] = 0;
           skip = strstr(input_buffer, buffer) + strlen(buffer);
           memmove(input_buffer, skip, strlen(skip) + 1);
       } else {
         int skip;
-        if ((skip = strspn(buffer, "0123456789."))) {
+        if ((skip = strspn(buffer, "0123456789./-"))) {
           if (skip > 1)
             memmove(buffer, buffer + skip, strlen(buffer + skip) + 1);
+        }
         if (isalpha(buffer[0]) || strchr(buffer, '-')) {
           char *first, *last, *percent;
 /*
  *******************************************************************************
  *                                                                             *
  *   RestoreGame() resets the position to the beginning of the game, and then  *
- *   reads in the game.nnn history file to set the position up so that the game*
+ *   reads in the game.nnn history file to set the position up so that the     *
- *   position matches the position at the end of the history file.             *
+ *   game position matches the position at the end of the history file.        *
  *                                                                             *
  *******************************************************************************
  */
 void RestoreGame(void) {
-  int i, move;
+  int i, v, move;
   char cmd[16];
   if (!history_file)
     return;
   game_wtm = 1;
   InitializeChessBoard(block[0]);
   for (i = 0; i < 500; i++) {
     fseek(history_file, i * 10, SEEK_SET);
     strcpy(cmd, "");
-    fscanf(history_file, "%s", cmd);
+    v = fscanf(history_file, "%s", cmd);
+    if (v < 0)
+      perror("RestoreGame fscanf error: ");
     if (strcmp(cmd, "pass")) {
-      move = InputMove(block[0], cmd, 0, game_wtm, 1, 0);
+      move = InputMove(block[0], 0, game_wtm, 1, 0, cmd);
       if (move)
-        MakeMoveRoot(block[0], move, game_wtm);
+        MakeMoveRoot(block[0], game_wtm, move);
       else
         break;
+    }
     game_wtm = Flip(game_wtm);
+  }
   nps = (int) ((time) ? 100 * nodes / (uint64_t) time : nodes);
   if (!puzzling) {
     char prefix[128];
     if (!(kibitz & 16))
-      sprintf_s(prefix, sizeof (prefix), "kibitz"); // Pierre-Marie Baty -- use safe version
+      sprintf(prefix, "kibitz");
     else
-      sprintf_s(prefix, sizeof (prefix), "whisper"); // Pierre-Marie Baty -- use safe version
+      sprintf(prefix, "whisper");
     switch (level) {
       case 1:
         if ((kibitz & 15) >= 1) {
           if (value > 0) {
             printf("%s mate in %d moves.\n\n", prefix, value);
             printf("%s mated in %d moves.\n\n", prefix, -value);
+          }
+        }
         break;
       case 2:
-        if ((kibitz & 15) >= 2) {
+        if ((kibitz & 15) >= 2)
           printf("%s ply=%d; eval=%s; nps=%s; time=%s(%d%%); egtb=%d\n",
               prefix, depth, DisplayEvaluationKibitz(value, wtm),
-              DisplayKMB(nps), DisplayTimeKibitz(time), ip, tb_hits);
+              DisplayKMB(nps, 0), DisplayTimeKibitz(time), ip, tb_hits);
-        }
       case 3:
-        if ((kibitz & 15) >= 3 && (nodes > 5000 || level == 2)) {
+        if ((kibitz & 15) >= 3 && (nodes > 5000 || level == 2))
           printf("%s %s\n", prefix, pv);
-        }
         break;
       case 4:
-        if ((kibitz & 15) >= 4) {
+        if ((kibitz & 15) >= 4)
           printf("%s %s\n", prefix, pv);
-        }
         break;
       case 5:
         if ((kibitz & 15) >= 5 && nodes > 5000) {
           printf("%s d%d-> %s/s %s(%d%%) %s %s ", prefix, depth,
-              DisplayKMB(nps), DisplayTimeKibitz(time), ip,
+              DisplayKMB(nps, 0), DisplayTimeKibitz(time), ip,
               DisplayEvaluationKibitz(value, wtm), pv);
           if (tb_hits)
             printf("egtb=%d", tb_hits);
           printf("\n");
-        }
-        break;
-      case 6:
-        if ((kibitz & 15) >= 6 && nodes > 5000) {
-          if (wtm)
-            printf("%s d%d+ %s/s %s(%d%%) >(%s) %s <re-searching>\n", prefix,
-                depth, DisplayKMB(nps), DisplayTimeKibitz(time), ip,
-                DisplayEvaluationKibitz(value, wtm), pv);
-          else
-            printf("%s d%d+ %s/s %s(%d%%) <(%s) %s <re-searching>\n", prefix,
-                depth, DisplayKMB(nps), DisplayTimeKibitz(time), ip,
-                DisplayEvaluationKibitz(value, wtm), pv);
+        }
         break;
+    }
     value = (wtm) ? value : -value;
     if (post && level > 1) {
       if (strstr(pv, "book"))
-        printf("        %2d  %5d %7d %" PRIu64 " %s\n", depth, value, time,
+        printf("      %2d  %5d %7d %" PRIu64 " %s\n", depth, value, time,
             nodes, pv + 10);
       else
-        printf("        %2d  %5d %7d %" PRIu64 " %s\n", depth, value, time,
+        printf("      %2d  %5d %7d %" PRIu64 " %s\n", depth, value, time,
             nodes, pv);
+    }
     fflush(stdout);
+  }
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   Output() is used to print the principal variation whenever it changes.    *
- *   One additional feature is that Output() will try to do something about    *
- *   variations truncated by the transposition table.  If the variation was    *
- *   cut short by a transposition table hit, then we can make the last move,   *
- *   add it to the end of the variation and extend the depth of the variation  *
- *   to cover it.                                                              *
  *                                                                             *
  *******************************************************************************
  */
-void Output(TREE * RESTRICT tree, int bound) {
+void Output(TREE * RESTRICT tree) {
-  int wtm;
+  int wtm, i;
-  int i;
-  ROOT_MOVE temp_rm;
 /*
  ************************************************************
  *                                                          *
+ *  Output the PV by walking down the path being backed up. *
- *  First, move the best move to the top of the ply-1 move  *
+ *  We do set the "age" for this move to "4" which will     *
- *  list if it's not already there, so that it will be the  *
+ *  keep it in the group of "search with all threads" moves *
- *  first move tried in the next iteration.                 *
+ *  so that it will be searched faster.                     *
  *                                                          *
  ************************************************************
  */
   wtm = root_wtm;
   if (!abort_search) {
-    kibitz_depth = iteration_depth;
+    kibitz_depth = iteration;
+    end_time = ReadClock();
+    DisplayPV(tree, 6, wtm, end_time - start_time, &tree->pv[1], 0);
     for (i = 0; i < n_root_moves; i++)
-      if (tree->curmv[1] == root_moves[i].move)
+      if (tree->pv[1].path[1] == root_moves[i].move)
         break;
-    if (i && i < n_root_moves) {
-      temp_rm = root_moves[i];
-      for (; i > 0; i--)
-        root_moves[i] = root_moves[i - 1];
+    root_moves[i].path = tree->pv[1];
-      root_moves[0] = temp_rm;
+    root_moves[i].bm_age = 4;
-    }
+  }
-    root_moves[0].bm_age = 4;
-    end_time = ReadClock();
+}
 /*
- ************************************************************
+ *******************************************************************************
- *                                                          *
+ *                                                                             *
+ *   SortRootMoves() is used to sort the root move list based on the value     *
+ *   saved for each move.  After a fail high or fail low, we always re-sort    *
+ *   the root move list so that the best move found so far is first in the     *
+ *   list.  This is primarily intended as a defense against getting a score    *
+ *   for the first root move, and then getting a fail-high on the second move, *
- *  If this is not a fail-high move, then output the PV by  *
+ *   which should move this move to the front of the moves.  But if the move   *
+ *   then fails low, we want to move it back down since a deeper/less-reduced  *
- *  walking down the path being backed up.                  *
+ *   search did not verify the fail-high.                                      *
- *                                                          *
+ *                                                                             *
- ************************************************************
+ *******************************************************************************
  */
-    if (tree->pv[1].pathv < bound) {
+void SortRootMoves() {
-      UnmakeMove(tree, 1, tree->pv[1].path[1], root_wtm);
+  ROOT_MOVE rtemp;
-      DisplayPV(tree, 6, wtm, end_time - start_time, &tree->pv[1]);
-      MakeMove(tree, 1, tree->pv[1].path[1], root_wtm);
+  int mvp, done;
+  do {
-    } else {
+    done = 1;
-      if (tree->curmv[1] != tree->pv[1].path[1]) {
+    for (mvp = 0; mvp < n_root_moves - 1; mvp++) {
-        tree->pv[1].path[1] = tree->curmv[1];
+      if (root_moves[mvp].path.pathv < root_moves[mvp + 1].path.pathv) {
-        tree->pv[1].pathl = 2;
+        rtemp = root_moves[mvp];
-        tree->pv[1].pathh = 0;
+        root_moves[mvp] = root_moves[mvp + 1];
-        tree->pv[1].pathd = iteration_depth;
+        root_moves[mvp + 1] = rtemp;
+        done = 0;
+      }
+    }
-  }
+  } while (!done);
+}
 /*
  *******************************************************************************
  *                                                                             *
- *   Trace() is used to print the search trace output each time a node is*
+ *   Trace() is used to print the search trace output each time a node is      *
  *   traversed in the tree.                                                    *
  *                                                                             *
  *******************************************************************************
  */
 void Trace(TREE * RESTRICT tree, int ply, int depth, int wtm, int alpha,
-    int beta, const char *name, int phase) {
+    int beta, const char *name, int mode, int phase, int order) {
   int i;
   Lock(lock_io);
   for (i = 1; i < ply; i++)
-    printf("  ");
+    Print(-1, "  ");
   if (phase != EVALUATION) {
-    printf("%d  %s d:%2d [%s,", ply, OutputMove(tree, tree->curmv[ply], ply,
+    Print(-1, "%d  %s(%d) d:%2d [%s,", ply, OutputMove(tree, ply, wtm,
-            wtm), depth, DisplayEvaluation(alpha, 1));
+            tree->curmv[ply]), order, depth, DisplayEvaluation(alpha, 1));
-    printf("%s] n:%" PRIu64 " %s(%d)", DisplayEvaluation(beta, 1),
+    Print(-1, "%s] n:%" PRIu64 " %s(%c:%d)", DisplayEvaluation(beta, 1),
-        (tree->nodes_searched), name, phase);
+        tree->nodes_searched, name, (mode) ? 'P' : 'S', phase);
-    if (smp_max_threads > 1)
-      printf(" (t=%d) ", tree->thread_id);
+    Print(-1, " (t=%d)\n", tree->thread_id);
-    printf("\n");
   } else {
-    printf("%d window/eval(%s) = {", ply, name);
+    Print(-1, "%d window/eval(%s) = {", ply, name);
-    printf("%s, ", DisplayEvaluation(alpha, 1));
+    Print(-1, "%s, ", DisplayEvaluation(alpha, 1));
-    printf("%s, ", DisplayEvaluation(depth, 1));
+    Print(-1, "%s, ", DisplayEvaluation(depth, 1));
-    printf("%s}\n", DisplayEvaluation(beta, 1));
+    Print(-1, "%s}\n", DisplayEvaluation(beta, 1));
+  }
   fflush(0);
   Unlock(lock_io);
+}
  *   StrCnt() counts the number of times a character occurs in a string.       *
  *                                                                             *
  *******************************************************************************
  */
 int StrCnt(char *string, char testchar) {
-  int count = 0;
+  int count = 0, i;
-  size_t i; // Pierre-Marie Baty -- fixed type
-  for (i = 0; i < strlen(string); i++)
+  for (i = 0; i < (int) strlen(string); i++) // Pierre-Marie Baty -- added type cast
     if (string[i] == testchar)
       count++;
   return count;
+}
  *   against the current chess board, castling status, en passant status, etc. *
  *                                                                             *
  *******************************************************************************
  */
 int ValidMove(TREE * RESTRICT tree, int ply, int wtm, int move) {
-  static int epdir[2] = { 8, -8 };
-  static int csq[2] = { C8, C1 };
-  static int dsq[2] = { D8, D1 };
-  static int esq[2] = { E8, E1 };
-  static int fsq[2] = { F8, F1 };
-  static int gsq[2] = { G8, G1 };
   int btm = Flip(wtm);
 /*
  ************************************************************
  *                                                          *
  ************************************************************
  */
     case pawn:
       if (((wtm) ? To(move) - From(move) : From(move) - To(move)) < 0)
         return 0;
-      if (Abs(From(move) - To(move)) == 8) {
+      if (Abs(From(move) - To(move)) == 8)
-        if (!PcOnSq(To(move)))
+        return (PcOnSq(To(move))) ? 0 : 1;
-          return 1;
-        return 0;
-      }
-      if (Abs(From(move) - To(move)) == 16) {
+      if (Abs(From(move) - To(move)) == 16)
-        if (!PcOnSq(To(move)) && !PcOnSq(To(move) + epdir[wtm]))
+        return (PcOnSq(To(move)) || PcOnSq(To(move) + epdir[wtm])) ? 0 : 1;
-          return 1;
-        return 0;
-      }
       if (!Captured(move))
         return 0;
 /*
  ************************************************************
  *                                                          *
  *  checking the from and to squares and also the attack    *
  *  status for completeness.                                *
  *                                                          *
  ************************************************************
  */
-  if ((Captured(move) == ((wtm) ? -PcOnSq(To(move)) : PcOnSq(To(move))))
+  return ((Captured(move) == ((wtm) ? -PcOnSq(To(move)) : PcOnSq(To(move))))
-      && Captured(move) != king)
+      && Captured(move) != king) ? 1 : 0;
-    return 1;
-  return 0;
+}
 /* last modified 02/26/14 */
 /*
  *******************************************************************************
  *   move to be sure it is safe to make it on the permanent game board.        *
  *                                                                             *
  *******************************************************************************
  */
 int VerifyMove(TREE * RESTRICT tree, int ply, int wtm, int move) {
-  int moves[220], *mv, *mvp;
+  unsigned moves[256], *mv, *mvp;
 /*
  Generate moves, then eliminate any that are illegal.
  */
   if (move == 0)
     return 0;
   tree->status[MAXPLY] = tree->status[ply];
   mvp = GenerateCaptures(tree, MAXPLY, wtm, moves);
   mvp = GenerateNoncaptures(tree, MAXPLY, wtm, mvp);
   for (mv = &moves[0]; mv < mvp; mv++) {
-    MakeMove(tree, MAXPLY, *mv, wtm);
+    MakeMove(tree, MAXPLY, wtm, *mv);
     if (!Check(wtm) && move == *mv) {
-      UnmakeMove(tree, MAXPLY, *mv, wtm);
+      UnmakeMove(tree, MAXPLY, wtm, *mv);
       return 1;
+    }
-    UnmakeMove(tree, MAXPLY, *mv, wtm);
+    UnmakeMove(tree, MAXPLY, wtm, *mv);
+  }
   return 0;
+}
 /*
  *   Windows NUMA support                                                      *
  *                                                                             *
  *******************************************************************************
  */
 #if !defined(UNIX)
-lock_t ThreadsLock;
 static BOOL(WINAPI * pGetNumaHighestNodeNumber) (PULONG);
 static BOOL(WINAPI * pGetNumaNodeProcessorMask) (UCHAR, PULONGLONG);
 static DWORD(WINAPI * pSetThreadIdealProcessor) (HANDLE, DWORD);
 static volatile BOOL fThreadsInitialized = FALSE;
 static BOOL fSystemIsNUMA = FALSE;
 static ULONG ulNumaNodes;
 static ULONG ulNumaNode = 0;
 // Get NUMA-related information from Windows
 static void WinNumaInit(void) {
-  //DWORD_PTR dwMask; // Pierre-Marie Baty -- unused variable
+  //DWORD_PTR dwMask; // Pierre-Marie Baty -- unreferenced variable
   HMODULE hModule;
   ULONG ulCPU, ulNode;
   ULONGLONG ullMask;
   DWORD dwCPU;
   if (!fThreadsInitialized) {
-    Lock(ThreadsLock);
+    Lock(lock_smp);
     if (!fThreadsInitialized) {
       printf("\nInitializing multiple threads.\n");
       fThreadsInitialized = TRUE;
       hModule = GetModuleHandle("kernel32");
       pGetNumaHighestNodeNumber =
         dwCPU =
             pSetThreadIdealProcessor(GetCurrentThread(), MAXIMUM_PROCESSORS);
         printf("Current ideal CPU is %u\n", dwCPU);
         pSetThreadIdealProcessor(GetCurrentThread(), dwCPU);
         if ((((DWORD) - 1) != dwCPU) && (MAXIMUM_PROCESSORS != dwCPU)
-            && !(ullProcessorMask[0] & (1ull << dwCPU))) { // Pierre-Marie Baty -- added "ll" prefix
+            && !(ullProcessorMask[0] & (1uLL << dwCPU))) { // Pierre-Marie Baty -- added type cast
           for (ulNode = 1; ulNode <= ulNumaNodes; ulNode++) {
-            if (ullProcessorMask[ulNode] & (1ull << dwCPU)) { // Pierre-Marie Baty -- added "ll" prefix
+            if (ullProcessorMask[ulNode] & (1uLL << dwCPU)) { // Pierre-Marie Baty -- added type cast
               printf("Exchanging nodes 0 and %d\n", ulNode);
               ullMask = ullProcessorMask[ulNode];
               ullProcessorMask[ulNode] = ullProcessorMask[0];
               ullProcessorMask[0] = ullMask;
               break;
+          }
+        }
       } else
         printf("System is SMP, not NUMA.\n");
+    }
-    Unlock(ThreadsLock);
+    Unlock(lock_smp);
+  }
+}
 // Start thread. For NUMA system set its affinity.
 #  if (CPUS > 1)
   DWORD dwPageSize;             // the page size on this computer
   LPVOID lpvResult;
   WinNumaInit();
   if (fSystemIsNUMA && (cThreads > 1)) {
-    GetSystemInfo(&sSysInfo);   // populate the system information structure
+    GetSystemInfo(&sSysInfo); // populate the system information structure
     dwPageSize = sSysInfo.dwPageSize;
 // Reserve pages in the process's virtual address space.
     pBase = (char *) VirtualAlloc(NULL, cbBytes, MEM_RESERVE, PAGE_NOACCESS);
     if (pBase == NULL) {
       printf("VirtualAlloc() reserve failed\n");
     for (iThread = 0; iThread < cThreads; iThread++) {
       ulNode = iThread % (ulNumaNodes + 1);
       dwAffinityMask =
           SetThreadAffinityMask(hThread, (DWORD_PTR) ullProcessorMask[ulNode]); // Pierre-Marie Baty -- added type cast
       for (pch = pBase + iThread * dwPageSize; pch < pEnd; pch += dwStep) {
-        lpvResult = VirtualAlloc(pch,   // next page to commit
+        lpvResult = VirtualAlloc(pch, // next page to commit
             dwPageSize, // page size, in bytes
             MEM_COMMIT, // allocate a committed page
-            PAGE_READWRITE);    // read/write access
+            PAGE_READWRITE); // read/write access
         if (lpvResult == NULL)
           ExitProcess(GetLastError());
         memset(lpvResult, 0, dwPageSize);
+      }
       SetThreadAffinityMask(hThread, dwAffinityMask);

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-crafty/utility.c – Rev 33 → 108