Rename MoveStack to ExtMove

Stack has no meaning here, while ExtMove (extended move),
better clarifies that we have a move + a score.

No functional change.

src/movegen.cpp

@@ -32,7 +32,7 @@
 namespace {
 
   template<CastlingSide Side, bool Checks, bool Chess960>
-  MoveStack* generate_castle(const Position& pos, MoveStack* mlist, Color us) {
+  ExtMove* generate_castle(const Position& pos, ExtMove* mlist, Color us) {
 
     if (pos.castle_impeded(us, Side) || !pos.can_castle(make_castle_right(us, Side)))
         return mlist;
@@ -69,8 +69,8 @@ namespace {
 
 
   template<GenType Type, Square Delta>
-  inline MoveStack* generate_promotions(MoveStack* mlist, Bitboard pawnsOn7,
+  inline ExtMove* generate_promotions(ExtMove* mlist, Bitboard pawnsOn7,
-                                        Bitboard target, const CheckInfo* ci) {
+                                      Bitboard target, const CheckInfo* ci) {
 
     Bitboard b = shift_bb<Delta>(pawnsOn7) & target;
 
@@ -101,8 +101,8 @@ namespace {
 
 
   template<Color Us, GenType Type>
-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist,
+  ExtMove* generate_pawn_moves(const Position& pos, ExtMove* mlist,
-                                 Bitboard target, const CheckInfo* ci) {
+                               Bitboard target, const CheckInfo* ci) {
 
     // Compute our parametrized parameters at compile time, named according to
     // the point of view of white side.
@@ -206,8 +206,8 @@ namespace {
 
 
   template<PieceType Pt, bool Checks> FORCE_INLINE
-  MoveStack* generate_moves(const Position& pos, MoveStack* mlist, Color us,
+  ExtMove* generate_moves(const Position& pos, ExtMove* mlist, Color us,
-                            Bitboard target, const CheckInfo* ci) {
+                          Bitboard target, const CheckInfo* ci) {
 
     assert(Pt != KING && Pt != PAWN);
 
@@ -238,8 +238,8 @@ namespace {
 
 
   template<GenType Type> FORCE_INLINE
-  MoveStack* generate_all(const Position& pos, MoveStack* mlist, Color us,
+  ExtMove* generate_all(const Position& pos, ExtMove* mlist, Color us,
-                          Bitboard target, const CheckInfo* ci = NULL) {
+                        Bitboard target, const CheckInfo* ci = NULL) {
 
     const bool Checks = Type == QUIET_CHECKS;
 
@@ -289,7 +289,7 @@ namespace {
 /// non-captures. Returns a pointer to the end of the move list.
 
 template<GenType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
+ExtMove* generate(const Position& pos, ExtMove* mlist) {
 
   assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS);
   assert(!pos.checkers());
@@ -304,15 +304,15 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
 }
 
 // Explicit template instantiations
-template MoveStack* generate<CAPTURES>(const Position&, MoveStack*);
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
-template MoveStack* generate<QUIETS>(const Position&, MoveStack*);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
-template MoveStack* generate<NON_EVASIONS>(const Position&, MoveStack*);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);
 
 
 /// generate<QUIET_CHECKS> generates all pseudo-legal non-captures and knight
 /// underpromotions that give check. Returns a pointer to the end of the move list.
 template<>
-MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* mlist) {
 
   assert(!pos.checkers());
 
@@ -342,7 +342,7 @@ MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
 /// generate<EVASIONS> generates all pseudo-legal check evasions when the side
 /// to move is in check. Returns a pointer to the end of the move list.
 template<>
-MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* mlist) {
 
   assert(pos.checkers());
 
@@ -404,9 +404,9 @@ MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
 /// generate<LEGAL> generates all the legal moves in the given position
 
 template<>
-MoveStack* generate<LEGAL>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* mlist) {
 
-  MoveStack *end, *cur = mlist;
+  ExtMove *end, *cur = mlist;
   Bitboard pinned = pos.pinned_pieces();
   Square ksq = pos.king_square(pos.side_to_move());
 

src/movegen.h

@@ -34,7 +34,7 @@ enum GenType {
 class Position;
 
 template<GenType>
-MoveStack* generate(const Position& pos, MoveStack* mlist);
+ExtMove* generate(const Position& pos, ExtMove* mlist);
 
 /// The MoveList struct is a simple wrapper around generate(), sometimes comes
 /// handy to use this class instead of the low level generate() function.
@@ -46,13 +46,13 @@ struct MoveList {
   Move operator*() const { return cur->move; }
   size_t size() const { return last - mlist; }
   bool contains(Move m) const {
-    for (const MoveStack* it(mlist); it != last; ++it) if (it->move == m) return true;
+    for (const ExtMove* it(mlist); it != last; ++it) if (it->move == m) return true;
     return false;
   }
 
 private:
-  MoveStack mlist[MAX_MOVES];
+  ExtMove mlist[MAX_MOVES];
-  MoveStack *cur, *last;
+  ExtMove *cur, *last;
 };
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

@@ -36,9 +36,9 @@ namespace {
   };
 
   // Our insertion sort, guaranteed to be stable, as is needed
-  void insertion_sort(MoveStack* begin, MoveStack* end)
+  void insertion_sort(ExtMove* begin, ExtMove* end)
   {
-    MoveStack tmp, *p, *q;
+    ExtMove tmp, *p, *q;
 
     for (p = begin + 1; p < end; ++p)
     {
@@ -51,12 +51,12 @@ namespace {
 
   // Unary predicate used by std::partition to split positive scores from remaining
   // ones so to sort separately the two sets, and with the second sort delayed.
-  inline bool has_positive_score(const MoveStack& ms) { return ms.score > 0; }
+  inline bool has_positive_score(const ExtMove& ms) { return ms.score > 0; }
 
   // Picks and moves to the front the best move in the range [begin, end),
   // it is faster than sorting all the moves in advance when moves are few, as
   // normally are the possible captures.
-  inline MoveStack* pick_best(MoveStack* begin, MoveStack* end)
+  inline ExtMove* pick_best(ExtMove* begin, ExtMove* end)
   {
       std::swap(*begin, *std::max_element(begin, end));
       return begin;
@@ -170,7 +170,7 @@ void MovePicker::score<CAPTURES>() {
   // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
   Move m;
 
-  for (MoveStack* it = moves; it != end; ++it)
+  for (ExtMove* it = moves; it != end; ++it)
   {
       m = it->move;
       it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
@@ -189,7 +189,7 @@ void MovePicker::score<QUIETS>() {
 
   Move m;
 
-  for (MoveStack* it = moves; it != end; ++it)
+  for (ExtMove* it = moves; it != end; ++it)
   {
       m = it->move;
       it->score = history[pos.piece_moved(m)][to_sq(m)];
@@ -204,7 +204,7 @@ void MovePicker::score<EVASIONS>() {
   Move m;
   int seeScore;
 
-  for (MoveStack* it = moves; it != end; ++it)
+  for (ExtMove* it = moves; it != end; ++it)
   {
       m = it->move;
       if ((seeScore = pos.see_sign(m)) < 0)

src/movepick.h

@@ -100,11 +100,11 @@ private:
   Move* countermoves;
   Depth depth;
   Move ttMove;
-  MoveStack killers[4];
+  ExtMove killers[4];
   Square recaptureSquare;
   int captureThreshold, phase;
-  MoveStack *cur, *end, *endQuiets, *endBadCaptures;
+  ExtMove *cur, *end, *endQuiets, *endBadCaptures;
-  MoveStack moves[MAX_MOVES];
+  ExtMove moves[MAX_MOVES];
 };
 
 #endif // !defined(MOVEPICK_H_INCLUDED)

src/types.h

@@ -313,12 +313,12 @@ inline Score operator/(Score s, int i) {
 
 extern Value PieceValue[PHASE_NB][PIECE_NB];
 
-struct MoveStack {
+struct ExtMove {
   Move move;
   int score;
 };
 
-inline bool operator<(const MoveStack& f, const MoveStack& s) {
+inline bool operator<(const ExtMove& f, const ExtMove& s) {
   return f.score < s.score;
 }