Rename getters functions removing 'get_' prefix

Follow the suggested Qt style:

http://doc.qt.nokia.com/qq/qq13-apis.html

It seems to me simpler and easier to read.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

src/benchmark.cpp

@@ -107,7 +107,7 @@ void benchmark(int argc, char* argv[]) {
 
   // Ok, let's start the benchmark !
   totalNodes = 0;
-  time = get_system_time();
+  time = system_time();
 
   for (size_t i = 0; i < fenList.size(); i++)
   {
@@ -131,7 +131,7 @@ void benchmark(int argc, char* argv[]) {
       }
   }
 
-  time = get_system_time() - time;
+  time = system_time() - time;
 
   cerr << "\n==============================="
        << "\nTotal time (ms) : " << time

src/book.cpp

@@ -349,7 +349,7 @@ namespace {
 /// Book c'tor. Make random number generation less deterministic, for book moves
 Book::Book() : bookSize(0) {
 
-  for (int i = abs(get_system_time() % 10000); i > 0; i--)
+  for (int i = abs(system_time() % 10000); i > 0; i--)
       RKiss.rand<unsigned>();
 }
 

src/endgame.cpp

@@ -87,7 +87,7 @@ namespace {
     fen += string(1, '0' + int(8 - keyCode.length())) + "/8/8/8/8/8/8/8 w - - 0 10";
 
     // Build a Position out of the fen string and get its material key
-    return Position(fen, false, 0).get_material_key();
+    return Position(fen, false, 0).material_key();
   }
 
 } // namespace

src/evaluate.cpp

@@ -288,7 +288,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
   margins[WHITE] = margins[BLACK] = VALUE_ZERO;
 
   // Probe the material hash table
-  ei.mi = Threads[pos.thread()].materialTable.get_material_info(pos);
+  ei.mi = Threads[pos.thread()].materialTable.material_info(pos);
   score += ei.mi->material_value();
 
   // If we have a specialized evaluation function for the current material
@@ -300,7 +300,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
   }
 
   // Probe the pawn hash table
-  ei.pi = Threads[pos.thread()].pawnTable.get_pawn_info(pos);
+  ei.pi = Threads[pos.thread()].pawnTable.pawn_info(pos);
   score += ei.pi->pawns_value();
 
   // Initialize attack and king safety bitboards

src/material.cpp

@@ -90,15 +90,15 @@ void MaterialInfoTable::init() { Base::init(); if (!funcs) funcs = new Endgames(
 MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
 
 
-/// MaterialInfoTable::get_material_info() takes a position object as input,
+/// MaterialInfoTable::material_info() takes a position object as input,
 /// computes or looks up a MaterialInfo object, and returns a pointer to it.
 /// If the material configuration is not already present in the table, it
 /// is stored there, so we don't have to recompute everything when the
 /// same material configuration occurs again.
 
-MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
+MaterialInfo* MaterialInfoTable::material_info(const Position& pos) const {
 
-  Key key = pos.get_material_key();
+  Key key = pos.material_key();
   MaterialInfo* mi = probe(key);
 
   // If mi->key matches the position's material hash key, it means that we

src/material.h

@@ -68,13 +68,13 @@ private:
 
 
 /// The MaterialInfoTable class represents a pawn hash table. The most important
-/// method is get_material_info, which returns a pointer to a MaterialInfo object.
+/// method is material_info(), which returns a pointer to a MaterialInfo object.
 
 class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
 public:
   ~MaterialInfoTable();
   void init();
-  MaterialInfo* get_material_info(const Position& pos) const;
+  MaterialInfo* material_info(const Position& pos) const;
   static Phase game_phase(const Position& pos);
 
 private:

src/misc.cpp

@@ -134,9 +134,9 @@ void dbg_before() { dbg_hit_on(false); }
 void dbg_after()  { dbg_hit_on(true); dbg_hit_cnt0--; }
 
 
-/// get_system_time() returns the current system time, measured in milliseconds
+/// system_time() returns the current system time, measured in milliseconds
 
-int get_system_time() {
+int system_time() {
 
 #if defined(_MSC_VER)
   struct _timeb t;

src/misc.h

@@ -28,7 +28,7 @@
 
 extern const std::string engine_name();
 extern const std::string engine_authors();
-extern int get_system_time();
+extern int system_time();
 extern int cpu_count();
 extern void timed_wait(WaitCondition*, Lock*, int);
 extern void prefetch(char* addr);

src/movepick.cpp

@@ -232,7 +232,7 @@ void MovePicker::go_next_phase() {
 /// MovePicker::score_captures(), MovePicker::score_noncaptures() and
 /// MovePicker::score_evasions() assign a numerical move ordering score
 /// to each move in a move list.  The moves with highest scores will be
-/// picked first by get_next_move().
+/// picked first by next_move().
 
 void MovePicker::score_captures() {
   // Winning and equal captures in the main search are ordered by MVV/LVA.
@@ -300,14 +300,14 @@ void MovePicker::score_evasions() {
   }
 }
 
-/// MovePicker::get_next_move() is the most important method of the MovePicker
+/// MovePicker::next_move() is the most important method of the MovePicker class.
-/// class. It returns a new pseudo legal move every time it is called, until there
+/// It returns a new pseudo legal move every time it is called, until there
 /// are no more moves left. It picks the move with the biggest score from a list
 /// of generated moves taking care not to return the tt move if has already been
 /// searched previously. Note that this function is not thread safe so should be
 /// lock protected by caller when accessed through a shared MovePicker object.
 
-Move MovePicker::get_next_move() {
+Move MovePicker::next_move() {
 
   Move move;
 

src/movepick.h

@@ -28,7 +28,7 @@
 /// MovePicker is a class which is used to pick one pseudo legal move at a time
 /// from the current position. It is initialized with a Position object and a few
 /// moves we have reason to believe are good. The most important method is
-/// MovePicker::get_next_move(), which returns a new pseudo legal move each time
+/// MovePicker::next_move(), which returns a new pseudo legal move each time
 /// it is called, until there are no moves left, when MOVE_NONE is returned.
 /// In order to improve the efficiency of the alpha beta algorithm, MovePicker
 /// attempts to return the moves which are most likely to get a cut-off first.
@@ -41,7 +41,7 @@ public:
   MovePicker(const Position&, Move, Depth, const History&, Search::Stack*, Value);
   MovePicker(const Position&, Move, Depth, const History&, Square recaptureSq);
   MovePicker(const Position&, Move, const History&, PieceType parentCapture);
-  Move get_next_move();
+  Move next_move();
 
 private:
   void score_captures();

src/pawns.cpp

@@ -72,14 +72,14 @@ namespace {
 }
 
 
-/// PawnInfoTable::get_pawn_info() takes a position object as input, computes
+/// PawnInfoTable::pawn_info() takes a position object as input, computes
 /// a PawnInfo object, and returns a pointer to it. The result is also stored
 /// in an hash table, so we don't have to recompute everything when the same
 /// pawn structure occurs again.
 
-PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
+PawnInfo* PawnInfoTable::pawn_info(const Position& pos) const {
 
-  Key key = pos.get_pawn_key();
+  Key key = pos.pawn_key();
   PawnInfo* pi = probe(key);
 
   // If pi->key matches the position's pawn hash key, it means that we

src/pawns.h

@@ -29,9 +29,9 @@ const int PawnTableSize = 16384;
 /// PawnInfo is a class which contains various information about a pawn
 /// structure. Currently, it only includes a middle game and an end game
 /// pawn structure evaluation, and a bitboard of passed pawns. We may want
-/// to add further information in the future. A lookup to the pawn hash table
+/// to add further information in the future. A lookup to the pawn hash
-/// (performed by calling the get_pawn_info method in a PawnInfoTable object)
+/// table (performed by calling the pawn_info method in a PawnInfoTable
-/// returns a pointer to a PawnInfo object.
+/// object) returns a pointer to a PawnInfo object.
 
 class PawnInfo {
 
@@ -63,11 +63,11 @@ private:
 
 
 /// The PawnInfoTable class represents a pawn hash table. The most important
-/// method is get_pawn_info, which returns a pointer to a PawnInfo object.
+/// method is pawn_info, which returns a pointer to a PawnInfo object.
 
 class PawnInfoTable : public SimpleHash<PawnInfo, PawnTableSize> {
 public:
-  PawnInfo* get_pawn_info(const Position& pos) const;
+  PawnInfo* pawn_info(const Position& pos) const;
 
 private:
   template<Color Us>

src/position.cpp

@@ -731,7 +731,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   assert(&newSt != st);
 
   nodes++;
-  Key key = st->key;
+  Key k = st->key;
 
   // Copy some fields of old state to our new StateInfo object except the ones
   // which are recalculated from scratch anyway, then switch our state pointer
@@ -750,7 +750,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   st = &newSt;
 
   // Update side to move
-  key ^= zobSideToMove;
+  k ^= zobSideToMove;
 
   // Increment the 50 moves rule draw counter. Resetting it to zero in the
   // case of non-reversible moves is taken care of later.
@@ -759,7 +759,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
 
   if (is_castle(m))
   {
-      st->key = key;
+      st->key = k;
       do_castle_move<true>(m);
       return;
   }
@@ -820,7 +820,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
       pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
 
       // Update hash keys
-      key ^= zobrist[them][capture][capsq];
+      k ^= zobrist[them][capture][capsq];
       st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
 
       // Update incremental scores
@@ -831,12 +831,12 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   }
 
   // Update hash key
-  key ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
+  k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
 
   // Reset en passant square
   if (st->epSquare != SQ_NONE)
   {
-      key ^= zobEp[st->epSquare];
+      k ^= zobEp[st->epSquare];
       st->epSquare = SQ_NONE;
   }
 
@@ -844,13 +844,13 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   if (    st->castleRights != CASTLES_NONE
       && (castleRightsMask[from] & castleRightsMask[to]) != ALL_CASTLES)
   {
-      key ^= zobCastle[st->castleRights];
+      k ^= zobCastle[st->castleRights];
       st->castleRights &= castleRightsMask[from] & castleRightsMask[to];
-      key ^= zobCastle[st->castleRights];
+      k ^= zobCastle[st->castleRights];
   }
 
   // Prefetch TT access as soon as we know key is updated
-  prefetch((char*)TT.first_entry(key));
+  prefetch((char*)TT.first_entry(k));
 
   // Move the piece
   Bitboard move_bb = make_move_bb(from, to);
@@ -874,7 +874,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
           && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(PAWN, them)))
       {
           st->epSquare = Square((from + to) / 2);
-          key ^= zobEp[st->epSquare];
+          k ^= zobEp[st->epSquare];
       }
 
       if (is_promotion(m))
@@ -899,7 +899,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
           pieceList[us][promotion][index[to]] = to;
 
           // Update hash keys
-          key ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
+          k ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
           st->pawnKey ^= zobrist[us][PAWN][to];
           st->materialKey ^=  zobrist[us][promotion][pieceCount[us][promotion]++]
                             ^ zobrist[us][PAWN][pieceCount[us][PAWN]];
@@ -930,7 +930,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   st->capturedType = capture;
 
   // Update the key with the final value
-  st->key = key;
+  st->key = k;
 
   // Update checkers bitboard, piece must be already moved
   st->checkersBB = 0;

src/position.h

@@ -173,10 +173,10 @@ public:
   int see_sign(Move m) const;
 
   // Accessing hash keys
-  Key get_key() const;
+  Key key() const;
-  Key get_exclusion_key() const;
+  Key exclusion_key() const;
-  Key get_pawn_key() const;
+  Key pawn_key() const;
-  Key get_material_key() const;
+  Key material_key() const;
 
   // Incremental evaluation
   Score value() const;
@@ -394,19 +394,19 @@ inline bool Position::pawn_is_passed(Color c, Square s) const {
   return !(pieces(PAWN, flip(c)) & passed_pawn_mask(c, s));
 }
 
-inline Key Position::get_key() const {
+inline Key Position::key() const {
   return st->key;
 }
 
-inline Key Position::get_exclusion_key() const {
+inline Key Position::exclusion_key() const {
   return st->key ^ zobExclusion;
 }
 
-inline Key Position::get_pawn_key() const {
+inline Key Position::pawn_key() const {
   return st->pawnKey;
 }
 
-inline Key Position::get_material_key() const {
+inline Key Position::material_key() const {
   return st->materialKey;
 }
 

src/search.cpp

@@ -190,7 +190,7 @@ namespace {
     MovePickerExt(const Position& p, Move ttm, Depth d, const History& h, Stack* ss, Value b)
                   : MovePicker(p, ttm, d, h, ss, b), mp(ss->sp->mp) {}
 
-    Move get_next_move() { return mp->get_next_move(); }
+    Move next_move() { return mp->next_move(); }
     MovePicker* mp;
   };
 
@@ -653,7 +653,7 @@ namespace {
     // We don't want the score of a partial search to overwrite a previous full search
     // TT value, so we use a different position key in case of an excluded move.
     excludedMove = ss->excludedMove;
-    posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
+    posKey = excludedMove ? pos.exclusion_key() : pos.key();
     tte = TT.probe(posKey);
     ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
 
@@ -816,7 +816,7 @@ namespace {
         MovePicker mp(pos, ttMove, H, pos.captured_piece_type());
         CheckInfo ci(pos);
 
-        while ((move = mp.get_next_move()) != MOVE_NONE)
+        while ((move = mp.next_move()) != MOVE_NONE)
             if (pos.pl_move_is_legal(move, ci.pinned))
             {
                 pos.do_move(move, st, ci, pos.move_gives_check(move, ci));
@@ -867,7 +867,7 @@ split_point_start: // At split points actual search starts from here
     // Step 11. Loop through moves
     // Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
-           && (move = mp.get_next_move()) != MOVE_NONE
+           && (move = mp.next_move()) != MOVE_NONE
            && !thread.cutoff_occurred())
     {
       assert(is_ok(move));
@@ -1220,7 +1220,7 @@ split_point_start: // At split points actual search starts from here
 
     // Transposition table lookup. At PV nodes, we don't use the TT for
     // pruning, but only for move ordering.
-    tte = TT.probe(pos.get_key());
+    tte = TT.probe(pos.key());
     ttMove = (tte ? tte->move() : MOVE_NONE);
 
     if (!PvNode && tte && can_return_tt(tte, ttDepth, beta, ss->ply))
@@ -1252,7 +1252,7 @@ split_point_start: // At split points actual search starts from here
         if (bestValue >= beta)
         {
             if (!tte)
-                TT.store(pos.get_key(), value_to_tt(bestValue, ss->ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
+                TT.store(pos.key(), value_to_tt(bestValue, ss->ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
 
             return bestValue;
         }
@@ -1273,7 +1273,7 @@ split_point_start: // At split points actual search starts from here
 
     // Loop through the moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
-           && (move = mp.get_next_move()) != MOVE_NONE)
+           && (move = mp.next_move()) != MOVE_NONE)
     {
       assert(is_ok(move));
 
@@ -1373,7 +1373,7 @@ split_point_start: // At split points actual search starts from here
     vt   = bestValue <= oldAlpha ? VALUE_TYPE_UPPER
          : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT;
 
-    TT.store(pos.get_key(), value_to_tt(bestValue, ss->ply), vt, ttDepth, move, ss->eval, evalMargin);
+    TT.store(pos.key(), value_to_tt(bestValue, ss->ply), vt, ttDepth, move, ss->eval, evalMargin);
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
@@ -1602,9 +1602,9 @@ split_point_start: // At split points actual search starts from here
     static int searchStartTime;
 
     if (reset)
-        searchStartTime = get_system_time();
+        searchStartTime = system_time();
 
-    return get_system_time() - searchStartTime;
+    return system_time() - searchStartTime;
   }
 
 
@@ -1768,7 +1768,7 @@ split_point_start: // At split points actual search starts from here
     static RKISS rk;
 
     // PRNG sequence should be not deterministic
-    for (int i = abs(get_system_time() % 50); i > 0; i--)
+    for (int i = abs(system_time() % 50); i > 0; i--)
         rk.rand<unsigned>();
 
     // RootMoves are already sorted by score in descending order
@@ -1821,7 +1821,7 @@ split_point_start: // At split points actual search starts from here
     pv.push_back(m);
     pos.do_move(m, *st++);
 
-    while (   (tte = TT.probe(pos.get_key())) != NULL
+    while (   (tte = TT.probe(pos.key())) != NULL
            && tte->move() != MOVE_NONE
            && pos.is_pseudo_legal(tte->move())
            && pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
@@ -1853,7 +1853,7 @@ split_point_start: // At split points actual search starts from here
     assert(pv[ply] != MOVE_NONE && pos.is_pseudo_legal(pv[ply]));
 
     do {
-        k = pos.get_key();
+        k = pos.key();
         tte = TT.probe(k);
 
         // Don't overwrite existing correct entries
@@ -1971,9 +1971,9 @@ void do_timer_event() {
   static int lastInfoTime;
   int e = elapsed_time();
 
-  if (get_system_time() - lastInfoTime >= 1000 || !lastInfoTime)
+  if (system_time() - lastInfoTime >= 1000 || !lastInfoTime)
   {
-      lastInfoTime = get_system_time();
+      lastInfoTime = system_time();
 
       dbg_print_mean();
       dbg_print_hit_rate();

src/uci.cpp

@@ -117,9 +117,9 @@ void uci_loop() {
       }
 
       else if (token == "key")
-          cout << "key: " << hex     << pos.get_key()
+          cout << "key: " << hex     << pos.key()
-               << "\nmaterial key: " << pos.get_material_key()
+               << "\nmaterial key: " << pos.material_key()
-               << "\npawn key: "     << pos.get_pawn_key() << endl;
+               << "\npawn key: "     << pos.pawn_key() << endl;
 
       else if (token == "uci")
           cout << "id name "     << engine_name()
@@ -251,11 +251,11 @@ namespace {
     if (!(is >> depth))
         return;
 
-    time = get_system_time();
+    time = system_time();
 
     int64_t n = Search::perft(pos, depth * ONE_PLY);
 
-    time = get_system_time() - time;
+    time = system_time() - time;
 
     std::cout << "\nNodes " << n
               << "\nTime (ms) " << time