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

 #include "data.h"
 #if defined(UNIX)
 #  include <unistd.h>
 #  include <pwd.h>
 #  include <sys/types.h>
-#endif
-#if defined(NUMA) && defined(UNIX)
-#  include <numa.h>
 #endif
 #include <signal.h>
 /* last modified 02/24/14 */
 /*
  *******************************************************************************
  *                                                                             *
- *  Crafty, copyright 1996-2011 by Robert M. Hyatt, Ph.D., Associate Professor *
+ *  Crafty, copyright 1996-2015 by Robert M. Hyatt, Ph.D., Associate Professor *
  *  of Computer and Information Sciences, University of Alabama at Birmingham. *
  *                                                                             *
  *  Crafty is a team project consisting of the following members.  These are   *
  *  the people involved in the continuing development of this program, there   *
  *  are no particular members responsible for any specific aspect of Crafty,   *
  *  although R. Hyatt wrote 99%+ of the existing code, excepting the Magic .   *
- *  move stuff by Pradu Kanan, egtb.cpp written by Eugene Nalimov, and the epd *
+ *  move stuff by Pradu Kaanan, egtb.cpp written by Eugene Nalimov, and the    *
- *  stuff written by S. Edwards.                                               *
+ *  epd stuff written by S. Edwards.                                           *
  *                                                                             *
  *     Robert Hyatt, University of Alabama at Birmingham.                      *
+ *     Mike Byrne, Pen Argyl, PA.                                              *
  *     Tracy Riegle, Hershey, PA.                                              *
  *     Peter Skinner, Edmonton, AB  Canada.                                    *
  *                                                                             *
  *  All rights reserved.  No part of this program may be reproduced in any     *
  *  form or by any means, for other than your personal use, without the        *
  *           one side is "in distress" pieces are attracted to that king in    *
  *           "big hurry" to either attack or defend.                           *
  *                                                                             *
  *    3.4    "Threat extensions" added.  Simply, this is a null-move search    *
  *           used to determine if a move is good only because it is a horizon  *
- *           effect type move.  we do a null move search after a move fails    *
+ *           effect type move.  We do a null move search after a move fails    *
  *           high anywhere in the tree.  The window is normally lowered by 1.5 *
  *           pawns, the idea being that if the fail-high move happens in a     *
  *           position that fails "really low" with a null move, then this move *
  *           might be a horizon move.  To test this, re-search this move with  *
  *           the depth increased by one.                                       *
  *           a normal evaluation and/or further search is futile, this test    *
  *           has been moved to inside the loop *before* Quiesce() is           *
  *           recursively called, avoiding the MakeMove() work only to          *
  *           discover that the resulting position won't be searched further.   *
  *                                                                             *
- *    5.4    New Swap() function that now understands indirect attacks through *
+ *    5.4    New SEE() function that now understands indirect attacks through  *
  *           the primary attacking piece(s).  This corrects a lot of sloppy    *
  *           move ordering as well as make the "futility" cutoffs added in     *
  *           in version 5.3 much more reliable.                                *
  *                                                                             *
  *    5.5    Checks are now back in the quiescence search.  Crafty now stores  *
  *           to cause some tactical oversights in the search.                  *
  *                                                                             *
  *    5.6    Improved move ordering by using the old "killer move" idea.  An   *
  *           additional advantage is that the killers can be tried before      *
  *           generating any moves (after the captures.)  Quiescence now only   *
- *           includes "safe" checks (using Swap() to determine if it is a safe *
+ *           includes "safe" checks (using SEE() to determine if it is a safe  *
  *           checking move.                                                    *
  *                                                                             *
  *    5.7    King safety now "hates" a pawn at b3/g3 (white) or b6/g6 (black)  *
  *           to try and avoid the resulting mate threats.                      *
  *                                                                             *
  *           is no longer done if the major scoring contributors in Evaluate() *
  *           haven't pulled the score within the alpha/beta window, and the    *
  *           remainder of Evaluate() can't possible accomplish this either.    *
  *           Gross error in EvaluatePawns() fixed, which would "forget" all    *
  *           of the pawn scoring done up to the point where doubled white      *
- *           pawns were found.  error was xx=+ rather than xx+=, which had     *
+ *           pawns were found.  Error was xx=+ rather than xx+=, which had     *
  *           an extremely harmful effect on pawn structure evaluation.         *
  *                                                                             *
  *    7.4    Performance improvements produced by elimination of bit-fields.   *
  *           This was accomplished by hand-coding the necessary ANDs, ORs, and *
  *           SHIFTs necessary to accomplish the same thing, only faster.       *
  *           to edit Makefile and set "target" to the appropriate value from   *
  *           the list provided.  Then, when getting a new version, save your   *
  *           Makefile, extract the new source, copy in your makefile and you   *
  *           will be ready, except for those rare occasions where I add a new  *
  *           source module.  Other changes are performance tweaks.  One is a   *
- *           simple trick to order captures while avoiding Swap() if possible. *
+ *           simple trick to order captures while avoiding SEE() if possible.  *
  *           If the captured piece is more valuable than the capturing piece,  *
  *           we can simply use the difference (pessimistic value) rather than  *
- *           calling Swap() since this pessimistic value is still > 0.  Other  *
+ *           calling SEE() since this pessimistic value is still > 0.  Other   *
  *           tweaks to the various Next_*() routines to avoid a little un-     *
  *           necessary work.                                                   *
  *                                                                             *
  *    8.18   Book move selection algorithm changed.  Note that this is highly  *
  *           speculative, but when best book play is selected, Crafty will     *
  *                                                                             *
  *    8.22   EPD support (courtesy of Steven Edwards [thanks]) is now standard *
  *           in Crafty.  For porting, I'll provide a small test run which can  *
  *           be used to validate Crafty once it's been compiled.               *
  *                                                                             *
- *    8.23   Cleanup/speedup in hashing.  HashProbe() and HashStore() now      *
+ *    8.23   Cleanup/speedup in hashing.  ProbeTransRef() and StoreTransRef()  *
- *           carefully cast the boolean operations to the most efficient size  *
+ *           now carefully cast the boolean operations to the most efficient   *
- *           to avoid 64bit operations when only the right 32 bits are         *
+ *           size to avoid 64bit operations when only the right 32 bits are    *
  *           significant. Repeat() code completely re-written to maintain two  *
  *           repetition lists, one for each side.  Quiesce() now handles the   *
  *           repetition check a little different, being careful to not call it *
  *           when it's unimportant, but calling it when repetitions are        *
  *           possible.                                                         *
  *    8.24   Tweaks for king tropism to encourage pieces to collect near the   *
  *           king, or to encourage driving them away when being attacked.  A   *
  *           modification to Evaluate() to address the problem where Crafty    *
  *           is forced to play Kf1 or Kf8, blocking the rook in and getting    *
  *           into tactical difficulties as a result.  Book problem fixed where *
- *           BookUp was attempting to group moves with a common ancestor       *
+ *           Bookup was attempting to group moves with a common ancestor       *
  *           position together.  Unfortunately, captures were separated from   *
  *           this group, meaning capture moves in the book could never be      *
  *           played.  If a capture was the only move in book, it sort of       *
  *           worked because Crafty would drop out of book (not finding the     *
  *           capture) and then the search would "save" it.  However, if there  *
  *           if the side on move is either significantly ahead or behind,      *
  *           depending on the extension.  For example, getting out of check    *
  *           won't extend if the side on move is a rook behind, since it's     *
  *           already lost anyway.  We don't extend on passed pawn pushes if    *
  *           the side on move is ahead a rook, since he's already winning.     *
- *           minor adjustments for efficiency as well.  The next few           *
+ *           minor adjustments for efficiency as well.  The next few versions  *
- *           versions in this series will have module names in these comments  *
+ *           in this series will have module names in these comments           *
  *           indicating which modules have been "cleaned" up.  This is an      *
  *           effort at optimizing, although it is currently directed at a line *
  *           by line analysis within modules, rather than major changes that   *
  *           effect more global ideas.  This type of optimization will come at *
  *           a later point in time.                                            *
  *                                                                             *
  *    9.15   Evaluate() now attempts to recognize the case where a knight is   *
  *           trapped on one of the four corner squares, much like a bishop     *
  *           trapped at a2/a7/h2/h7.  If a knight is on a corner square, and   *
  *           neither of the two potential flight squares are safe (checked by  *
- *           Swap()) then a large penalty is given.  This was done to avoid    *
+ *           SEE()) then a large penalty is given.  This was done to avoid     *
  *           positions where Crafty would give up a piece to fork the king and *
  *           rook at (say) c7, and pick up the rook at a8 and think it was an  *
  *           exchange ahead, when often the knight was trapped and it was      *
  *           two pieces for a rook and pawn (or worse.)  Two timing bugs fixed *
  *           in this version:  (1) nodes_per_second was getting clobbered at   *
  *           the piece could let passed pawns race in undisturbed which would  *
  *           affect the score.  This pruning is turned off when there are not  *
  *           at least two pieces left on the board.  Another bug in the move   *
  *           generator produced pawn promotions twice, once when captures were *
  *           generated, then again when the rest of the moves are produced.    *
- *           this was also repaired.  Small book now will work.  The BookUp()  *
+ *           this was also repaired.  Small book now will work.  The Bookup()  *
  *           code now assumes white *and* black won in the absence of a valid  *
  *           PGN Result tag, so that the small book will work correctly.       *
  *                                                                             *
  *   11.6    Modifications to time allocation in a further attempt to make     *
  *           Crafty speed up if time gets short, to avoid flagging.  It is now *
  *   11.13   Endgame threshold lowered to the other side having a queen or     *
  *           less (9) rather than (13) points.  Queen+bishop can be very       *
  *           dangerous to the king for example, or two rooks and a bishop.     *
  *           Learning "curve" modified.  It was accidentally left in a sort    *
  *           of "geometric" shape, with the last move getting the full learn   *
- *           value, the next one back getting 1/2, the next 1/3, etc.   Now    *
+ *           value, the next one back getting 1/2, the next 1/3, etc.  Now     *
  *           it is uniformly distributed from front to back.  If there are 20  *
  *           moves, the last gets the full value, the next gets 19/20, etc..   *
  *           Also the "percentage played" was hosed and is fixed.              *
  *                                                                             *
  *   11.14   Minor modification to book learn 4 code so that when you start    *
  *           cache thrashing.  PopCnt() no longer used to recognize that we    *
  *           have reached an endgame database, there's now a counter for the   *
  *           total number of pieces on the board, as it's much faster to inc   *
  *           and dec that value rather than count 1 bits.  Tweaks to MakeMove  *
  *           and UnmakeMove to make things a couple of percent faster, but a   *
- *           whole lot cleaner.  Ditto for Swap and Quiesce.  More speed, and  *
+ *           whole lot cleaner.  Ditto for SEE and Quiesce.  More speed, and   *
  *           cleaner code.  Outside passed pawn scored scaled down except when *
  *           the opponent has no pieces at all.  "Lazy eval" cleaned up.  We   *
  *           now have two early exits, one before king safety and one after    *
  *           king safety.  There are two saved values so we have an idea of    *
  *           how large the positional scores have gotten to make this work.    *
  *           status not only indicates whether castling is legal or not, but   *
  *           if it's not, whether that side castled or move the king/rooks.    *
  *           this let ValidateMove() fail to correctly detect that a castling  *
  *           move from the hash table might be invalid, which could wreck the  *
  *           search easily.  This was an oversight from the new status code.   *
- *           Serious book bug fixed.  BookUp() was not counting wins and       *
+ *           Serious book bug fixed.  Bookup() was not counting wins and       *
  *           losses correctly, a bug introduced to make small.pgn work. Minor  *
  *           bug in the "trapped bishop" (a2/h2/a7/h7) code fixed.  Minor bug  *
- *           in Swap() also fixed (early exit that was not safe in rare cases.)*
+ *           in SEE() also fixed (early exit that was not safe in rare cases.) *
  *                                                                             *
  *   11.18   EvaluatePawns() modified to recognize that if there are two white *
  *           pawns "rammed" by black pawns at (say) c4/c5 and e4/e5, then any  *
  *           pawns on the d-file are also effectively rammed as well since     *
  *           there is no hope for advancing it.  Auto232 automatic play code   *
  *           again, even if this choice was at move 2, and the remainder of    *
  *           the book line was completely forced.  All in an effort to learn   *
  *           more quickly.                                                     *
  *                                                                             *
  *   14.5    annotate bug fixed where if there was only one legal move, the    *
- *           annotation would stop with no warning.  BookUp() now produces a   *
+ *           annotation would stop with no warning.  Bookup() now produces a   *
  *           more useful error message, giving the exact line number in the    *
  *           input file where the error occurred, to make fixing them easier.  *
  *           If you are playing without a book.bin, 14.4 would crash in the    *
- *           book learning code.  This is now caught and avoided.  BookUp()    *
+ *           book learning code.  This is now caught and avoided.  Bookup()    *
  *           now knows how to skip analysis in PGN files, so you can use such  *
  *           files to create your opening book, without having problems.  It   *
  *           understands that nesting () {} characters "hides" the stuff in-   *
  *           side them, as well as accepting non-standard PGN comments that    *
  *           are inside [].  Annotate() now will annotate a PGN file with      *
  *           promotion moves with no promotion piece specified.  The book      *
  *           create code also now correctly reports when you run out of disk   *
  *           space and this should work under any system to let you know when  *
  *           you run out of space.                                             *
  *                                                                             *
- *   15.15   Major modifications to Book() and BookUp().  BookUp() now needs   *
+ *   15.15   Major modifications to Book() and Bookup().  Bookup() now needs   *
  *           1/2 the temp space to build a book that it used to need (even     *
  *           less under windows).  Also, a book position is now 16 bytes in-   *
  *           stead of 20 (or 24 under windows) further reducing the space      *
  *           requirements.  The "win/lose/draw" counts are no longer absolute, *
  *           rather they are relative so they can be stored in one byte. A new *
  *           which gives them the most flexibility in advancing.  A change to  *
  *           the bishops of opposite color to not just consider B vs B drawish *
  *           when the B's are on opposite colors, but to also consider other   *
  *           positons like RB vs RB drawish with opposite B's.                 *
  *                                                                             *
- *   16.0    Hash functions renamed to HashProbe() and HashStore().  The store *
+ *   16.0    Hash functions renamed to ProbeTransRef() and StoreTransRef().    *
- *           functions (2) were combined to eliminate some duplicate code and  *
+ *           The store functions (2) were combined to eliminate some duplicate *
- *           shrink the cache footprint a bit.  Adjustment to "losing the      *
+ *           code and shrink the cache footprint a bit.  Adjustment to "losing *
- *           right to castle" so that the penalty is much less if this is done *
+ *           the right to castle" so that the penalty is much less if this is  *
- *           when trading queens, since a king in the center becomes less of a *
+ *           done when trading queens, since a king in the center becomes less *
- *           problem there. Several eval tweaks.  Support for Eugene Nalimov's *
+ *           of a problem there. Several eval tweaks.  Support for Eugene      *
- *           new endgame databases that reduce the size by 50%.  Added a new   *
+ *           Nalimov's new endgame databases that reduce the size by 50%.      *
- *           cache=xxx command to set the tablebase cache (more memory means   *
+ *           Added a new cache=xxx command to set the tablebase cache (more    *
- *           less I/O of course).  The "egtb" command now has two uses.  If    *
+ *           memory means less I/O of course).  The "egtb" command now has two *
- *           use egtb=0, you can disable tablebases for testing.  Otherwise,   *
+ *           uses.  If you enter egtb=0, you can disable tablebases for        *
- *           you just add "egtb" to your command line or .craftyrc file and    *
+ *           testing.  Otherwise, you just add "egtb" to your command line or  *
- *           Crafty automatically recognizes the files that are present and    *
+ *           .craftyrc file and Crafty automatically recognizes the files that *
- *           sets up to probe them properly.  Added an eval term to catch a    *
+ *           are present and sets up to probe them properly.  Added an eval    *
- *           closed position with pawns at e4/d3/c4 and then avoiding the      *
+ *           term to catch a closed position with pawns at e4/d3/c4 and then   *
- *           temptation to castle into an attack.  Most of the evaluation      *
+ *           avoiding the temptation to castle into an attack.  Most of the    *
- *           discontinuities have been removed, using the two new macros       *
+ *           evaluation discontinuities have been removed, using the two new   *
- *           ScaleToMaterial() and InverseScaleToMaterial().  Scale() is used  *
+ *           macros ScaleToMaterial() and InverseScaleToMaterial().  Scale()   *
- *           to reduce scores as material is removed from the board, while     *
+ *           is used to reduce scores as material is removed from the board,   *
- *           InverseScale() is used to increase the score as material is       *
+ *           while InverseScale() is used to increase the score as material    *
- *           removed.  This removed a few ugly effects of things happening     *
+ *           is removed.  This removed a few ugly effects of things happening  *
  *           right around the EG_MAT threshold.                                *
  *                                                                             *
  *   16.1    Bug in EGTBProbe() which used the wrong variable to access the    *
  *           enpassant target square was fixed.  The cache=x command now       *
  *           checks for a failed malloc() and reverts to the default cache     *
  *           mode.                                                             *
  *                                                                             *
  *   16.2    More evaluation changes, specifically to bring king safety down   *
  *           to reasonable levels.  Support for the DGT electronic chess board *
  *           is now included (but only works in text mode, not in conjunction  *
- *           with xboard/winboard yet.  Fix to HashStore() that corrected a    *
+ *           with xboard/winboard yet.  Fix to StoreTransRef() that corrected  *
- *           problem with moving an entry from tablea to tableb, but to the    *
+ *           a problem with moving an entry from tablea to tableb, but to the  *
  *           wrong address 50% of the time (thanks to J. Wesley Cleveland).    *
  *                                                                             *
  *   16.3    Performance tweaks plus a few evaluation changes.  An oversight   *
  *           would let Crafty play a move like exd5 when cxd5 was playable.    *
  *           IE it didn't follow the general rule "capture toward the center." *
  *           probe limit, it wouldn't probe yet Iterate() would terminate the  *
  *           search after a couple of plies.  And the move chosen could draw.  *
  *           New code submitted by George Barrett, which adds a new command    *
  *           "html on".  Using this will cause the annotate command to produce *
  *           a game.html file (rather than game.can) which includes nice board *
- *           displays (bitmapped images) everywhere Crafty suggests a different*
+ *           displays (bitmapped images) everywhere Crafty suggests a          *
- *           move.  You will need to download the bitmaps directory files to   *
+ *           different move.  You will need to download the bitmaps directory  *
- *           make this work.  Note that html on enables this or you will get   *
+ *           files to make this work.  Note that html on enables this or you   *
- *           normal annotation output in the .can file.  Final hashing changes *
+ *           will get normal annotation output in the .can file.  Final        *
- *           made.  Now crafty has only two hash tables, the 'depth preferred' *
+ *           hashing changes made.  Now crafty has only two hash tables, the   *
- *           and 'always store' tables, but not one for each side.             *
+ *           'depth preferred' and 'always store' tables, but not one for each *
+ *           side.                                                             *
  *                                                                             *
  *   16.5    Minor glitch in internal iterative deepening code (in search.c)   *
  *           could sometimes produce an invalid move.  Crafty now probes the   *
  *           hash table to find the best move which works in all cases.        *
  *           Interesting tablebase bug fixed.  By probing at ply=2, the        *
  *           search could overlook a repetition/50 move draw, and turn a won   *
  *           position into a draw.  Crafty now only probes at ply > 2, to      *
+ *           let the Repeat() function have a chance.  Added code by Dan       *
- *           let the Repeat() function have a chance.  Added code by Dan       * *           Corbitt to add environment variables for the tablebases, books,   *
+ *           Corbitt to add environment variables for the tablebases, books,   *
  *           logfiles and the .craftyrc file paths.  The environment variables *
  *           CRAFTY_TB_PATH, CRAFTY_BOOK_PATH, CRAFTY_LOG_PATH and             *
  *           CRAFTY_RC_PATH should point to where these files are located and  *
  *           offer an alternative to specifying them on the command line.      *
  *           Final version of the EGTB code is included in this version.  This *
  *           which was intentionally ignored in the last major revision.  Many *
  *           other scoring terms have been modified as well to attempt to      *
  *           bring the scores back closer to something reasonable.             *
  *                                                                             *
  *   16.8    Bug in evaluate.c (improper editing) broke the scoring for white  *
- *           rooks on open files (among other things.)  new twist on null-     *
+ *           rooks on open files (among other things.)  New twist on null-     *
  *           move search...  Crafty now uses R=3 near the root of the tree,    *
  *           and R=2 near the top.  It also uses null-move so long as there is *
  *           a single piece on the board, but when material drops to a rook or *
  *           less, null move is turned off and only used in the last 7 plies   *
  *           to push the zugzwang errors far enough off that they can be       *
  *           Evaluate() procedure, which could produce bizarre effects.  A few *
  *           minor eval glitches that caused asymmetric scores unintentionally *
  *           were removed.                                                     *
  *                                                                             *
  *   16.17   Minor "hole" in SMP code fixed.  It was possible that a move      *
- *           displayed as the best in Output() would not get played.     *
+ *           displayed as the best in Output() would not get played.           *
  *           Very subtle timing issue dealing with the search timing out and   *
  *           forgetting to copy the best move back to the right data area.     *
  *           Minor fixes to the modified -USE_ATTACK_FUNCTIONS option that     *
  *           was broken when the And()/Or()/ShiftX() macros were replaced by   *
  *           their direct bitwise operator replacements.                       *
  *           toward the opponent king in a coordinated way).  The scoring term *
  *           that kept the queen from going to the opposite side of the board  *
  *           was not working well which would also cause attacking problems.   *
  *           Razoring code has been disabled, as it neither helps or hurts on  *
  *           tactical tests, and it creates a few hashing problems that are    *
- *           annoying.  Bug in HashStorePV() that would store the PV into the  *
+ *           annoying.  Bug in StoreTransRefPV() that would store the PV into  *
- *           hash table, but possibly in the wrong table entry, which could    *
+ *           the hash table, but possibly in the wrong table entry, which      *
- *           stuff a bad move in a hash entry, or overwrite a key entry that   *
+ *           could stuff a bad move in a hash entry, or overwrite a key entry  *
- *           could have been useful later.  Book random 0 was slightly wrong   *
+ *           that could have been useful later.  Book random 0 was slightly    *
- *           as it could not ignore book moves if the search said that the     *
+ *           wrong as it could not ignore book moves if the search said that   *
- *           score was bad.  Also the search would not time-out properly on a  *
+ *           the score was bad.  Also the search would not time-out properly   *
- *           forced move, it would use the entire time alotted which was a big *
+ *           on a forced move, it would use the entire time alotted which was  *
- *           waste of time when there was only one legal move to make. A very  *
+ *           a big waste of time when there was only one legal move to make.   *
- *           interesting bug was found in storing mate bounds in the hash      *
+ *           A very interesting bug was found in storing mate bounds in the    *
- *           table, one I had not heard of before.  Another change to          *
+ *           hash table, one I had not heard of before.  Another change to     *
  *           Iterate() to make it avoid exiting as soon as a mate is found, so *
  *           that it can find the shortest mate possible.                      *
  *                                                                             *
  *   16.19   Savepos now pads each rank to 8 characters so that programs that  *
  *           don't handle abbreviated FEN will be able to parse Crafty's FEN   *
  *           black pawn to g7 made it work fine.   Also if both sides had an   *
  *           equal number of pawns (black pawn at a7/b7, white pawns at b2/c2  *
  *           the code would not notice black had an outside passer candidate   *
  *           since pawns were 'equal' in number.                               *
  *                                                                             *
- *   17.12   BookUp() will now create a book with all sorts of games in it, so *
+ *   17.12   Bookup() will now create a book with all sorts of games in it, so *
  *           long as the various games have the FEN string to properly set the *
  *           initial chess board position.                                     *
  *                                                                             *
  *   17.13   Endgame evaluation problem fixed.  King scoring now dynamically   *
  *           chooses the right piece/square table depending on which side of   *
  *           Even if the other side had pawns all over the board.  Passed pawn *
  *           scores increased a bit.  Minor change to "bad trade" code to turn *
  *           off in endings.  S list removed.  The trojan horse check is now   *
  *           automatically enabled when the key position is recognized at the  *
  *           root of the tree.  It is disabled once the key position is no     *
- *           longer seen at the root.  Bug in BookUp() would break if a FEN    *
+ *           longer seen at the root.  Bug in Bookup() would break if a FEN    *
  *           string was included in a game used for input.  SetBoard() was     *
  *           setting castling status incorrectly.  Internal iterative          *
  *           deepening bug could (on very rare occasions) cause Crafty to try  *
  *           to search an illegal move that would bomb the search.  This       *
  *           version fully supports the new xboard protocol version 2.  One    *
  *           than testing R=2/3 as the real null-move search uses.  The kibitz *
  *           for "Hello from Crafty Vx.xx" has been moved so that it works     *
  *           with the new xboard/winboard 4.2.2 versions.  Book learning was   *
  *           badly broken in the previous version and has been fixed/tested.   *
  *                                                                             *
- *   18.4    Recapture extension was left in SearchParallel() by mistake.  This*
+ *   18.4    Recapture extension was left in SearchParallel() by mistake.      *
- *           has now been protected by a #ifdef just like it was in Search().  *
+ *           This has now been protected by a #ifdef just like it was in       *
- *           Bug in Repeat() was causing problems in SMP versions.  The entire *
+ *           Search().  Bug in Repeat() was causing problems in SMP versions.  *
- *           repetition list code was modified to clean this up.  The problem  *
+ *           The entire repetition list code was modified to clean this up.    *
- *           was most noticable on things like fine #70.  Bug in               *
+ *           The problem was most noticable on things like fine #70.  Bug in   *
  *           LearnImportBook() confused the learn value sign, due to the other *
- *           changes to make +=white all the time.  opposite bishop scoring    *
+ *           changes to make +=white all the time.  Opposite bishop scoring    *
  *           has been beefed up a bit to avoid these drawish endings.          *
  *                                                                             *
  *   18.5    Minor change to RootMove() to use Quiesce() rather than the more  *
  *           complicated way it was ordering with Evaluate()/EnPrise().  This  *
  *           is no faster, but it is simpler and eliminated the need for the   *
  *                                                                             *
  *   19.3    Change to EvaluateMaterial to realize that a rook for five pawns  *
  *           is also likely a "bad trade."  Adaptive hash table size code was  *
  *           added so that the hash size is set automatically based on the     *
  *           estimated NPS and time per move values for a specific "level"     *
- *           command setting.   Repeat() rewritten.  The old code had an       *
+ *           command setting.  Repeat() rewritten.  The old code had an        *
  *           unexplained bug that would overlook repetitions in a parallel     *
  *           search in rare cases.  The old cold was complex enough that it    *
  *           was time to rewrite it and simplify it significantly.             *
  *                                                                             *
  *   19.4    Initial depth "seed" value changed to iteration_depth + 1/2 ply,  *
  *                                                                             *
  *   19.7    Changes to draw code so that Crafty will first claim a draw and   *
  *           then play the move, to avoid any confusion in whether the draw    *
  *           was made according to FIDE rules or not.  Minor bug in evaluate() *
  *           dealing with candidate passed pawns fixed.  A few additions to    *
- *           support my AMD Opteron inline assembly for MSB(), LSB()  *
+ *           support my AMD Opteron inline assembly for MSB(), LSB()           *
  *           and PopCnt() procedures.                                          *
  *                                                                             *
  *   19.8    Changes to lock.h to (a) eliminate NT/alpha, since Microsoft no   *
  *           longer supports the alpha, which makes lock.h much more readable. *
  *           CLONE is no longer an option either, further simplyfying the .h   *
  *           burn CPU time when not actually playing a game.                   *
  *                                                                             *
  *   19.17   Changes to pawn evaluation to limit positional scores that could  *
  *           get a bit out of sane boundaries in some positions.               *
  *                                                                             *
- *   19.18   HashProbe() no longer adjusts alpha/beta bounds if the entry is   *
+ *   19.18   ProbeTransRef() no longer adjusts alpha/beta bounds if the entry  *
- *           not good enough to terminate the search here.  This has helped    *
+ *           is not good enough to terminate the search here.  This has helped *
  *           speed things up (reduced size of tree) over many test positions   *
  *           so either it was buggy or not worthwhile.  Regardless, it is now  *
  *           'gone'.  Connected passed pawns now scored as a simple pair of    *
  *           pawns that are better as they are advanced, the old connected     *
  *           passed pawns on the 6th rank special code has been removed.       *
  *           array indices of 5,0, 4,1, 3,2, 2,3, 1,4, or 0,5, which is better *
  *           than what it was doing.  I plan to tweak this more later to make  *
  *           3,2 or 2,3 worse than 4,1 or 1,4 and 0,5 or 5,0, as the latter    *
  *           mean "unsafe king but no piece pressure" or "piece pressure but   *
  *           king pawn shelter is safe" whereas the middle values mean both    *
- *           components of an attack are present, unsafe king position and the
+ *           components of an attack are present, unsafe king position and the *
  *           pieces are closing in.                                            *
  *                                                                             *
  *   20.11   Minor fix to late move reduction code.  Turns out it is possible  *
  *           to reach the block of code if (first_move) { } with status set to *
  *           REMAINING_MOVES (this means no captures, no killer, no hash move, *
  *           was summarily removed (not summarily executed, it has had that    *
  *           done far too many times already).                                 *
  *                                                                             *
  *   22.0    Redesign of the data structures completed so that Crafty will no  *
  *           longer have duplicated code for wtm and btm cases.  This has      *
- *           already resulted in a rewrite of movgen(), swap(), make() and     *
+ *           already resulted in a rewrite of movgen(), SEE(), Make() and      *
  *           Unmake() and cut that code size by almost exactly 50%. The result *
  *           has been slightly faster speeds, but also the future benefits     *
  *           will be enormous by eliminating a lot of debugging caused by the  *
  *           duplicated code.  Timing change to avoid starting an iteration    *
  *           and wasting significant time.  We still search enough to get a    *
  *           reducing a few of the moves two plies.  The futility pruning has  *
  *           been modified to work at the last N plies.  We have an array of   *
  *           pruning margins (tuned on the cluster) where anytime the depth is *
  *           less than "pruning_depth" we try the futility test.  If the test  *
  *           succeeds, that move is discarded and not searched at all.  Move   *
- *           ordering code modified slightly to call Swap() fewer times if the *
+ *           ordering code modified slightly to call SEE() fewer times if the  *
  *           goodness of the capture can still be accurately assessed without  *
  *           the call.  Hash table has been changed to use a bucket of 4       *
  *           entries similar to a 4-way set associative cache.  When a store   *
  *           is attempted, we replace the least useful entry (see hash.c for   *
  *           details).  Additionally the hash table is forced to a 64 byte     *
  *           could cause a thread to attempt to output a PV after the search   *
  *           was in the process of timing out.  That thread could back up an   *
  *           incomplete/bogus search result to the root in rare occasions,     *
  *           which would / could result in Crafty kibitzing one move but       *
  *           playing a different move.  On occasion, the move played could be  *
- *           a horrible blunder.  Minor bug caused HashStore() to lose a best  *
+ *           a horrible blunder.  Minor bug caused StoreTransRef() to lose a   *
- *           move when overwriting an old position with a null-move search     *
+ *           best move when overwriting an old position with a null-move       *
- *           result.  Minor change by Tracy to lazy evaluation cutoff to speed *
+ *           search result.  Minor change by Tracy to lazy evaluation cutoff   *
- *           up evaluation somewhat.  Old "Trojan Horse" attack detection was  *
+ *           to speed up evaluation somewhat.  Old "Trojan Horse" attack       *
- *           removed.  At today's depths, it was no longer needed.  New hash   *
+ *           detection was removed.  At today's depths, it was no longer       *
- *           idea stores the PV for an EXACT hash entry in a separate hash     *
+ *           needed.  New hash idea stores the PV for an EXACT hash entry in a *
- *           table.  When an EXACT hit happens, this PV can be added to the    *
+ *           separate hash table.  When an EXACT hit happens, this PV can be   *
- *           incomplete PV we have so far so that we have the exact path that  *
+ *           added to the incomplete PV we have so far so that we have the     *
- *           leads to the backed up score.  New "phash" (path hash) command to *
+ *           exact path that leads to the backed up score.  New "phash" (path  *
- *           set the number of entries in this path hash table.  For longer    *
+ *           hash) command to set the number of entries in this path hash      *
- *           searches, a larger table avoids path table collisions which will  *
+ *           table.  For longer searches, a larger table avoids path table     *
- *           produce those short paths that end in <HT>.  If <HT> appears in   *
+ *           collisions which will produce those short paths that end in <HT>. *
- *           too many PVs, phash should be increased.  The "Trojan Horse" code *
+ *           If <HT> appears in too many PVs, phash should be increased.  The  *
- *           has been completely removed, which also resulted in the removal   *
+ *           "Trojan Horse" code has been completely removed, which also       *
- *           of the last bit of "pre-processing code" in preeval.c, so it has  *
+ *           resulted in the removal of the last bit of "pre-processing code"  *
- *           been completely removed as well.  Current search depths are such  *
+ *           in preeval.c, so it has been completely removed as well.  Current *
- *           that the Trojan Horse code is simply not needed any longer.  A    *
+ *           search depths are such that the Trojan Horse code is simply not   *
- *           minor bug in TimeSet() fixed where on rare occasions, near the    *
+ *           needed any longer.  A minor bug in TimeSet() fixed where on rare  *
- *           end of a time control, time_limit could be larger than the max    *
+ *           occasions, near the end of a time control, time_limit could be    *
- *           time allowed (absolute_time_limit).  We never check against this  *
+ *           larger than the max time allowed (absolute_time_limit).  We never *
- *           limit until we exceed the nominal time limit.  Cleanup on the     *
+ *           check against this limit until we exceed the nominal time limit.  *
- *           draw by repetition code to greatly simplify the code as well as   *
+ *           Cleanup on the draw by repetition code to greatly simplify the    *
- *           speed it up.                                                      *
+ *           code as well as speed it up.                                      *
  *                                                                             *
  *    23.5   Several pieces of code cleanup, both for readability and speed.   *
  *           We are now using stdint.h, which lets us specific the exact size  *
  *           of an integer value which gets rid of the int vs long issues that *
  *           exist between MSVC and the rest of the world on X86_64.  We still *
  *           only to be instantly aborted so that we could back out of Search()*
  *           and then re-start.  Wasted the split time unnecessarily although  *
  *           it was not a huge amount of time.  Another simplification to the  *
  *           repetition-detection code while chasing a parallel search bug     *
  *           was missing repetitions.                                          *
+ *                                                                             *
+ *    24.1   LMR reductions changed to allow a more dynamic reduction amount   *
+ *           rather than just 1 or 2.  An array LMR_reductions[depth][moves]   *
+ *           is initialized at start-up and sets the reduction amount for a    *
+ *           specific depth remaining (larger reduction with more depth left)  *
+ *           and the total moves searched at this node (again a larger         *
+ *           reduction as more moves are searched.)  This can easily be        *
+ *           changed with the new "lmr" command (help lmr for details).  The   *
+ *           old "noise" stuff has been changed.  Now, rather than noise       *
+ *           specifying the number of nodes that have to be searched before    *
+ *           any output is displayed (PV, fail high, etc) it now specifies a   *
+ *           time that must pass before the first output is produced.  This    *
+ *           can still be displayed with noise=0, otherwise noise=n says no    *
+ *           output until n seconds have passed (n can be a fraction of a      *
+ *           second if wanted.)  I restored the old adaptive null-move code,   *
+ *           but changed the reduction (used to be 2 to 3 depending on the     *
+ *           depth remaining) so that it is 3 + depth / 6.  For each 6 plies   *
+ *           of remaining depth, we reduce by another ply, with no real bound  *
+ *           other than the max depth we can reasonably reach.  The "6" in     *
+ *           the above can be changed with the personality command or the new  *
+ *           null m n command.  When the changes to noise were made, Iterate() *
+ *           was also changed so that if the search terminates for any reason  *
+ *           and no PV was displayed, whether because the noise limit was not  *
+ *           satisfied or this search did not produce a PV because it started  *
+ *           at an excessively deep search depth, Crafty now always displays   *
+ *           at least one PV in the log file to show how the game is going to  *
+ *           continue.  One case where this was an issue was where Crafty did  *
+ *           a LONG ponder search because the opponent took an excessive       *
+ *           amount of time to make a move.  If it finishes (say) a 30 ply     *
+ *           search while pondering, when the opponent moves, Crafty will move *
+ *           instantly, but when it starts the next search, we start pondering *
+ *           at iteration 29, which might take a long time to finish.  But we  *
+ *           do still have the PV from the last search (the 30 ply one) and    *
+ *           main() thoughtfully removed the first two moves (the move played  *
+ *           and the move we are now pondering, so we always have something to *
+ *           display, and now we no longer terminate a search with no output   *
+ *           (PV, time, etc) at all.  Generation II of the parallel split code *
+ *           (see Thread() in the thread.c source file comments for specifics) *
+ *           that is a lighter-weight split/copy plus the individual threads   *
+ *           do most of the copying rather than the thread that initiates the  *
+ *           split.  More work on the skill command.  For each 10 units the    *
+ *           skill level is reduced, the search speed is reduced by 50%.       *
+ *           Additionally the null-move and LMR reduction values are also      *
+ *           ramped down so that by the time skill drops below 10, there are   *
+ *           no reductions left.                                               *
+ *                                                                             *
+ *    24.2   Bug in SetTime() fixed.  The absolute time limit was set way too  *
+ *           large in sudden death games (games with no secondary time control *
+ *           to add time on the clock) with an increment.  It was intended to  *
+ *           allow the search to use up to 5x the normal target time, unless   *
+ *           that was larger than 1/2 of the total time remaining, but some-   *
+ *           where along the way that 5x was removed and it always set the     *
+ *           absolute time limit to 1/2 the remaining clock, which would burn  *
+ *           clock time way too quickly.  Complete re-factor of Search() to    *
+ *           take the main loop and move that to a new procedure               *
+ *           SearchMoveList() to eliminate the duplicated search code between  *
+ *           Search() and SearchParallel() which has been replaced by          *
+ *           SearchMoveList().  New addition to NextMove().  It was cleaned up *
+ *           to eliminate the old NextEvasion() code since one was a sub-set   *
+ *           of the other.  A minor change to limit the NPS impact on history  *
+ *           ordering.  We do not do history ordering within 6 plies of a      *
+ *           terminal node, and we only try to order 1/2 of the moves before   *
+ *           giving up and assuming this is an ALL node where ordering does    *
+ *           not matter.                                                       *
+ *                                                                             *
+ *    25.0   Complete re-factor of pawn evaluation code.  There were too many  *
+ *           overlapping terms that made tuning difficult.  Now a pawn is      *
+ *           classified as one specific class, there is no overlap between     *
+ *           classes, which simplifies the code significantly.  The code is    *
+ *           now easier to understand and modify.  In addition, the passed     *
+ *           pawn evaluation was rewritten and consolidates all the passed     *
+ *           pawn evaluation in one place.  The evaluation used to add a bonus *
+ *           for rooks behind passed pawns in rook scoring, blockading some-   *
+ *           where else, etc.  All of this was moved to the passed pawn code   *
+ *           to make it easier to understand and modify.  A limited version of *
+ *           late move pruning (LMP) is used in the last two plies.  Once a    *
+ *           set number of moves have been searched with no fail high, non-    *
+ *           interesting moves are simply skipped in a way similar to futility *
+ *           pruning.  This version also contains a major rewrite of the       *
+ *           parallel search code, now referred to as Generation II.  It has a *
+ *           more lightweight split algorithm, that costs the parent MUCH less *
+ *           effort to split the search.  The key is that now the individual   *
+ *           "helper" threads do all the work, allocating a split block,       *
+ *           copying the data from the parent, etc., rather than the parent    *
+ *           doing it all.  Gen II based on the DTS "late-join" idea so that a *
+ *           thread will try to join existing split points before it goes to   *
+ *           the idle wait loop waiting for some other thread to split with    *
+ *           it.  In fact, this is now the basis for the new split method      *
+ *           where the parent simply creates a split point by allocating a     *
+ *           split block for itself, and then continuing the search, after the *
+ *           parent split block is marked as "joinable".  Now any idle threads *
+ *           just "jump in" without the parent doing anything else, which      *
+ *           means that currently idle threads will "join" this split block if *
+ *           they are in the "wait-for-work" spin loop, and threads that be-   *
+ *           come idle also join in exactly the same way.  This is MUCH more   *
+ *           efficient, and also significantly reduces the number of split     *
+ *           blocks needed during the search.  We also now pre-split the       *
+ *           search when we are reasonably close to the root of the tree,      *
+ *           which is called a "gratuitous split.  This leaves joinable split  *
+ *           points laying around so that whenever a thread becomes idle, it   *
+ *           can join in at these pre-existing split points immediately.  We   *
+ *           now use a much more conservative approach when dealing with fail  *
+ *           highs at the root.  Since LMR and such have introduced greater    *
+ *           levels of search instability, we no longer trust a fail-high at   *
+ *           the root if it fails low on the re-search.  We maintain the last  *
+ *           score returned for every root move, along with the PV.  Either an *
+ *           exact score or the bound score that was returned.  At the end of  *
+ *           the iteration, we sort the root move list using the backed-up     *
+ *           score as the sort key, and we play the move with the best score.  *
+ *           This solves a particularly ugly issue where we get a score for    *
+ *           the first move, then another move fails high, but then fails low  *
+ *           and the re-search produces a score that is actually WORSE than    *
+ *           the original best move.  We still see that, but we always play    *
+ *           the best move now.  One other efficiency trick is that when the   *
+ *           above happens, the search would tend to be less efficient since   *
+ *           the best score for that fail-high/fail-low move is actually worse *
+ *           than the best move/score found so far.  If this happens, the      *
+ *           score is restored to the original best move score (in Search())   *
+ *           so that we continue searching with a good lower bound, not having *
+ *           to deal with moves that would fail high with this worse value,    *
+ *           but not with the original best move's value.  Minor change to     *
+ *           history counters that now rely on a "saturating counter" idea.  I *
+ *           wanted to avoid the aging idea, and it seemed to not be so clear  *
+ *           that preferring history moves by the depth at which they were     *
+ *           good was the way to go.  I returned to a history counter idea I   *
+ *           tested around 2005 but discarded, namely using a saturating       *
+ *           counter.  The idea is that a center value (at present 1024)       *
+ *           represents a zero score.  Decrementing it makes it worse,         *
+ *           incrementing it makes it better.  But to make it saturate at      *
+ *           either end, I only reduce the counter by a fraction of its        *
+ *           distance from the saturation point so that once it gets to either *
+ *           extreme value, it will not be modified further avoiding wrap-     *
+ *           around.  This basic idea was originally reported by Mark Winands  *
+ *           in 2005.  It seems to provide better results (slightly) on very   *
+ *           deep searches.  One impetus for this was an intent to fold this   *
+ *           into a move so that I could sort the moves rather than doing the  *
+ *           selection approach I currently use.  However, this had a bad      *
+ *           effect on testing, since history information is dynamic and is    *
+ *           constantly changing, between two moves at the same ply in fact.   *
+ *           The sort fixed the history counters to the value at the start of  *
+ *           that ply.  This was discarded after testing, but the history      *
+ *           counter based on the saturating counter idea seemed to be OK and  *
+ *           was left in even though it produced minimal Elo gain during       *
+ *           testing.  Change to the way moves are counted, to add a little    *
+ *           more consistency to LMR.  Now Next*() returns an order number     *
+ *           that starts with 1 and monotonically increases, this order number *
+ *           is used for LMR and such decisions that vary things based on how  *
+ *           far down the move list something occurs.  Root move counting was  *
+ *           particularly problematic with parallel searching, now things are  *
+ *           at least "more consistent".  The only negative impact is that now *
+ *           the move counter gets incremented even for illegal moves, but     *
+ *           testing showed this was a no-change change with one thread, and   *
+ *           the consistency with multiple threads made it useful.  New method *
+ *           to automatically tune SMP parameters.  The command is autotune    *
+ *           and "help autotune" will explain how to run it.  Added the        *
+ *           "counter-move" heuristic for move ordering (Jos Uiterwijk, JICCA) *
+ *           which simply remembers a fail high move and the move at the       *
+ *           previous ply.  If the hash, captures or killer moves don't result *
+ *           in a fail high, this move is tried next.  No significant cost,    *
+ *           seems to reduce tree size noticeably.  Added a follow-up idea     *
+ *           based on the same idea, except we pair a move that fails high     *
+ *           with the move two plies back, introducing a sort of "connection"  *
+ *           between them.  This is a sort of "plan" idea where the first move *
+ *           of the pair enables the second move to fail high.  The benefit is *
+ *           that this introduces yet another pair of good moves that get      *
+ *           ordered before history moves, and is therefore not subject to     *
+ *           reduction.  I have been unable to come up with a reference for    *
+ *           this idea, but I believe I first saw it somewhere around the time *
+ *           Fruit showed up, I am thinking perhaps in the JICCA/JICGA.  Any   *
+ *           reference would be appreciated.  Minor change to the way the PV   *
+ *           and fail-hi/fail-low moves are displayed when pondering.  Crafty  *
+ *           now adds the ponder move to the front of the PV enclosed in ( )   *
+ *           so that it is always visible in console mode.  The depths are     *
+ *           reaching such extreme numbers the ponder move scrolls off the top *
+ *           of the screen when running in console mode or when "tail -f" is   *
+ *           used to watch the log file while a game is in progress.  This is  *
+ *           a bit trickier than you might think since Crafty displays the     *
+ *           game move numbers in the PV.  Penalty for pawns on same color as  *
+ *           bishop now only applies when there is one bishop.                 *
+ *                                                                             *
+ *    25.0.1 Cleanup of NextMove() plus a minor ordering bug fix that would    *
+ *           skip counter moves at ply = 2. Added NUMA code to force the hash  *
+ *           tables to be spread across the numa nodes as equally as possible  *
+ *           rather than all of the data sitting on just onenode.  This makes  *
+ *           one specific user policy important.  BEFORE you set the hash size *
+ *           for any of the four hash tables, you should ALWAYS set the max    *
+ *           threads limit first, so that the NUMA trick works correctly.  Of  *
+ *           course, if you do not use -DAFFINITY this is all irrelevant.  The *
+ *           -DNUMA option has been removed.  I no longer use any libnuma      *
+ *           routines.  A new "smpnuma" command is now used to enable/disable  *
+ *           NUMA mode (which really only affects how the hash tables are      *
+ *           cleared, all the other NUMA code works just fine no matter        *
+ *           whether this is enabled or disabled.  Fixed a bug with the xboard *
+ *           memory command that could overflow and cause preposterous malloc  *
+ *           requests.                                                         *
  *                                                                             *
  *******************************************************************************
  */
 int main(int argc, char **argv) {
-  int move, readstat;
-  int value = 0, i, result;
-  int draw_type;
   TREE *tree;
   FILE *personality;
+  int move, readstat, value = 0, i, v, result, draw_type;
   char announce[128];
 #if defined(UNIX)
   char path[1024];
   struct passwd *pwd;
 #endif
 /* Collect environmental variables */
   char *directory_spec = getenv("CRAFTY_BOOK_PATH");
   if (directory_spec)
-    strcpy_s(book_path, sizeof (book_path), directory_spec); // Pierre-Marie Baty -- use safe version
+    strncpy(book_path, directory_spec, sizeof book_path);
   directory_spec = getenv("CRAFTY_LOG_PATH");
   if (directory_spec)
-    strcpy_s(log_path, sizeof (log_path), directory_spec); // Pierre-Marie Baty -- use safe version
+    strncpy(log_path, directory_spec, sizeof log_path);
   directory_spec = getenv("CRAFTY_TB_PATH");
   if (directory_spec)
-    strcpy_s(tb_path, sizeof (tb_path), directory_spec); // Pierre-Marie Baty -- use safe version
+    strncpy(tb_path, directory_spec, sizeof tb_path);
   directory_spec = getenv("CRAFTY_RC_PATH");
   if (directory_spec)
-    strcpy_s(rc_path, sizeof (rc_path), directory_spec); // Pierre-Marie Baty -- use safe version
+    strncpy(rc_path, directory_spec, sizeof rc_path);
   if (getenv("CRAFTY_XBOARD")) {
-    Print(4095, "feature done=0\n");
+    Print(-1, "feature done=0\n");
-    done = 0;
+    xboard_done = 0;
   } else if (argc > 1 && !strcmp(argv[1], "xboard")) {
-    Print(4095, "feature done=0\n");
+    Print(-1, "feature done=0\n");
-    done = 0;
+    xboard_done = 0;
+  }
 /*
  ************************************************************
  *                                                          *
  *  First, parse the command-line options and pick off the  *
  *  ones that need to be handled before any initialization  *
  *  is attempted (mainly path commands at present.)         *
  *                                                          *
  ************************************************************
  */
-  AlignedMalloc((void **) &tree, 2048, (size_t) sizeof(TREE));
+  AlignedMalloc((void *) ((void *) &tree), 2048, (size_t) sizeof(TREE));
   block[0] = tree;
-  tree->parent = 0;
+  memset((void *) block[0], 0, sizeof(TREE));
-  tree->used = 1;
-  tree->stop = 0;
   tree->ply = 1;
-  tree->nprocs = 0;
-  tree->thread_id = 0;
   input_stream = stdin;
   for (i = 0; i < 512; i++)
     args[i] = (char *) malloc(256);
   if (argc > 1) {
     for (i = 1; i < argc; i++) {
-      if (strstr(argv[i], "path") || strstr(argv[i], "log")) {
+      if (strstr(argv[i], "path") || strstr(argv[i], "log") ||
+          strstr(argv[1], "affinity")) {
-        strcpy_s(buffer, sizeof (buffer), argv[i]); // Pierre-Marie Baty -- use safe version
+        strcpy(buffer, argv[i]);
         result = Option(tree);
         if (result == 0)
-          printf("ERROR \"%s\" is unknown command-line option\n", buffer);
+          Print(2048, "ERROR \"%s\" is unknown command-line option\n",
+              buffer);
         display = tree->position;
+      }
+    }
+  }
 /*
       sprintf(path, "%s/.craftyrc", pwd->pw_dir);
       input_stream = fopen(path, "r");
+    }
   if (input_stream)
 #else
-  sprintf_s(crafty_rc_file_spec, sizeof (crafty_rc_file_spec), "%s/crafty.rc", rc_path);
+  sprintf(crafty_rc_file_spec, "%s/crafty.rc", rc_path);
   if ((input_stream = fopen(crafty_rc_file_spec, "r")))
 #endif
     while (1) {
-      readstat = Read(1, buffer, sizeof (buffer)); // Pierre-Marie Baty -- use safe version
+      readstat = Read(1, buffer);
       if (readstat < 0)
         break;
       if (!strstr(buffer, "path"))
         continue;
       result = Option(tree);
       if (result == 0)
-        printf("ERROR \"%s\" is unknown rc-file option\n", buffer);
+        Print(2048, "ERROR \"%s\" is unknown rc-file option\n", buffer);
       if (input_stream == stdin)
         break;
+    }
-/*
- ************************************************************
- *                                                          *
- *  If NUMA is enabled, report on the current machine       *
- *  configuration.                                          *
- *                                                          *
- ************************************************************
- */
-#if defined(NUMA) && defined(UNIX)
-  if (numa_available() >= 0) {
-    unsigned long cpus[8];
-    numa_node_to_cpus(0, cpus, 64);
-    printf("\nMachine is NUMA, %d nodes (%d cpus/node)\n\n",
-        numa_max_node() + 1, PopCnt(cpus[0]));
-  }
-#endif
 /*
  ************************************************************
  *                                                          *
  *   Initialize all data arrays and chess board.            *
  *                                                          *
   if (argc > 1) {
     for (i = 1; i < argc; i++)
       if (strcmp(argv[i], "c"))
         if (!strstr(argv[i], "path")) {
           if (strlen(argv[i]) > 255)
-            Print(4095, "ERROR ignoring token %s, 255 character max\n",
+            Print(-1, "ERROR ignoring token %s, 255 character max\n",
                 argv[i]);
           else {
-            strcpy_s(buffer, sizeof (buffer), argv[i]); // Pierre-Marie Baty -- use safe version
+            strcpy(buffer, argv[i]);
-            Print(128, "(info) command line option \"%s\"\n", buffer);
+            Print(32, "(info) command line option \"%s\"\n", buffer);
             result = Option(tree);
             if (result == 0)
-              printf("ERROR \"%s\" is unknown command-line option\n", buffer);
+              Print(2048, "ERROR \"%s\" is unknown command-line option\n",
+                  buffer);
+          }
+        }
+  }
   display = tree->position;
   initialized = 1;
       sprintf(path, "%s/.craftyrc", pwd->pw_dir);
       input_stream = fopen(path, "r");
+    }
   if (input_stream)
 #else
-  sprintf_s(crafty_rc_file_spec, sizeof (crafty_rc_file_spec), "%s/crafty.rc", rc_path); // Pierre-Marie Baty -- use safe version
+  sprintf(crafty_rc_file_spec, "%s/crafty.rc", rc_path);
   if ((input_stream = fopen(crafty_rc_file_spec, "r")))
 #endif
     while (1) {
-      readstat = Read(1, buffer, sizeof (buffer));
+      readstat = Read(1, buffer);
       if (readstat < 0)
         break;
       if (strstr(buffer, "path"))
         continue;
       result = Option(tree);
       if (result == 0)
-        printf("ERROR \"%s\" is unknown rc-file option\n", buffer);
+        Print(2048, "ERROR \"%s\" is unknown rc-file option\n", buffer);
       if (input_stream == stdin)
         break;
+    }
   input_stream = stdin;
 #if defined(UNIX)
   if (xboard)
     signal(SIGINT, SIG_IGN);
 #endif
-  Print(128, "\nCrafty v%s (%d cpus)\n\n", version, Max(smp_max_threads, 1));
+  Print(32, "\nCrafty v%s (%d cpus)\n\n", version, Max(smp_max_threads, 1));
   NewGame(1);
 /*
  ************************************************************
  *                                                          *
  *  Check to see if we can find a "crafty.cpf" personality  *
  *                                                          *
  ************************************************************
  */
   if ((personality = fopen("crafty.cpf", "r"))) {
     fclose(personality);
-    Print(4095, "using default personality file \"crafty.cpf\"\n");
+    Print(-1, "using default personality file \"crafty.cpf\"\n");
-    sprintf_s(buffer, sizeof (buffer), "personality load crafty.cpf"); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer, "personality load crafty.cpf");
-    (void) Option(tree);
+    Option(tree);
+  }
 /*
  ************************************************************
  *                                                          *
  *  This is the "main loop" that never ends unless the user *
       opponent_start_time = ReadClock();
       input_status = 0;
       display = tree->position;
       move = 0;
       presult = 0;
-      if (done == 0 && xboard) {
+      if (xboard_done == 0 && xboard) {
-        done = 1;
+        xboard_done = 1;
-        Print(128, "feature done=1\n");
+        Print(-1, "feature done=1\n");
+      }
       do {
         if (presult != 2)
           presult = 0;
         result = 0;
         if (pong) {
-          Print(4095, "pong %d\n", pong);
+          Print(-1, "pong %d\n", pong);
           pong = 0;
+        }
         display = tree->position;
         if (presult != 2 && (move_number != 1 || !game_wtm))
           presult = Ponder(game_wtm);
         if (presult == 0 || presult == 2) {
           if (!xboard) {
             printf("%s(%d): ", SideToMove(game_wtm), move_number);
             fflush(stdout);
+          }
-          readstat = Read(1, buffer, sizeof (buffer));
+          readstat = Read(1, buffer);
           if (log_file)
             fprintf(log_file, "%s(%d): %s\n", SideToMove(game_wtm),
                 move_number, buffer);
           if (readstat < 0 && input_stream == stdin) {
-            strcpy_s(buffer, sizeof (buffer), "end"); // Pierre-Marie Baty -- use safe version
+            strcpy(buffer, "end");
-            (void) Option(tree);
+            Option(tree);
+          }
+        }
         if (presult == 1)
           break;
         opponent_end_time = ReadClock();
         result = Option(tree);
         if (result == 0) {
-          nargs = ReadParse(buffer, args, "     ;");
+          nargs = ReadParse(buffer, args, " \t;");
-          move = InputMove(tree, args[0], 0, game_wtm, 0, 0);
+          move = InputMove(tree, 0, game_wtm, 0, 0, args[0]);
           result = !move;
           if (move)
             last_pv.path[1] = 0;
         } else {
           input_status = 0;
  ************************************************************
  */
       if (result == 0) {
         fseek(history_file, ((move_number - 1) * 2 + 1 - game_wtm) * 10,
             SEEK_SET);
-        fprintf(history_file, "%9s\n", OutputMove(tree, move, 0, game_wtm));
+        fprintf(history_file, "%9s\n", OutputMove(tree, 0, game_wtm, move));
-        MakeMoveRoot(tree, move, game_wtm);
+        MakeMoveRoot(tree, game_wtm, move);
+        tree->curmv[0] = move;
         time_used_opponent = opponent_end_time - opponent_start_time;
         if (!force)
           Print(1, "              time used: %s\n",
               DisplayTime(time_used_opponent));
-        TimeAdjust(time_used_opponent, game_wtm);
+        TimeAdjust(game_wtm, time_used_opponent);
         game_wtm = Flip(game_wtm);
         if (game_wtm)
           move_number++;
         move_actually_played = 1;
         last_opponent_move = move;
  *  be satisfied with a draw, so we will claim it and end   *
  *  the current game.                                       *
  *                                                          *
  ************************************************************
  */
-        if ((draw_type = Repeat3x(tree, game_wtm)) == 1) {
+        if ((draw_type = Repeat3x(tree)) == 1) {
-          Print(128, "I claim a draw by 3-fold repetition.\n");
+          Print(1, "I claim a draw by 3-fold repetition.\n");
           value = DrawScore(game_wtm);
           if (xboard)
-            Print(4095, "1/2-1/2 {Drawn by 3-fold repetition}\n");
+            Print(-1, "1/2-1/2 {Drawn by 3-fold repetition}\n");
+        }
         if (draw_type == 2) {
-          Print(128, "I claim a draw by the 50 move rule.\n");
+          Print(1, "I claim a draw by the 50 move rule.\n");
           value = DrawScore(game_wtm);
           if (xboard)
-            Print(4095, "1/2-1/2 {Drawn by 50-move rule}\n");
+            Print(-1, "1/2-1/2 {Drawn by 50-move rule}\n");
+        }
         if (Drawn(tree, last_search_value) == 2) {
-          Print(128, "I claim a draw due to insufficient material.\n");
+          Print(1, "I claim a draw due to insufficient material.\n");
           if (xboard)
-            Print(4095, "1/2-1/2 {Insufficient material}\n");
+            Print(-1, "1/2-1/2 {Insufficient material}\n");
+        }
       } else {
         tree->status[1] = tree->status[0];
         presult = 0;
+      }
         presult = 0;
+    }
     ponder_move = 0;
     thinking = 1;
     if (presult != 1) {
-      strcpy_s(kibitz_text, sizeof (kibitz_text), "n/a"); // Pierre-Marie Baty -- use safe version
+      strcpy(kibitz_text, "n/a");
       last_pv.pathd = 0;
       last_pv.pathl = 0;
       display = tree->position;
       value = Iterate(game_wtm, think, 0);
+    }
       if (move_number < 40 || !accept_draws)
         drawsc = -300;
       if (value <= drawsc && (tc_increment != 0 ||
               tc_time_remaining[Flip(game_wtm)] >= 1000)) {
         if (xboard)
-          Print(4095, "offer draw\n");
+          Print(-1, "offer draw\n");
         else {
-          Print(128, "Draw accepted.\n");
+          Print(1, "Draw accepted.\n");
           if (audible_alarm)
             printf("%c", audible_alarm);
           if (speech) {
-            strcpy_s(announce, sizeof (announce), SPEAK); // Pierre-Marie Baty -- use safe version
+            strcpy(announce, "./speak ");
-            strcat_s(announce, sizeof (announce), " Drawaccept"); // Pierre-Marie Baty -- use safe version
+            strcat(announce, "Drawaccept");
-            system(announce);
+            v = system(announce);
+            if (v != 0)
+              perror("main() system() error: ");
+          }
+        }
-        Print(4095, "1/2-1/2 {Draw agreed}\n");
+        Print(-1, "1/2-1/2 {Draw agreed}\n");
-        strcpy_s(pgn_result, sizeof (pgn_result), "1/2-1/2");
+        strcpy(pgn_result, "1/2-1/2");
       } else {
-        if (!xboard)
+        if (!xboard) {
-          Print(4095, "Draw declined.\n");
+          Print(1, "Draw declined.\n");
+          if (speech) {
+            strcpy(announce, "./speak ");
+            strcat(announce, "Drawdecline");
+            v = system(announce);
+            if (v != 0)
+              perror("main() system() error: ");
+          }
+        }
+      }
+    }
 /*
  ************************************************************
  *                                                          *
     thinking = 0;
     if (!last_pv.pathl) {
       if (value == -MATE + 1) {
         over = 1;
         if (game_wtm) {
-          Print(4095, "0-1 {Black mates}\n");
+          Print(-1, "0-1 {Black mates}\n");
-          strcpy_s(pgn_result, sizeof (pgn_result), "0-1"); // Pierre-Marie Baty -- use safe version
+          strcpy(pgn_result, "0-1");
         } else {
-          Print(4095, "1-0 {White mates}\n");
+          Print(-1, "1-0 {White mates}\n");
-          strcpy_s(pgn_result, sizeof (pgn_result), "1-0"); // Pierre-Marie Baty -- use safe version
+          strcpy(pgn_result, "1-0");
+        }
         if (speech) {
-          strcpy_s(announce, sizeof (announce), SPEAK); // Pierre-Marie Baty -- use safe version
+          strcpy(announce, "./speak ");
-          strcat_s(announce, sizeof (announce), " Checkmate"); // Pierre-Marie Baty -- use safe version
+          strcat(announce, "Checkmate");
-          system(announce);
+          v = system(announce);
+          if (v != 0)
+            perror("main() system() error: ");
+        }
       } else {
         over = 1;
         if (!xboard) {
-          Print(128, "stalemate\n");
+          Print(1, "stalemate\n");
           if (speech) {
-            strcpy_s(announce, sizeof (announce), SPEAK); // Pierre-Marie Baty -- use safe version
+            strcpy(announce, "./speak ");
-            strcat_s(announce, sizeof (announce), " Stalemate"); // Pierre-Marie Baty -- use safe version
+            strcat(announce, "Stalemate");
-            system(announce);
+            v = system(announce);
+            if (v != 0)
+              perror("main() system() error: ");
+          }
         } else
-          Print(4095, "1/2-1/2 {stalemate}\n");
+          Print(-1, "1/2-1/2 {stalemate}\n");
+      }
     } else {
       if (value > 32000 && value < MATE - 2) {
-        Print(128, "\nmate in %d moves.\n\n", (MATE - value) / 2);
+        Print(1, "\nmate in %d moves.\n\n", (MATE - value) / 2);
         Kibitz(1, game_wtm, 0, 0, (MATE - value) / 2, tree->nodes_searched, 0,
 , " ");
       } else if (-value > 32000 && -value < MATE - 1) {
-        Print(128, "\nmated in %d moves.\n\n", (MATE + value) / 2);
+        Print(1, "\nmated in %d moves.\n\n", (MATE + value) / 2);
         Kibitz(1, game_wtm, 0, 0, -(MATE + value) / 2, tree->nodes_searched,
 , 0, " ");
+      }
 /*
  ************************************************************
  *  "result" string if this move checkmates our opponent.   *
  *                                                          *
  ************************************************************
  */
       if (speech) {
-        char *moveptr = OutputMove(tree, last_pv.path[1], 0, game_wtm);
+        char *moveptr = OutputMove(tree, 0, game_wtm, last_pv.path[1]);
-        strcpy_s(announce, sizeof (announce), SPEAK); // Pierre-Marie Baty -- use safe version
+        strcpy(announce, "./speak ");
-        strcat_s(announce, sizeof (announce), moveptr); // Pierre-Marie Baty -- use safe version
+        strcat(announce, moveptr);
+        strcat(announce, " &");
-        system(announce);
+        v = system(announce);
+        if (v != 0)
+          perror("main() system() error: ");
+      }
       if (!xboard && audible_alarm)
         printf("%c", audible_alarm);
       Print(1, "%s(%d): %s\n", SideToMove(game_wtm), move_number,
-          OutputMove(tree, last_pv.path[1], 0, game_wtm));
+          OutputMove(tree, 0, game_wtm, last_pv.path[1]));
       if (xboard)
-        printf("move %s\n", OutputMove(tree, last_pv.path[1], 0, game_wtm));
+        printf("move %s\n", OutputMove(tree, 0, game_wtm, last_pv.path[1]));
+      fflush(stdout);
       if (value == MATE - 2) {
         if (game_wtm) {
-          Print(4095, "1-0 {White mates}\n");
+          Print(-1, "1-0 {White mates}\n");
-          strcpy_s(pgn_result, sizeof (pgn_result), "1-0"); // Pierre-Marie Baty -- use safe version
+          strcpy(pgn_result, "1-0");
         } else {
-          Print(4095, "0-1 {Black mates}\n");
+          Print(-1, "0-1 {Black mates}\n");
-          strcpy_s(pgn_result, sizeof (pgn_result), "0-1"); // Pierre-Marie Baty -- use safe version
+          strcpy(pgn_result, "0-1");
+        }
+      }
       time_used = program_end_time - program_start_time;
       Print(1, "              time used: %s\n", DisplayTime(time_used));
-      TimeAdjust(time_used, game_wtm);
+      TimeAdjust(game_wtm, time_used);
       fseek(history_file, ((move_number - 1) * 2 + 1 - game_wtm) * 10,
           SEEK_SET);
-      fprintf(history_file, "%9s\n", OutputMove(tree, last_pv.path[1], 0,
+      fprintf(history_file, "%9s\n", OutputMove(tree, 0, game_wtm,
-              game_wtm));
+              last_pv.path[1]));
       last_search_value = value;
       if (kibitz) {
         if (kibitz_depth)
           Kibitz(2, game_wtm, kibitz_depth, end_time - start_time, value,
-              tree->nodes_searched, idle_percent,
+              tree->nodes_searched, busy_percent, (int) tree->egtb_hits, // Pierre-Marie Baty -- added type cast
-              tree->egtb_probes_successful, kibitz_text);
+              kibitz_text);
         else
           Kibitz(4, game_wtm, 0, 0, 0, 0, 0, 0, kibitz_text);
+      }
-      MakeMoveRoot(tree, last_pv.path[1], game_wtm);
+      MakeMoveRoot(tree, game_wtm, last_pv.path[1]);
+      tree->curmv[0] = move;
 /*
  ************************************************************
  *                                                          *
  *  From this point forward, we are in a state where it is  *
  *                                                          *
  */
       game_wtm = Flip(game_wtm);
       if (game_wtm)
         move_number++;
       move_actually_played = 1;
-      if ((draw_type = Repeat3x(tree, game_wtm)) == 1) {
+      if ((draw_type = Repeat3x(tree)) == 1) {
-        Print(128, "I claim a draw by 3-fold repetition after my move.\n");
+        Print(1, "I claim a draw by 3-fold repetition after my move.\n");
         if (xboard)
-          Print(4095, "1/2-1/2 {Drawn by 3-fold repetition}\n");
+          Print(-1, "1/2-1/2 {Drawn by 3-fold repetition}\n");
         value = DrawScore(game_wtm);
+      }
       if (draw_type == 2 && last_search_value < 32000) {
-        Print(128, "I claim a draw by the 50 move rule after my move.\n");
+        Print(1, "I claim a draw by the 50 move rule after my move.\n");
         if (xboard)
-          Print(4095, "1/2-1/2 {Drawn by 50-move rule}\n");
+          Print(-1, "1/2-1/2 {Drawn by 50-move rule}\n");
         value = DrawScore(game_wtm);
+      }
       if (Drawn(tree, last_search_value) == 2) {
-        Print(128,
+        Print(1,
             "I claim a draw due to insufficient material after my move.\n");
         if (xboard)
-          Print(4095, "1/2-1/2 {Insufficient material}\n");
+          Print(-1, "1/2-1/2 {Insufficient material}\n");
+      }
 #if !defined(TEST)
       if (time_limit > 300)
 #endif
         if (log_file)
         last_pv.pathd -= 2;
         if (last_pv.pathd > last_pv.pathl)
           last_pv.pathd = last_pv.pathl;
         if (last_pv.pathl == 0)
           last_pv.pathd = 0;
+        tree->pv[0] = last_pv;
       } else {
         last_pv.pathd = 0;
         last_pv.pathl = 0;
         ponder_move = 0;
+        tree->pv[0] = last_pv;
+      }
+    }
 #if defined(TEST)
-    strcpy_s(buffer, sizeof (buffer), "score"); // Pierre-Marie Baty -- use safe version
+    strcpy(buffer, "score");
     Option(tree);
 #endif
     if ((i = GameOver(game_wtm))) {
       if (i == 1)
-        Print(4095, "1/2-1/2 {stalemate}\n");
+        Print(-1, "1/2-1/2 {stalemate}\n");
+    }
     if (book_move) {
       moves_out_of_book = 0;
       predicted++;
       if (ponder_move)
-        sprintf_s(book_hint, sizeof (book_hint), "%s", OutputMove(tree, ponder_move, 0, game_wtm)); // Pierre-Marie Baty -- use safe version
+        sprintf(book_hint, "%s", OutputMove(tree, 0, game_wtm, ponder_move));
     } else
       moves_out_of_book++;
 #if defined(DEBUG)
     ValidatePosition(tree, 0, last_pv.path[1], "Main(2)");
 #endif
       learn_seekto[learn_positions_count] = book_learn_seekto;
       learn_key[learn_positions_count] = book_learn_key;
       learn_nmoves[learn_positions_count++] = book_learn_nmoves;
+    }
     if (mode == tournament_mode) {
-      strcpy_s(buffer, sizeof (buffer), "clock"); // Pierre-Marie Baty -- use safe version
+      strcpy(buffer, "clock");
       Option(tree);
-      Print(128, "if clocks are wrong, use 'settc' command to adjust them\n");
+      Print(32, "if clocks are wrong, use 'settc' command to adjust them\n");
+    }
+  }
+}

Subversion Repositories Games.Chess Giants

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