Ticket #148: changes2.diff

gnugo/engine/board.h

@@ -36 +36 @@
  * character access is very slow.
  */
 
+/* simple test for old machines */
+#if SIZEOF_INT >= 4
+#define INT_INTERSECTION
+typedef int Intersection;
+#else
 typedef unsigned char Intersection;
+#endif
 
 /* FIXME: This is very ugly but we can't include hash.h until we have
  * defined Intersection. And we do need to include it before using
@@ -135 +141 @@
 
 /* Note that POS(-1, -1) == 0
  * DELTA() is defined so that POS(i+di, j+dj) = POS(i, j) + DELTA(di, dj).
+ * For details look in the documentation.
  */
 #define BOARDSIZE     ((MAX_BOARD + 2) * (MAX_BOARD + 1) + 1)
 #define BOARDMIN      (MAX_BOARD + 2)
@@ -148 +155 @@
 #define NS            (MAX_BOARD + 1)
 #define WE            1
 #define SOUTH(pos)    ((pos) + NS)
-#define WEST(pos)     ((pos) - 1)
+#define WEST(pos)     ((pos) - WE)
 #define NORTH(pos)    ((pos) - NS)
-#define EAST(pos)     ((pos) + 1)
-#define SW(pos)       ((pos) + NS - 1)
-#define NW(pos)       ((pos) - NS - 1)
-#define NE(pos)       ((pos) - NS + 1)
-#define SE(pos)       ((pos) + NS + 1)
+#define EAST(pos)     ((pos) + WE)
+#define SW(pos)       ((pos) + NS - WE)
+#define NW(pos)       ((pos) - NS - WE)
+#define NE(pos)       ((pos) - NS + WE)
+#define SE(pos)       ((pos) + NS + WE)
 #define SS(pos)       ((pos) + 2 * NS)
-#define WW(pos)       ((pos) - 2)
+#define WW(pos)       ((pos) - 2 * WE)
 #define NN(pos)       ((pos) - 2 * NS)
-#define EE(pos)       ((pos) + 2)
+#define EE(pos)       ((pos) + 2 * WE)
 
 #define DIRECT_NEIGHBORS(pos1, pos2)            \
   ((pos1) == SOUTH(pos2)                        \
@@ -260 +267 @@
 /* Functions handling the permanent board state. */
 void clear_board(void);
 int test_gray_border(void);
-void setup_board(Intersection new_board[MAX_BOARD][MAX_BOARD], int ko_pos,
-                 int *last, float new_komi, int w_captured, int b_captured);
 void add_stone(int pos, int color);
 void remove_stone(int pos);
 void play_move(int pos, int color);
@@ -271 +276 @@
 void restore_board(struct board_state *state);
 
 /* Information about the permanent board. */
-int get_last_move(void);
-int get_last_player(void);
+inline int get_last_move(void);
+inline int get_last_player(void);
 int get_last_opponent_move(int color);
 int stones_on_board(int color);
 
 /* Functions handling the variable board state. */
-int trymove(int pos, int color, const char *message, int str);
+int trymove(int pos, int color, const char *message, int str_pos);
 int tryko(int pos, int color, const char *message);
 void popgo(void);
 int komaster_trymove(int pos, int color,
                      const char *message, int str,
                      int *is_conditional_ko, int consider_conditional_ko);
-int get_komaster(void);
-int get_kom_pos(void);
+inline int get_komaster(void);
+inline int get_kom_pos(void);
 
 int move_in_stack(int pos, int cutoff);
-void get_move_from_stack(int k, int *move, int *color);
+inline void get_move_from_stack(int k, int *move, int *color);
 void dump_stack(void);
 void do_dump_stack(void);
 
-void reset_trymove_counter(void);
-int get_trymove_counter(void);
+void dump_incremental_board(void);
+
+inline void reset_trymove_counter(void);
+inline int get_trymove_counter(void);
 
 /* move properties */
-int is_pass(int pos);
+inline int is_pass(int pos);
 int is_legal(int pos, int color);
 int is_suicide(int pos, int color);
-int is_illegal_ko_capture(int pos, int color);
+inline int is_illegal_ko_capture(int pos, int color);
 int is_allowed_move(int pos, int color);
 int is_ko(int pos, int color, int *ko_pos);
 int is_ko_point(int pos);
@@ -306 +313 @@
 int is_self_atari(int pos, int color);
 
 /* Purely gemoetric functions */
-int is_edge_vertex(int pos);
-int is_corner_vertex(int pos);
-int edge_distance(int pos);
-int square_dist(int pos1, int pos2);
+inline int is_edge_vertex(int pos);
+inline int is_corner_vertex(int pos);
+inline int edge_distance(int pos);
+inline int square_dist(int pos1, int pos2);
 
 /* Basic string information. */
-int find_origin(int str);
-int chainlinks(int str, int adj[MAXCHAIN]);
-int chainlinks2(int str, int adj[MAXCHAIN], int lib);
-int chainlinks3(int str, int adj[MAXCHAIN], int lib);
-int extended_chainlinks(int str, int adj[MAXCHAIN], int both_colors);
-
-int liberty_of_string(int pos, int str);
-int second_order_liberty_of_string(int pos, int str);
-int neighbor_of_string(int pos, int str);
-int has_neighbor(int pos, int color);
-int same_string(int str1, int str2);
-int adjacent_strings(int str1, int str2);
+inline int find_origin(int str_pos);
+int chainlinks(int str_pos, int adj[MAXCHAIN]);
+int chainlinks2(int str_pos, int adj[MAXCHAIN], int lib);
+int chainlinks3(int str_pos, int adj[MAXCHAIN], int lib);
+int extended_chainlinks(int str_pos, int adj[MAXCHAIN], int both_colors);
+
+int liberty_of_string(int pos, int str_pos);
+int liberty_of_string2(int pos, int str_pos);
+int second_order_liberty_of_string(int pos, int str_pos);
+int neighbor_of_string(int pos, int str_pos);
+inline int has_neighbor(int pos, int color);
+inline int same_string(int str1_pos, int str2_pos);
+int adjacent_strings(int str1_pos, int str2_pos);
 void mark_string(int str, signed char mx[BOARDMAX], signed char mark);
 int are_neighbors(int pos1, int pos2);
 
-/* Count and/or find liberties at (pos). */
-int countlib(int str);
-int findlib(int str, int maxlib, int *libs);
+/* Count and/or find liberties at (pos) */
+inline int countlib(int str_pos);
+int findlib(int str_pos, int maxlib, int *libs);
 int fastlib(int pos, int color, int ignore_captures);
 int approxlib(int pos, int color, int maxlib, int *libs);
 int accuratelib(int pos, int color, int maxlib, int *libs);
-int count_common_libs(int str1, int str2);
-int find_common_libs(int str1, int str2, int maxlib, int *libs);
-int have_common_lib(int str1, int str2, int *lib);
+int count_common_libs(int str1_pos, int str2_pos);
+int find_common_libs(int str1_pos, int str2_pos, int maxlib, int *libs);
+int have_common_lib(int str1_pos, int str2_pos, int *lib);
 
 /* Count the number of stones in a string. */
-int countstones(int str);
-int findstones(int str, int maxstones, int *stones);
-int count_adjacent_stones(int str1, int str2, int maxstones);
+inline int countstones(int str_pos);
+int findstones(int str_pos, int maxstones, int *stones);
+int count_adjacent_stones(int str1_pos, int str2_pos, int maxstones);
 
 /* Special function for reading.c */
-void incremental_order_moves(int move, int color, int string,
+void incremental_order_moves(int move, int color, int target_pos,
                              int *number_edges, int *number_same_string,
                              int *number_own, int *number_opponent,
                              int *captured_stones, int *threatened_stones,
                              int *saved_stones, int *number_open);
 
 /* Board caches initialization functions. */
-void clear_approxlib_cache(void);
-void clear_accuratelib_cache(void);
+inline void clear_approxlib_cache(void);
+inline void clear_accuratelib_cache(void);
   
 
 /* Is this point inside the board? */
@@ -381 +389 @@
  * south, west, north, east, southwest, northwest, northeast, southeast.
  * Defined in board.c.
  */
-extern int deltai[8]; /* = { 1,  0, -1,  0,  1, -1, -1, 1}; */
-extern int deltaj[8]; /* = { 0, -1,  0,  1, -1, -1,  1, 1}; */
-extern int delta[8];  /* = { NS, -1, -NS, 1, NS-1, -NS-1, -NS+1, NS+1}; */
+extern const int deltai[8]; /* = { 1,  0, -1,  0,  1, -1, -1, 1}; */
+extern const int deltaj[8]; /* = { 0, -1,  0,  1, -1, -1,  1, 1}; */
+extern const int delta[8];  /* = { NS, -WE, -NS, WE, NS-WE, -NS-WE, -NS+WE, NS+WE}; */
 
 
 

gnugo/engine/boardlib.c

@@ -29 +29 @@
 /* The board state itself. */
 int          board_size = DEFAULT_BOARD_SIZE; /* board size */
 Intersection board[BOARDSIZE];
-int          board_ko_pos;
+int          board_ko_pos;      /* Position of a ko (captured stone). */
 int          white_captured;    /* number of black and white stones captured */
 int          black_captured;
 
@@ -54 +54 @@
 /* Hashing of positions. */
 Hash_data board_hash;
 
-int stackp;             /* stack pointer */
+int stackp;             /* moves stack depth */
 int position_number;    /* position number */
 
 /* Some statistics gathered partly in board.c and hash.c */

gnugo/engine/breakin.c

@@ -367 +367 @@
 
         if (used[pos2])
           break;
-      }
+          }
 
       used[pos] = 1;
       if (ON_BOARD(pos2))
@@ -440 +440 @@
   }
 }
 
-void
+inline void
 clear_break_in_list()
 {
   num_break_ins = 0;

gnugo/engine/cache.c

@@ -39 +39 @@
 /* ---------------------------------------------------------------- */
 
 static void tt_init(Transposition_table *table, int memsize);
-static void tt_clear(Transposition_table *table);
+inline static void tt_clear(Transposition_table *table);
 
 /* The transposition table itself. */
 Transposition_table ttable;
@@ -72 +72 @@
 calculate_hashval_for_tt(Hash_data *hashdata, int routine, int target1,
                          int target2, Hash_data *extra_hash)
 { 
-  *hashdata = board_hash;                /* from globals.c */
+  *hashdata = board_hash;                /* from boardlib.c */
   hashdata_xor(*hashdata, routine_hash[routine]);
   hashdata_xor(*hashdata, target1_hash[target1]);
   if (target2 != NO_MOVE)
@@ -97 +97 @@
   keyhash_init();
 
   if (memsize > 0)
-    num_entries = memsize / sizeof(table->entries[0]);
+    num_entries = memsize / sizeof(Hashentry);
   else
     num_entries = DEFAULT_NUMBER_OF_CACHE_ENTRIES;
 
   table->num_entries = num_entries;
-  table->entries     = malloc(num_entries * sizeof(table->entries[0]));
+  table->entries     = malloc(num_entries * sizeof(Hashentry));
 
   if (table->entries == NULL) {
     perror("Couldn't allocate memory for transposition table. \n");
     exit(1);
   }
 
-  table->is_clean = 0;
   tt_clear(table);
 }
 
 
 /* Clear the transposition table. */
 
-static void
+inline static void
 tt_clear(Transposition_table *table)
 {
-  if (!table->is_clean) {
-    memset(table->entries, 0, table->num_entries * sizeof(table->entries[0]));
-    table->is_clean = 1;
-  }
+  memset(table->entries, 0, table->num_entries * sizeof(Hashentry));
 }
- 
- 
+
+
 /* Free the transposition table. */
 
-void
+inline void
 tt_free(Transposition_table *table)
 {
   free(table->entries);
 }
 
 
-/* Get result and move. Return value:
+/* Get result and move (the bigger remaining depth the lower depth).
+ * Return value:
  *   0 if not found
- *   1 if found, but depth too small to be trusted.  In this case the move
+ *   1 if found, but depth too big to be trusted.  In this case the move
  *     can be used for move ordering.
- *   2 if found and depth is enough so that the result can be trusted.
+ *   2 if found and depth is small enough so that the result can be trusted.
  */
  
 int
@@ -162 +159 @@
 
   /* Get the correct entry and node. */
   entry = &table->entries[hashdata_remainder(hashval, table->num_entries)];
-  if (hashdata_is_equal(hashval, entry->deepest.key))
-    node = &entry->deepest;
+
+  if (hashdata_is_equal(hashval, entry->most_reliable.key))
+    node = &entry->most_reliable;
   else if (hashdata_is_equal(hashval, entry->newest.key))
     node = &entry->newest;
   else
     return 0;
 
-  stats.read_result_hits++;
+#ifndef GG_TURN_OFF_STATS
+  ++stats.read_result_hits;
+#endif
 
   /* Return data.  Only set the result if remaining depth in the table
    * is big enough to be trusted.  The move can always be used for move
@@ -177 +177 @@
    */
   if (move)
     *move = hn_get_move(node->data);
+
   if (remaining_depth <= (int) hn_get_remaining_depth(node->data)) {
     if (value1)
       *value1 = hn_get_value1(node->data);
     if (value2)
       *value2 = hn_get_value2(node->data);
-    stats.trusted_read_result_hits++;
+
+#ifndef GG_TURN_OFF_STATS
+    ++stats.trusted_read_result_hits;
+#endif
+
     return 2;
   }
 
@@ -201 +206 @@
 {
   Hash_data hashval;
   Hashentry *entry;
-  Hashnode *deepest;
+  Hashnode *most_reliable;
   Hashnode *newest;
   unsigned int data;
   /* Get routine costs definitions from liberty.h. */
@@ -220 +225 @@
 
   /* Get the entry and nodes. */ 
   entry = &table->entries[hashdata_remainder(hashval, table->num_entries)];
-  deepest = &entry->deepest;
+  most_reliable = &entry->most_reliable;
   newest  = &entry->newest;
  
   /* See if we found an already existing node. */
-  if (hashdata_is_equal(hashval, deepest->key)
-      && remaining_depth >= (int) hn_get_remaining_depth(deepest->data)) {
-
-    /* Found deepest */
-    deepest->data = data;
-
+  if (hashdata_is_equal(hashval, most_reliable->key))
+  {
+    /* Found shallower node (can be trusted more likely) */
+    if (remaining_depth > (int) hn_get_remaining_depth(most_reliable->data))
+      most_reliable->data = data;
   }
-  else if (hashdata_is_equal(hashval, newest->key)
-           && remaining_depth >= (int) hn_get_remaining_depth(newest->data)) {
-
+  else if (hashdata_is_equal(hashval, newest->key))
+  {
     /* Found newest */
-    newest->data = data;
-
-    /* If newest has become deeper than deepest, then switch them. */
-    if (hn_get_remaining_depth(newest->data)
-        > hn_get_remaining_depth(deepest->data)) {
-      Hashnode temp;
-
-      temp = *deepest;
-      *deepest = *newest;
-      *newest = temp;
+    if (remaining_depth > (int) hn_get_remaining_depth(newest->data))
+    {
+      newest->data = data;
+
+      /* If newest reliability is bigger than most_reliable, switch them. */
+      if (hn_get_reliability(newest->data) >
+          hn_get_reliability(most_reliable->data))
+      {
+        Hashnode temp;
+
+        temp = *most_reliable;
+        *most_reliable = *newest;
+        *newest = temp;
+      }
     }
-
   }
-  else if (hn_get_total_cost(data) > hn_get_total_cost(deepest->data)) {
-    if (hn_get_total_cost(newest->data) < hn_get_total_cost(deepest->data))
-      *newest = *deepest;
-    deepest->key  = hashval;
-    deepest->data = data;
-  } 
-  else {
+  /* Have new node. */
+  else if (hn_get_reliability(data) >
+           hn_get_reliability(most_reliable->data))
+  {
+    /* Replace most_reliable. */
+    most_reliable->key  = hashval;
+    most_reliable->data = data;
+  }
+  else
+  {
     /* Replace newest. */
     newest->key  = hashval;
     newest->data = data;
   }
 
-  stats.read_result_entered++;
-  table->is_clean = 0;
+#ifndef GG_TURN_OFF_STATS
+  ++stats.read_result_entered;
+#endif
 }
 
 
@@ -270 +280 @@
 };
 
 /* Convert a routine as used in the cache table to a string. */
-const char *
+inline const char *
 routine_id_to_string(enum routine_id routine)
 {
   return routine_names[(int) routine];
@@ -282 +292 @@
  * allocate a single node or if the allocation fails, the caching is
  * disabled.
  */
-void
+inline void
 reading_cache_init(int bytes)
 {
   tt_init(&ttable, bytes);
@@ -290 +300 @@
 
 
 /* Clear the cache for read results. */
-void
+inline void
 reading_cache_clear()
 {
   tt_clear(&ttable);
 }
 
-float
+inline float
 reading_cache_default_size()
 {
   return DEFAULT_NUMBER_OF_CACHE_ENTRIES * sizeof(Hashentry) / 1024.0 / 1024.0;

gnugo/engine/cache.h

@@ -32 +32 @@
  * (Reading/Hashing) for more information.  
  */
 
+#if SIZEOF_INT == 4
+  typedef unsigned int HASHNODE_DATATYPE;
+#elif SIZEOF_LONG == 4
+  typedef unsigned long HASHNODE_DATATYPE;
+#elif SIZEOF_INT > 4
+  typedef unsigned short HASHNODE_DATATYPE;
+#elif
+  #error Long type size has to be at least 4 bytes.
+#endif
 
 /* Hashnode: a node stored in the transposition table.
  *
  * In addition to the position, the hash lock encodes the following data,
  * all hashed:
- *   komaster
- *   kom_pos
+ *   ko
+ *   komaster (look in doc)
+ *   kom_pos (look in doc)
  *   routine
- *   str1
- *   str2
+ *   target1
+ *   target2
  *   extra hashvalue, optional (e.g. encoding a goal array)
  *
  * The data field packs into 32 bits the following
@@ -54 +64 @@
  *   cost           :  4 bits
  *   remaining_depth:  5 bits (depth - stackp)  NOTE: HN_MAX_REMAINING_DEPTH
  *
- *   The last 9 bits together give an index for the total costs.
+ *   The last 9 bits together give a reliability index (bigger index means
+ *   more reliable result).
+ *   Values are results of analyzed position (WIN, LOSE, etc.)
  */
 typedef struct {
   Hash_data key;
-  unsigned int data; /* Should be 32 bits, but only wastes 25% if 64 bits. */
+  HASHNODE_DATATYPE data; /* 32-bit value */
 } Hashnode;
 
 #define HN_MAX_REMAINING_DEPTH 31
@@ -67 +79 @@
 /* Hashentry: an entry, with two nodes of the hash_table
  */
 typedef struct {
-  Hashnode deepest;
+  Hashnode most_reliable;
   Hashnode newest;
 } Hashentry;
 
@@ -76 +88 @@
 #define hn_get_value2(hn)           ((hn >> 19) & 0x0f)
 #define hn_get_move(hn)             ((hn >>  9) & 0x3ff)
 #define hn_get_cost(hn)             ((hn >>  5) & 0x0f)
-#define hn_get_remaining_depth(hn)  ((hn >>  0) & 0x1f)
-#define hn_get_total_cost(hn)       ((hn >>  0) & 0x1ff)
+#define hn_get_remaining_depth(hn)  ((hn/*>>  0*/) & 0x1f)
+#define hn_get_reliability(hn)      ((hn/*>>  0*/) & 0x1ff)
 
 #define hn_create_data(remaining_depth, value1, value2, move, cost) \
     ((((value1)         & 0x0f)  << 23) \
    | (((value2)         & 0x0f)  << 19) \
    | (((move)           & 0x3ff) <<  9) \
    | (((cost)           & 0x0f)  <<  5) \
-   | (((remaining_depth & 0x1f)  <<  0)))
+   | (((remaining_depth & 0x1f)/*<<  0*/)))
 
 
 /* Transposition_table: transposition table used for caching. */
 typedef struct {
   unsigned int num_entries;
   Hashentry *entries;
-  int is_clean;
 } Transposition_table;
 
 extern Transposition_table ttable;
@@ -101 +112 @@
  */
 #define DEFAULT_NUMBER_OF_CACHE_ENTRIES 350000
 
-void tt_free(Transposition_table *table);
+inline void tt_free(Transposition_table *table);
 int  tt_get(Transposition_table *table, enum routine_id routine,
             int target1, int target2, int remaining_depth,
             Hash_data *extra_hash,
@@ -141 +152 @@
   int q1 = board[str1] == EMPTY ? str1 : find_origin(str1); \
   int q2 = board[str2] == EMPTY ? str2 : find_origin(str2);
 
+#define READ_FUNCTION_NAME read_function_name
+
 #else
 
 #define TRACE_CACHED_RESULT(result, move)
 #define TRACE_CACHED_RESULT2(result1, result2, move)
 
+#ifndef GG_TURN_OFF_TRACES
+
 #define SETUP_TRACE_INFO(name, str) \
   const char *read_function_name = name; \
   int q = str;
@@ -155 +170 @@
   int q1 = str1; \
   int q2 = str2;
 
-#endif
-
-/* Trace messages in decidestring/decidedragon sgf file. */
-void sgf_trace(const char *func, int str, int move, int result,
-               const char *message);
-/* Trace messages in decideconnection sgf file. */
-void sgf_trace2(const char *func, int str1, int str2, int move, 
-                const char *result, const char *message);
-/* Trace messages in decidesemeai sgf file. */
-void sgf_trace_semeai(const char *func, int str1, int str2, int move, 
-                      int result1, int result2, const char *message);
-
 /* Macro to hide the call to sgf_trace(). Notice that a little black
  * magic is going on here. Before using this macro, SETUP_TRACE_INFO
  * must have been called to provide the variables read_function_name
@@ -190 +193 @@
     sgf_trace_semeai(read_function_name, q1, q2, move, \
                      result1, result2, message)
 
+#define READ_FUNCTION_NAME read_function_name
+
+#else // #ifndef GG_TURN_OFF_TRACES
+
+#define SETUP_TRACE_INFO(name, str)
+#define SETUP_TRACE_INFO2(name, str1, str2)
+#define SGFTRACE(move, result, message) (void)0
+#define SGFTRACE2(move, result, message) (void)0
+#define SGFTRACE_SEMEAI(move, result1, result2, message) (void)0
+#define READ_FUNCTION_NAME NULL
+
+#endif // #ifndef GG_TURN_OFF_TRACES
+
+#endif // #if TRACE_READ_RESULTS
+
+/* Trace messages in decidestring/decidedragon sgf file. */
+void sgf_trace(const char *func, int str, int move, int result,
+               const char *message);
+/* Trace messages in decideconnection sgf file. */
+void sgf_trace2(const char *func, int str1, int str2, int move, 
+                const char *result, const char *message);
+/* Trace messages in decidesemeai sgf file. */
+void sgf_trace_semeai(const char *func, int str1, int str2, int move, 
+                      int result1, int result2, const char *message);
+
 
 /* ================================================================ */
 
@@ -212 +240 @@
   do { \
     tt_update(&ttable, routine, str, NO_MOVE, remaining_depth, NULL,\
               value, 0, move);\
-    if ((value) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value) != 0) \
+      *(point) = (move); \
     return (value); \
   } while (0)
 
@@ -220 +249 @@
   do { \
     tt_update(&ttable, routine, str1, str2, remaining_depth, NULL, \
               value1, value2, move); \
-    if ((value1) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value1) != 0) \
+      *(point) = (move); \
     return; \
   } while (0)
 
@@ -228 +258 @@
   do { \
     tt_update(&ttable, routine, str1, str2, remaining_depth, NULL,\
               value, 0, move);\
-    if ((value) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value) != 0) \
+      *(point) = (move); \
     return (value); \
   } while (0)
 
@@ -236 +267 @@
   do { \
     tt_update(&ttable, routine, str, NO_MOVE, remaining_depth, hash,\
               value, 0, move);\
-    if ((value) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value) != 0) \
+      *(point) = (move); \
     return (value); \
   } while (0)
 
@@ -244 +276 @@
   do { \
     tt_update(&ttable, routine, str, NO_MOVE, remaining_depth, NULL,\
               value1, value2, move);\
-    if ((value1) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value1) != 0) \
+      *(point) = (move); \
     return (value1); \
   } while (0)
 

gnugo/engine/clock.c

@@ -38 +38 @@
 #include "clock.h"
 #include "gg_utils.h"
 #include "board.h"
+#include "gnugo.h"
 
 /* Level data */
 static int level             = DEFAULT_LEVEL; /* current level */
@@ -68 +69 @@
 };
 
 struct timer_data {
-  struct remaining_time_data official;
-  struct remaining_time_data estimated;
+  struct remaining_time_data official; // time received from external source
+  struct remaining_time_data estimated; // time counted by GnuGO
   int time_out;
 };
 
@@ -127 +128 @@
  *
  *  byo_time > 0 and byo_stones == 0 means no time settings.
  */
-void
+inline void
 clock_settings(int time, int byo_time, int byo_stones)
 {
   if (time >= 0)
@@ -142 +143 @@
 /* Get time settings. Returns 1 if any time settings have been made,
  * 0 otherwise.
  */
-int
+inline int
 have_time_settings(void)
 {
   /* According to the semantics of the GTP command 'time_settings', the
@@ -220 +221 @@
   static int last_movenum = -1;
   struct timer_data* const td
     = (color == BLACK) ? &black_time_data : &white_time_data;
-  double now = gg_gettimeofday();
+  double now;
 
   if (!have_time_settings())
     return;
 
+  now = gg_gettimeofday();
+
   if (last_movenum >= 0
-      && movenum == last_movenum + 1
-      && movenum > td->estimated.movenum) {
+      && movenum == last_movenum + 1) {
     double time_used = now - last_time;
     td->estimated.time_left -= time_used;
     td->estimated.movenum = movenum;
     td->estimated.time_for_last_move = time_used;
     if (td->estimated.time_left < 0) {
       if (td->estimated.in_byoyomi || byoyomi_stones == 0) {
+
+#ifndef GG_TURN_OFF_DEBUGS
         DEBUG(DEBUG_TIME, "%s ran out of time.\n", color_to_string(color));
         if (debug & DEBUG_TIME)
           clock_print(color);
+#endif
+
         td->time_out = 1;
       }
       else {
@@ -251 +257 @@
     }
     else if (td->estimated.stones > 0) {
       gg_assert(td->estimated.in_byoyomi);
-      td->estimated.stones = td->estimated.stones - 1;
+      --td->estimated.stones;
       if (td->estimated.stones == 0) {
         td->estimated.time_left = byoyomi_time;
         td->estimated.stones = byoyomi_stones;
@@ -262 +268 @@
   last_movenum = movenum;
   last_time = now;
 
+#ifndef GG_TURN_OFF_DEBUGS
   /* Update main timer. */
   if (debug & DEBUG_TIME)
     clock_print(color);
+#endif
 }
 
 
@@ -297 +305 @@
 
   if (timer->stones == 0) {
     /* Main time running. */
-    *time_left = timer->time_left + byoyomi_time;
+    *time_left = timer->time_left;
     if (byoyomi_time > 0)
+    {
+      *time_left += byoyomi_time;
       *stones_left = byoyomi_stones;
+    }
     else {
       /* Absolute time. Here we aim to be able to play at least X more
        * moves or a total of Y moves. We choose Y as a third of the
@@ -331 +342 @@
 adjust_level_offset(int color)
 {
   double time_for_last_move;
-  double time_left;
+  double time_left, estimated_time;
   int stones_left;
 
   if (!analyze_time_data(color, &time_for_last_move, &time_left, &stones_left))
@@ -342 +353 @@
    *
    * FIXME: Use rules with at least some theoretical basis.
    */
-  if (time_left < time_for_last_move * (stones_left + 3))
-    level_offset--;
-  if (time_left < time_for_last_move * stones_left)
-    level_offset--;
-  if (3 * time_left < 2 * time_for_last_move * stones_left)
-    level_offset--;
-  if (2 * time_left < time_for_last_move * stones_left)
-    level_offset--;
-  if (3 * time_left < time_for_last_move * stones_left)
-    level_offset--;
-
-  if (time_for_last_move == 0)
-    time_for_last_move = 1;
-  if (time_left > time_for_last_move * (stones_left + 6))
-    level_offset++;
-  if (time_left > 2 * time_for_last_move * (stones_left + 6))
-    level_offset++;
+  if (time_for_last_move < 0.1)
+    time_for_last_move = 0.1;
+
+  estimated_time = time_for_last_move * stones_left;
+
+  if (time_left < estimated_time)
+  {
+    --level_offset;
+
+    if (1.33 * time_left < estimated_time)
+    {
+      --level_offset;
+
+      if (2 * time_left < estimated_time)
+      {
+        level_offset -= 2;
+
+        if (4 * time_left < estimated_time)
+          level_offset -= 2;
+      }
+    }
+  }
+  else if (0.8 * time_left > estimated_time)
+  {
+    ++level_offset;
+
+    if (0.5 * time_left > estimated_time)
+      level_offset += 2;
+  }
 
   if (level + level_offset < min_level)
     level_offset = min_level - level;
-
-  if (level + level_offset > max_level)
+  else if (level + level_offset > max_level)
     level_offset = max_level - level;
 
   DEBUG(DEBUG_TIME, "New level %d (%d %C %f %f %d)\n", level + level_offset,
@@ -375 +397 @@
 /* Interface to level settings. */
 /********************************/
 
-int
+inline int
 get_level()
 {
   return level + level_offset;
 }
 
-void
+inline void
 set_level(int new_level)
 {
   level = new_level;
@@ -392 +414 @@
     min_level = level;
 }
 
-void
+inline void
 set_max_level(int new_max)
 {
   max_level = new_max;
 }
 
-void
+inline void
 set_min_level(int new_min)
 {
   min_level = new_min;

gnugo/engine/clock.h

@@ -26 +26 @@
 #include "gnugo.h"
 
 /* initialization and activation */
-void clock_settings(int maintime, int byotime, int byostones);
+inline void clock_settings(int maintime, int byotime, int byostones);
 void init_timers(void);
  
 /* main access */
 void clock_push_button(int color);
 void update_time_left(int color, int time_left, int stones);
 void clock_print(int color);
-int have_time_settings(void);
+inline int have_time_settings(void);
 
 void adjust_level_offset(int color);
 
 /* Access to level settings. */
-int get_level(void);
-void set_level(int new_level);
-void set_max_level(int new_max);
-void set_min_level(int new_min);
+inline int get_level(void);
+inline void set_level(int new_level);
+inline void set_max_level(int new_max);
+inline void set_min_level(int new_min);
 
 
 #endif  /* _CLOCK_H_ */

gnugo/engine/combination.c

@@ -761 +761 @@
         if (num_libs == 2)
           all_potential_defenses[libs[1]] = 1;
       }
-    }
+        }
 
     if (!IS_STONE(board[str])) {
       /* Error situation. This could be caused by a wrong matcher status. */
@@ -889 +889 @@
       continue;
     
     if (board[last_friendly] == EMPTY
-        && !liberty_of_string(last_friendly, pos))
+        && !liberty_of_string2(last_friendly, pos))
       continue;
     
     if (debug & DEBUG_ATARI_ATARI)
@@ -1054 +1054 @@
 
         if (!safe_move(move, color))
           continue;
-      }
+          }
       
       /*
        * Play (move) and see if there is an attack.

gnugo/engine/dragon.c

@@ -594 +594 @@
           propagate_worm(str);
         }
       }
-    }
+        }
 
   /* Revise essentiality of critical dragons. Specifically, a critical
    * dragon consisting entirely of inessential worms is considered

gnugo/engine/endgame.c

@@ -461 +461 @@
   int liberties;
   int libs[MAXLIBS];
   int k;
+  int color = board[str];
+  int origin = find_origin(str);
 
-  ASSERT1(IS_STONE(board[str]), str);
+  ASSERT1(IS_STONE(color), str);
 
   *essential_liberties = 0;
   *inessential_liberties = 0;
@@ -494 +496 @@
         if (worm[pos].attack_codes[0] != 0 || dragon[pos].status != ALIVE)
           return 0;
 
-        if (board[pos] == board[str]) {
-          if (find_origin(pos) != find_origin(str))
+        if (board[pos] == color) {
+          if (find_origin(pos) != origin)
             essential = 1;
         }
         else

gnugo/engine/filllib.c

@@ -310 +310 @@
       DEBUG(DEBUG_FILLLIB,
             "Filllib: Nothing found, looking for threat to back-capture.\n");
       for (k = 0; k < 4; k++) {
-        int d = delta[k];
-        if (board[pos + d] == other
-            && worm[pos + d].attack_codes[0] != 0) {
+        int checked_pos = pos + delta[k];
+        if (board[checked_pos] == other
+            && worm[checked_pos].attack_codes[0] != 0) {
           /* Just pick some other liberty. */
           /* FIXME: Something is odd about this code. */
           int libs[2];
-          if (findlib(pos + d, 2, libs) > 1) {
+          if (findlib(checked_pos, 2, libs) > 1) {
             if (is_legal(libs[0], color))
               *move = libs[0];
             else if (is_legal(libs[1], color))
@@ -394 +394 @@
    */
   acode = attack(move, &apos);
   gg_assert(acode != 0 && apos != NO_MOVE);
-  
+
   /* Find liberties. */
   liberties = findlib(move, MAXLIBS, libs);
 
@@ -435 +435 @@
       if (attack(adjs[k], &bpos) == WIN) {
         if (forbidden_moves[bpos])
           continue;
-        if (liberty_of_string(bpos, adjs[k])) {
+        if (liberty_of_string2(bpos, adjs[k])) {
           *backfill_move = bpos;
           return 1;
         }
@@ -464 +464 @@
         if (attack(adjs[k], &bpos) == WIN) {
           if (forbidden_moves[bpos])
             continue;
-          if (liberty_of_string(bpos, adjs[k])) {
+          if (liberty_of_string2(bpos, adjs[k])) {
             *backfill_move = bpos;
             return 1;
           }
@@ -496 +496 @@
     popgo();
     for (k = 0; k < neighbors; k++) {
       if (attack(adjs[k], &bpos) == WIN) {
-        if (!forbidden_moves[bpos] && liberty_of_string(bpos, adjs[k])) {
+        if (!forbidden_moves[bpos] && liberty_of_string2(bpos, adjs[k])) {
           *backfill_move = bpos;
           return 1;
         }

gnugo/engine/genmove.c

@@ -73 +73 @@
 void
 reset_engine()
 {
+  static int last_level = -1;
+  int act_level;
+
   /* To improve the reproducability of games, we restart the random
    * number generator with the same seed for each move. Thus we don't
    * have to know how many previous moves have been played, nor
@@ -98 +101 @@
   clear_break_in_list();
 
   /* Set up depth values (see comments there for details). */
-  set_depth_values(get_level(), 0);
+  act_level = get_level();
+  if (last_level != act_level)
+  {
+    set_depth_values(act_level, 0);
+    last_level = act_level;
+  }
 }
 
 /*
@@ -117 +125 @@
 void
 examine_position(int how_much, int aftermath_play)
 {
+#ifndef GG_TURN_OFF_TRACES
   int save_verbose = verbose;
+#endif
 
   purge_persistent_caches();
   
+#ifndef GG_TURN_OFF_TRACES
   /* Don't print reading traces during make_worms and make_dragons unless 
    * the user really wants it (verbose == 3). 
    */
   if (verbose == 1 || verbose == 2)
     --verbose;
+#endif
 
   if (NEEDS_UPDATE(worms_examined)) {
+
+#ifndef GG_TURN_OFF_TRACES
     start_timer(0);
+#endif
+
     make_worms();
+
+#ifndef GG_TURN_OFF_TRACES
     time_report(0, "  make worms", NO_MOVE, 1.0);
+#endif
   }
 
   if (how_much == EXAMINE_WORMS) {
+
+#ifndef GG_TURN_OFF_TRACES
     verbose = save_verbose;
+#endif
+
     gg_assert(test_gray_border() < 0);
     return;
   }
@@ -142 +165 @@
   if (stones_on_board(BLACK | WHITE) != 0) {
     if (NEEDS_UPDATE(initial_influence_examined))
       compute_worm_influence();
+
     if (how_much == EXAMINE_INITIAL_INFLUENCE) {
+
+#ifndef GG_TURN_OFF_TRACES
       verbose = save_verbose;
+#endif
+
       gg_assert(test_gray_border() < 0);
       return;
     }
@@ -151 +179 @@
     if (how_much == EXAMINE_DRAGONS_WITHOUT_OWL) {
       if (NEEDS_UPDATE(dragons_examined_without_owl))
         make_dragons(1);
+
+#ifndef GG_TURN_OFF_TRACES
       verbose = save_verbose;
+#endif
+
       gg_assert(test_gray_border() < 0);
       return;
     }
@@ -163 +195 @@
       dragons_examined_without_owl = position_number;
     }
     if (how_much == EXAMINE_DRAGONS) {
+
+#ifndef GG_TURN_OFF_TRACES
       verbose = save_verbose;
+#endif
+
       gg_assert(test_gray_border() < 0);
       return;
     }
@@ -173 +209 @@
            || how_much == EXAMINE_ALL) {
     initialize_dragon_data();
     compute_scores(chinese_rules || aftermath_play);
+
+#ifndef GG_TURN_OFF_TRACES
     verbose = save_verbose;
+#endif
+
     gg_assert(test_gray_border() < 0);
     return;
   }
   
+#ifndef GG_TURN_OFF_TRACES
   verbose = save_verbose;
+#endif
 
   if (NEEDS_UPDATE(initial_influence2_examined)) {
     compute_dragon_influence();
@@ -197 +239 @@
     return;
   }
 
+#ifndef GG_TURN_OFF_TRACES
   if (printworms)
     show_dragons();
+#endif
 }
 
 
@@ -283 +327 @@
 /* This function collects move reasons can be generated immediately from
  * the data gathered in the examine_position() phase.
  */
-void
+inline void
 collect_move_reasons(int color)
 {
   worm_reasons(color);
@@ -306 +350 @@
            int allowed_moves[BOARDMAX], float *value, int *resign)
 {
   float average_score, pessimistic_score, optimistic_score;
-  int save_verbose;
-  int save_depth;
   int move;
   float dummy_value;
   int use_thrashing_dragon_heuristics = 0;
 
+#ifndef GG_TURN_OFF_TRACES
+  int save_verbose;
+#endif
+
+#ifndef GG_TURN_OFF_ASSERTS
+  int save_depth;
+#endif
+
   if (!value)
     value = &dummy_value;
 
+#ifndef GG_TURN_OFF_TRACES
   start_timer(0);
+#endif
+
+#ifndef GG_TURN_OFF_STATS
   clearstats();
+#endif
 
   /* Usually we would not recommend resignation. */
   if (resign)
@@ -332 +387 @@
   /* Prepare pattern matcher and reading code. */
   reset_engine();
 
+#ifndef GG_TURN_OFF_ASSERTS
   /* Store the depth value so we can check that it hasn't changed when
    * we leave this function.
    */
   save_depth = depth;
+#endif
 
   /* If in mirror mode, try to find a mirror move. */
   if (play_mirror_go
@@ -348 +405 @@
   }
 
   /* Find out information about the worms and dragons. */
+#ifndef GG_TURN_OFF_TRACES
   start_timer(1);
+#endif
+
   examine_position(EXAMINE_ALL, 0);
+
+#ifndef GG_TURN_OFF_TRACES
   time_report(1, "examine position", NO_MOVE, 1.0);
+#endif
 
 
   /* The score will be used to determine when we are safely
@@ -374 +437 @@
     average_score = -(white_score + black_score)/2.0;
   choose_strategy(color, average_score, game_status(color));
 
+#ifndef GG_TURN_OFF_TRACES
   if (printboard) {
     if (printboard == 1)
       fprintf(stderr, "\n          dragon_status display:\n\n");
@@ -387 +451 @@
       showboard(4);
     }
   }
+#endif
   
   gg_assert(stackp == 0);
   
@@ -396 +461 @@
 
   
   /* Pick up moves that we know of already. */
+#ifndef GG_TURN_OFF_TRACES
   save_verbose = verbose;
   if (verbose > 0)
     verbose--;
+#endif
+
   collect_move_reasons(color);
+
+#ifndef GG_TURN_OFF_TRACES
   verbose = save_verbose;
   time_report(1, "generate move reasons", NO_MOVE, 1.0);
+#endif
   
   /* Try to find empty corner moves. */
   fuseki(color);
@@ -420 +491 @@
   
   /* The general pattern database. */
   shapes(color);
+
+#ifndef GG_TURN_OFF_TRACES
   time_report(1, "shapes", NO_MOVE, 1.0);
+#endif
+
   gg_assert(stackp == 0);
 
   /* Look for combination attacks and defenses against them. */
   combinations(color);
+
+#ifndef GG_TURN_OFF_TRACES
   time_report(1, "combinations", NO_MOVE, 1.0);
+#endif
+
   gg_assert(stackp == 0);
 
   /* Review the move reasons and estimate move values. */
@@ -433 +512 @@
                           pure_threat_value, pessimistic_score, allowed_moves,
                           use_thrashing_dragon_heuristics))
     TRACE("Move generation likes %1m with value %f\n", move, *value);
+
   gg_assert(stackp == 0);
+
+#ifndef GG_TURN_OFF_TRACES
   time_report(1, "review move reasons", NO_MOVE, 1.0);
+#endif
 
 
   /* If the move value is 6 or lower, we look for endgame patterns too. */
@@ -447 +530 @@
                             use_thrashing_dragon_heuristics))
       TRACE("Move generation likes %1m with value %f\n", move, *value);
     gg_assert(stackp == 0);
+
+#ifndef GG_TURN_OFF_TRACES
     time_report(1, "endgame", NO_MOVE, 1.0);
+#endif
   }
   
   /* If no move found yet, revisit any semeai and change the
@@ -465 +551 @@
               move, *value); 
       }
     }
-    time_report(1, "move reasons with revised semeai status",
-                NO_MOVE, 1.0);
+
+#ifndef GG_TURN_OFF_TRACES
+    time_report(1, "move reasons with revised semeai status", NO_MOVE, 1.0);
+#endif
   }
 
   /* If still no move, fill a remaining liberty. This should pick up
@@ -478 +566 @@
       *value = 1.0;
       TRACE("Filling a liberty at %1m\n", move);
       record_top_move(move, *value);
-      move_considered(move, *value);
+
+#ifndef GG_TURN_OFF_TRACES
+          move_considered(move, *value);
       time_report(1, "fill liberty", NO_MOVE, 1.0);
+#endif
     }
     else
       move = PASS_MOVE;
@@ -492 +583 @@
   if (move == PASS_MOVE) {
     if (play_out_aftermath 
         || capture_all_dead 
-        || (!doing_scoring && thrashing_dragon && pessimistic_score > 15.0))
+        || (!doing_scoring && thrashing_dragon && pessimistic_score > 1.0))
       move = aftermath_genmove(color, 0, allowed_moves);
       
     /* If we're instructed to capture all dead opponent stones, generate
@@ -506 +597 @@
       *value = 1.0;
       TRACE("Aftermath move at %1m\n", move);
       record_top_move(move, *value);
+
+#ifndef GG_TURN_OFF_TRACES
       move_considered(move, *value);
       time_report(1, "aftermath_genmove", NO_MOVE, 1.0);
+#endif
     }
   }
 
@@ -534 +628 @@
     *resign = 1;
   }
   
+#ifndef GG_TURN_OFF_STATS
   /* If statistics is turned on, this is the place to show it. */
   if (showstatistics)
     showstats();
+#endif
 
+#ifndef GG_TURN_OFF_TRACES
   if (showtime) {
     double spent = time_report(0, "TIME to generate move at ", move, 1.0);
     total_time += spent;
@@ -547 +644 @@
       slowest_movenum = movenum + 1;
     }
   }
+#endif
 
   /* Some consistency checks to verify that things are properly
    * restored and/or have not been corrupted.
    */
   gg_assert(stackp == 0);
   gg_assert(test_gray_border() < 0);
+
+#ifndef GG_TURN_OFF_ASSERTS
   gg_assert(depth == save_depth);
+#endif
 
   return move;
 }
@@ -565 +666 @@
  * have considered.
  */
 
-void 
+inline void 
 move_considered(int move, float value)
 {
   if (value > potential_moves[move])
@@ -682 +783 @@
   return 0;
 }
 
-/* Computer two territory estimates: for *upper, the status of all
+/* Compute two territory estimates: for *upper, the status of all
  * cricital stones gets resolved in White's favor; vice verso for
  * black.
  */
@@ -701 +802 @@
                     NO_MOVE, "White territory estimate");
   black_score = influence_score(&move_influence, use_chinese_rules);
 
+#ifndef GG_TURN_OFF_TRACES
   if (verbose || showscore) {
     if (white_score == black_score)
       gprintf("Score estimate: %s %f\n",
@@ -711 +813 @@
               white_score > 0 ? "W " : "B ", gg_abs(white_score));
     fflush(stderr);
   }
+#endif
 }
 
 

gnugo/engine/globals.c

@@ -132 +132 @@
 float white_score;
 float black_score;
 
-int close_worms[BOARDMAX][4];
+/* Close worms data. See liberty.h */
+int close_worms[BOARDMAX][MAX_CLOSE_WORMS];
 int number_close_worms[BOARDMAX];
-int close_black_worms[BOARDMAX][4];
+int close_black_worms[BOARDMAX][MAX_CLOSE_WORMS];
 int number_close_black_worms[BOARDMAX];
-int close_white_worms[BOARDMAX][4];
+int close_white_worms[BOARDMAX][MAX_CLOSE_WORMS];
 int number_close_white_worms[BOARDMAX];
 
 int false_eye_territory[BOARDMAX];

gnugo/engine/gnugo.h

@@ -114 +114 @@
 /*                           global variables                       */
 /* ================================================================ */
 
+// final release option
+
+#if FINAL_RELEASE == 1
+
+#define GG_TURN_OFF_ASSERTS
+#define GG_TURN_OFF_TRACES
+#define GG_TURN_OFF_STATS
+#define GG_TURN_OFF_DEBUGS
+
+#endif
 
 /* Miscellaneous debug options. */
 extern int quiet;               /* Minimal output. */
@@ -269 +279 @@
 /* influence.c */
 void debug_influence_move(int move);
 
-
+#ifdef GG_TURN_OFF_TRACES
+#define TRACE (1) ? (void)0 : (void)gprintf
+#else
 #define TRACE  (!(verbose)) ? (void)0 : (void)gprintf
+#endif
+
+#ifdef GG_TURN_OFF_DEBUGS
+#define DEBUG (1) ? (void)0 : (void)DEBUG_func
+int DEBUG_func(int level, const char *fmt, ...);
+#else
 
 #ifdef HAVE_VARIADIC_DEFINE
 
@@ -286 +304 @@
 
 #endif  /*HAVE_VARIADIC_DEFINE*/
 
+#endif /*GG_TURN_OFF_DEBUGS*/
+
 
 /* genmove.c */
 #define EXAMINE_WORMS               1

gnugo/engine/hash.c

@@ -24 +24 @@
 #include "board.h"
 #include "hash.h"
 #include "random.h"
+#include "gnugo.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <limits.h>
+#include <string.h>
 
 
 
@@ -58 +60 @@
 {
   int i;
   Hashvalue h = 0;
+  const int limit = CHAR_BIT * sizeof(Hashvalue);
 
-  for (i = 0; 32*i < (int) (CHAR_BIT*sizeof(Hashvalue)); i++)
-    h |= (Hashvalue) gg_urand() << 32*i;
+  for (i = 0; i < limit; i += 32)
+    h |= ((Hashvalue) gg_urand()) << i;
 
   return h;
 }
@@ -118 +121 @@
       hashdata_xor(*target, black_hash[pos]);
   }
 
-  if (ko_pos != 0)
+  if (ko_pos != NO_MOVE)
     hashdata_xor(*target, ko_hash[ko_pos]);
 }
 
 /* Clear hashdata. */
-void
+inline void
 hashdata_clear(Hash_data *hd)
 {
-  int i;
-  for (i = 0; i < NUM_HASHVALUES; i++)
-    hd->hashval[i] = 0;
+  memset(hd->hashval, 0, NUM_HASHVALUES * sizeof(Hashvalue));
 }
 
 /* Set or remove ko in the hash value and hash position.  */
-void
+inline void
 hashdata_invert_ko(Hash_data *hd, int pos)
 {
   hashdata_xor(*hd, ko_hash[pos]);
@@ -140 +141 @@
 
 
 /* Set or remove a stone of COLOR at pos in a Hash_data.  */
-void
+inline void
 hashdata_invert_stone(Hash_data *hd, int pos, int color)
 {
   if (color == BLACK)
@@ -151 +152 @@
 
 
 /* Set or remove the komaster value in the hash data. */
-void
+inline void
 hashdata_invert_komaster(Hash_data *hd, int komaster)
 {
   hashdata_xor(*hd, komaster_hash[komaster]);
 }
 
 /* Set or remove the komaster position in the hash data. */
-void
+inline void
 hashdata_invert_kom_pos(Hash_data *hd, int kom_pos)
 {
   hashdata_xor(*hd, kom_pos_hash[kom_pos]);

gnugo/engine/hash.h

@@ -87 +87 @@
 #define INIT_ZOBRIST_ARRAY(a) \
   hash_init_zobrist_array(a, (int) (sizeof(a) / sizeof(a[0])))
 
-void hashdata_clear(Hash_data *hd);
+inline void hashdata_clear(Hash_data *hd);
 void hashdata_recalc(Hash_data *hd, Intersection *board, int ko_pos);
-void hashdata_invert_ko(Hash_data *hd, int pos);
-void hashdata_invert_stone(Hash_data *hd, int pos, int color);
-void hashdata_invert_komaster(Hash_data *hd, int komaster);
-void hashdata_invert_kom_pos(Hash_data *hd, int kom_pos);
+inline void hashdata_invert_ko(Hash_data *hd, int pos);
+inline void hashdata_invert_stone(Hash_data *hd, int pos, int color);
+inline void hashdata_invert_komaster(Hash_data *hd, int komaster);
+inline void hashdata_invert_kom_pos(Hash_data *hd, int kom_pos);
 
 char *hashdata_to_string(Hash_data *hashdata);
 
@@ -100 +100 @@
 
 /* ---------------------------------------------------------------- */
 
-/* There is no need to involve all bits in the remainder computation
- * as long as we only use it to compute a key into a hash table. 32
- * random bits are sufficient to get an even distribution within any
- * hashtable of reasonable size. By never using more than 32 bits we
- * also reduce the platform dependency of the GNU Go engine.
-*/
+/* Calculates a place in the transposition table where to look up for
+   a hash value. If sizeof(long) > sizeof(int) we truncate long to int
+   because size of the transposition table wouldn't be greater than
+   int. */
 #define hashdata_remainder(hd, num) \
-  (((hd).hashval[0] & 0xffffffffU) % (num))
+  (*((unsigned int*)((hd).hashval)) % (num))
+
 
 #if NUM_HASHVALUES == 1
 

gnugo/engine/liberty.h

@@ -97 +97 @@
   "analyze_semeai"
 
 /* To prioritize between different types of reading, we give a cost
- * ranking to each of the routines above:
+ * ranking to each of the routines above (bigger index means bigger
+ * cost):
  *
  * 4 semeai
  * 3 owl
@@ -111 +112 @@
   3, 3, 4, 0, 0, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, -1
   
 
-const char *routine_id_to_string(enum routine_id routine);
+inline const char *routine_id_to_string(enum routine_id routine);
 
 
 /* This is used for both the dragon status and safety fields.
@@ -119 +120 @@
  * final status computed by the aftermath code.
  */
 enum dragon_status {
+  UNKNOWN,
   DEAD,
   ALIVE,
   CRITICAL,
-  UNKNOWN,
   UNCHECKED,
   CAN_THREATEN_ATTACK,
   CAN_THREATEN_DEFENSE, 
@@ -139 +140 @@
 };
 
 #define DRAGON_STATUS_NAMES \
+  "unknown", \
   "dead", \
   "alive", \
   "critical", \
-  "unknown", \
   "unchecked", \
   "can threaten attack", \
   "can threaten defense", \
@@ -194 +195 @@
                      struct corner_db *database);
 void dfa_match_init(void);
 
-void reading_cache_init(int bytes);
-void reading_cache_clear(void);
-float reading_cache_default_size(void);
+inline void reading_cache_init(int bytes);
+inline void reading_cache_clear(void);
+inline float reading_cache_default_size(void);
 
 /* reading.c */
 int attack(int str, int *move);
@@ -345 +346 @@
 int surround_map(int dr, int pos);
 
 /* functions to add (or remove) move reasons */
-void collect_move_reasons(int color);
+inline void collect_move_reasons(int color);
 
 void clear_move_reasons(void);
 void add_lunch(int eater, int food);
@@ -652 +653 @@
 
 void break_territories(int color_to_move, struct influence_data *q,
                        int store, int pos);
-void clear_break_in_list(void);
+inline void clear_break_in_list(void);
 void break_in_move_reasons(int color);
 
 void choose_strategy(int color, float our_score, float game_status);
@@ -669 +670 @@
 
 /* debugging support */
 void goaldump(const signed char goal[BOARDMAX]);
-void move_considered(int move, float value);
+inline void move_considered(int move, float value);
 
 
 /* Transformation stuff. */

gnugo/engine/move_reasons.c

@@ -1553 +1553 @@
 {
   float new_strength;
   int ii;
+  int aff_stone = board[affected];
 
-  ASSERT1(IS_STONE(board[affected]), affected);
+  ASSERT1(IS_STONE(aff_stone), affected);
 
   if (new_status == 0)
     new_strength = 0.0;
@@ -1563 +1564 @@
     new_strength = DEFAULT_STRENGTH;
   }
   for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-    if (board[ii] == board[affected]
+    if (board[ii] == aff_stone
         && same_string(ii, affected)) {
       strength[ii] = new_strength;
       safe_stones[ii] = new_status;

gnugo/engine/optics.c

@@ -1748 +1748 @@
   int defense_point;
   int attack_value;
   int defense_value;
+  int other = OTHER_COLOR(color);
 
   memset(attack_values, 0, sizeof(attack_values));
   memset(defense_values, 0, sizeof(defense_values));
@@ -1846 +1847 @@
      *           string neighbors more than one empty vertex in the
      *           same eyespace.
      */
-    if (val < 2.0 && board[pos] == EMPTY && board[diag] == OTHER_COLOR(color)
+    if (val < 2.0 && board[pos] == EMPTY && board[diag] == other
         && !is_edge_vertex(pos) && neighbor_of_string(pos, diag)
         && countstones(diag) >= 3) {
       int strings[3];
@@ -1880 +1881 @@
             continue;
 
           for (r = 0; r < lib_count && adj_eye_count < 2; r++)
-            if (my_eye[libs[r]].color == OTHER_COLOR(color)
+            if (my_eye[libs[r]].color == other
                 && !my_eye[libs[r]].marginal)
               adj_eye_count++;
           if (adj_eye_count < 2) {
@@ -1889 +1890 @@
           }
         }
       }
-    }
+        }
 
     sum += val;
 
@@ -2402 +2403 @@
    * liberties empty.
    */
   for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (mx[pos] == 1 || board[pos] != EMPTY || liberty_of_string(pos, str))
+    if (mx[pos] == 1 || board[pos] != EMPTY || liberty_of_string2(pos, str))
       continue;
     for (k = 0; k < 8; k++) {
-      if (ON_BOARD(pos + delta[k])
-          && liberty_of_string(pos + delta[k], str)) {
+      int checked_pos = pos + delta[k];
+      if (ON_BOARD(checked_pos)
+          && liberty_of_string(checked_pos, str)) {
         play_move(pos, BLACK);
         break;
       }
@@ -2695 +2697 @@
   int eyes;
   
   for (k = 0; k < 4; k++) {
-    if (board[vertex + delta[k]] == BLACK) {
+    int checked_pos = vertex + delta[k];
+    if (board[checked_pos] == BLACK) {
       eyes = 0;
-      num_libs = findlib(vertex + delta[k], MAXLIBS, libs);
+      num_libs = findlib(checked_pos, MAXLIBS, libs);
       
       for (r = 0; r < num_libs; r++)
         if (is_suicide(libs[r], WHITE))
@@ -3646 +3649 @@
   /* If there are any isolated O stones, those should also be added to
    * the playable vertices.
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (board[pos] == WHITE && !same_string(pos, POS(1, 0))) {
-      vertices[num_vertices] = vertices[num_vertices - 1];
-      vertices[num_vertices - 1] = vertices[num_vertices - 2];
-      vertices[num_vertices - 2] = vertices[num_vertices - 3];
-      vertices[num_vertices - 3] = pos;
-      num_vertices++;
-    }
+  {
+    int pos_1_0 = POS(1, 0);
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+      if (board[pos] == WHITE && !same_string(pos, pos_1_0)) {
+        vertices[num_vertices] = vertices[num_vertices - 1];
+        vertices[num_vertices - 1] = vertices[num_vertices - 2];
+        vertices[num_vertices - 2] = vertices[num_vertices - 3];
+        vertices[num_vertices - 3] = pos;
+        num_vertices++;
+      }
+  }
 
   if (verbose) {
     int k;

gnugo/engine/owl.c

@@ -480 +480 @@
             && !is_same_dragon(adjs[k], bpos)
             && dragon[adjs[k]].crude_status == ALIVE)
           adjacent_to_outside = 1;
-      }
+          }
       
       if ((adjacent_to_outside || countstones(str) > 6)
           && s_worms < MAX_SEMEAI_WORMS) {
@@ -1576 +1576 @@
     for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
       if (IS_STONE(board[pos])
           && pos == find_origin(pos)) {
-        if (owla->goal[pos])
-          net -= 75*countlib(pos);
-        if (owlb->goal[pos])
-          net += 100*countlib(pos);       
+        int count_lib = -1;
+        if (owla->goal[pos]) {
+          count_lib = countlib(pos);
+          net -= 75 * count_lib;
+        }
+        if (owlb->goal[pos]) {
+          if (count_lib < 0)
+            count_lib = countlib(pos);
+          net += 100 * count_lib;
+        }
       }
     }
     if (!trymove(move, color, NULL, 0)) {
@@ -1589 +1595 @@
     for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
       if (IS_STONE(board[pos])
           && pos == find_origin(pos)) {
+        int count_lib = -1;
         if (owla->goal[pos]
-            || (pos == move && liberty_of_goal(move, owla)))
-          net += 75*countlib(pos);
-        if (owlb->goal[pos])
-          net -= 100*countlib(pos);
+            || (pos == move && liberty_of_goal(move, owla))) {
+          count_lib = countlib(pos);
+          net += 75 * count_lib;
+        }
+        if (owlb->goal[pos]) {
+          if (count_lib < 0)
+            count_lib = countlib(pos);
+          net -= 100 * count_lib;
+        }
       }
     }
 
@@ -1929 +1941 @@
       int size = 0;
       saveworm = MAX_GOAL_WORMS;
       for (k = 0; k < MAX_GOAL_WORMS; k++) {
-        if (owl_goal_worm[k] == NO_MOVE)
+        int worm_goal = owl_goal_worm[k];
+        if (worm_goal == NO_MOVE)
           break;
-        if (board[owl_goal_worm[k]] == EMPTY
-            || countlib(owl_goal_worm[k]) > 1)
+        if (board[worm_goal] == EMPTY
+            || countlib(worm_goal) > 1)
           continue;
-        if (worm[owl_goal_worm[k]].size > size) {
+        if (worm[worm_goal].size > size) {
           saveworm = k;
-          size = worm[owl_goal_worm[k]].size;
+          size = worm[worm_goal].size;
         }
       }
       if (saveworm != MAX_GOAL_WORMS && size >= 3) {
@@ -3554 +3567 @@
     if (ON_BOARD(*move + delta[k]) && board[*move + delta[k]] != color)
       return 0;
 
-  for (r = 4; r < 8; r++)
-    if (board[*move + delta[r]] == other
-        && countlib(*move + delta[r]) == 1) {
-      for (k = 0; k < 4; k++)
-        if (board[*move + delta[k]] == color
-            && countlib(*move + delta[k]) == 1
-            && !adjacent_strings(*move + delta[r], *move + delta[k]))
+  for (r = 4; r < 8; r++) {
+    int checked_pos_r = *move + delta[r];
+    if (board[checked_pos_r] == other
+        && countlib(checked_pos_r) == 1) {
+      for (k = 0; k < 4; k++) {
+        int checked_pos_k = *move + delta[k];
+        if (board[checked_pos_k] == color
+            && countlib(checked_pos_k) == 1
+            && !adjacent_strings(checked_pos_r, checked_pos_k))
           break;
+      }
 
       if (k == 4) {
         int new_move;
-        findlib(*move + delta[r], 1, &new_move);
+        findlib(checked_pos_r, 1, &new_move);
         TRACE("Changing eyefilling move at %1m to capture at %1m.\n",
               *move, new_move);
         *move = new_move;
         return 1;
       }
     }
+  }
   
   return 0;    
 }
@@ -4999 +5016 @@
         mark_string(pos, component2, closest_component);
         component_size[closest_component] += countstones(pos);
       }
-    }
+        }
 
     /* Now find the biggest_component. */
     {

gnugo/engine/persistent.c

@@ -233 +233 @@
       return 0;
     else if (!(p[pos] & (HIGH_LIBERTY_BIT | HIGH_LIBERTY_BIT2)))
       continue;
-    else if (((p[pos] & HIGH_LIBERTY_BIT) && countlib(pos) <= 4)
-             || (p[pos] & HIGH_LIBERTY_BIT2 && countlib(pos) <= 3))
-      return 0;
+    else {
+      int count_lib = countlib(pos);
+      if (((p[pos] & HIGH_LIBERTY_BIT) && count_lib <= 4)
+          || ((p[pos] & HIGH_LIBERTY_BIT2) && count_lib <= 3))
+        return 0;
+    }
   }
   
   return 1;
@@ -336 +339 @@
     else {
       for (r = 0; r < MAX_CACHE_DEPTH; r++) {
         int apos = entry->stack[r];
-        int color = entry->move_color[r];
-        if (apos == 0)
+        int color;
+        if (apos == NO_MOVE)
           break;
+        color = entry->move_color[r];
         if (board[apos] == EMPTY
             && trymove(apos, color, "purge_persistent_cache", 0))
           played_moves++;
@@ -354 +358 @@
       /* Move the last entry in the cache here and back up the loop
        * counter to redo the test at this position in the cache.
        */
-      if (0)
+#if 0
         gprintf("Purging entry %d from cache.\n", k);
+#endif
       if (k < cache->current_size - 1)
         *entry = cache->table[cache->current_size - 1];
       k--;
@@ -718 +723 @@
                            int m, int n, float contribution)
 {
   int i, j, k;
+  int pos_mn;
   
   /* If p[m][n] is EMPTY, we just give the contribution to close empty
    * vertices. This is a rough simplification.
@@ -733 +739 @@
   /* Otherwise we give contribution to liberties and diagonal
    * neighbors of the string at (m, n).
    */
+  pos_mn = POS(m, n);
   for (i = 0; i < board_size; i++)
     for (j = 0; j < board_size; j++) {
       if (BOARD(i, j) != EMPTY)
         continue;
       for (k = 0; k < 8; k++) {
-        int di = deltai[k];
-        int dj = deltaj[k];
-        if (IS_STONE(BOARD(i+di, j+dj))
-            && same_string(POS(i+di, j+dj), POS(m, n))) {
+        int di = i + deltai[k];
+        int dj = j + deltaj[k];
+        if (IS_STONE(BOARD(di, dj))
+            && same_string(POS(di, dj), pos_mn)) {
           if (k < 4) {
             values[POS(i, j)] += contribution;
             break;
           }
           else {
-            if (BOARD(i+di, j) == EMPTY || countlib(POS(i+di, j)) <= 2
-                || BOARD(i, j+dj) == EMPTY || countlib(POS(i, j+dj)) <= 2)
+            if (BOARD(di, j) == EMPTY || countlib(POS(di, j)) <= 2
+                || BOARD(i, dj) == EMPTY || countlib(POS(i, dj)) <= 2)
               values[POS(i, j)] += contribution;
             break;
           }
@@ -1345 +1352 @@
     if (board[pos] != EMPTY)
       continue;
     for (k = 0; k < 8; k++) {
+      int same_dragon;
       int pos2 = pos + delta[k];
       if (IS_STONE(board[pos2])
-          && (is_same_dragon(pos2, dr)
+          && ((same_dragon = is_same_dragon(pos2, dr))
               || (are_neighbor_dragons(pos2, dr)
                   && board[pos2] == board[dr]))
           && (countlib(pos2) <= 4
               || is_edge_vertex(pos))) {
         if (k < 4) {
-          if (is_same_dragon(pos2, dr))
+          if (same_dragon)
             values[pos] += contribution;
           else
             values[pos] += 0.5 * contribution;

gnugo/engine/printutils.c

@@ -24 +24 @@
 #include "hash.h"
 #include "gg_utils.h"
 #include "sgftree.h"
+#include "gnugo.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -35 +36 @@
  * This function underpins all the TRACE and DEBUG stuff.
  * It accepts %c, %d, %f, %s, and %x as usual. But it
  * also accepts %m, which takes TWO integers and writes a move.
+ * It is possible to specify %1m, which takes one integer and
+ * prints a move (integer means the board array index).
  * Other accepted formats are
  * %H: Print a hashvalue.
  * %C: Print a color as a string.

gnugo/engine/readconnect.c

@@ -246 +246 @@
   
   /* if only one liberty after capture */
   if (trymove(lib, OTHER_COLOR(board[str]), "snapback", str)) {
-    liberties = 0;
-    if (IS_STONE(board[lib]))
-      liberties = countlib(lib);
+    liberties = countlib(lib);
     popgo();
     sgf_dumptree = save_sgf_dumptree;
     if (liberties > 1)
@@ -271 +269 @@
   int liberties, libs[MAXLIBS];
   int adj, adjs[MAXCHAIN];
   int neighb, neighbs[MAXCHAIN];
+  int color = board[str1];
+  int other = OTHER_COLOR(color);
 
   /* finds connection through two forbidden liberties for
    * the opponent
@@ -288 +288 @@
    */
   liberties = findlib(str1, MAXLIBS, libs);
   for (r = 0; r < liberties; r++)
-    if (is_self_atari(libs[r], OTHER_COLOR(board[str1]))) 
+    if (is_self_atari(libs[r], other)) 
       for (k = 0; k < 4; k++) {
         int pos = libs[r] + delta[k];
-        if (board[pos] == board[str1]
+        if (board[pos] == color
             && !same_string(pos, str1)
             && !same_string(pos, str2)) {
           /* try to connect pos to str2 in one move */
           /* play a common liberty */
           neighb = findlib(pos, MAXLIBS, neighbs);
           for (s = 0; s < neighb; s++)
-            if (liberty_of_string(neighbs[s], str2)) {
+            if (liberty_of_string2(neighbs[s], str2)) {
               res = 1;
               add_zone(zn, libs[r]);
               add_zone(zn, neighbs[s]);
@@ -492 +492 @@
     liberties = findlib(adjs[r], MAXLIBS, libs);
     common_adj_liberty = 0;
     for (s = 0; s < liberties; s++)
-      if (liberty_of_string(libs[s], str2))
+      if (liberty_of_string2(libs[s], str2))
         common_adj_liberty = 1;
     if (common_adj_liberty || adjacent_strings(adjs[r], str2)) {
       for (s = 0; s < liberties; s++)
@@ -511 +511 @@
     liberties = findlib(adjs[r], MAXLIBS, libs);
     common_adj_liberty = 0;
     for (s = 0; s < liberties; s++)
-      if (liberty_of_string(libs[s], str1))
+      if (liberty_of_string2(libs[s], str1))
         common_adj_liberty = 1;
     if (common_adj_liberty || adjacent_strings(adjs[r], str1)) {
       for (s = 0; s < liberties; s++)
@@ -530 +530 @@
   liberties = findlib(str1, MAXLIBS, libs);
   for (r = 0; r < liberties; r++) {
     if (board[SOUTH(libs[r])] == EMPTY) {
-      if (liberty_of_string(SOUTH(libs[r]), str2)) {
+      if (liberty_of_string2(SOUTH(libs[r]), str2)) {
         add_array(moves, libs[r]);
         add_array(moves, SOUTH(libs[r]));
       }
     }
     
     if (board[WEST(libs[r])] == EMPTY) {
-      if (liberty_of_string(WEST(libs[r]), str2)) {
+      if (liberty_of_string2(WEST(libs[r]), str2)) {
         add_array(moves, libs[r]);
         add_array(moves, WEST(libs[r]));
       }
     }
 
     if (board[NORTH(libs[r])] == EMPTY) {
-      if (liberty_of_string(NORTH(libs[r]), str2)) {
+      if (liberty_of_string2(NORTH(libs[r]), str2)) {
         add_array(moves, libs[r]);
         add_array(moves, NORTH(libs[r]));
       }
     }
 
     if (board[EAST(libs[r])] == EMPTY) {
-      if (liberty_of_string(EAST(libs[r]), str2)) {
+      if (liberty_of_string2(EAST(libs[r]), str2)) {
         add_array(moves, libs[r]);
         add_array(moves, EAST(libs[r]));
       }
@@ -561 +561 @@
   /* Liberties of str1 which are adjacent to a friendly string with
    * common liberty with str2.
    */
-  liberties = findlib(str1, MAXLIBS, libs);
+
+#ifndef GG_TURN_OFF_ASSERTS
+/* We got liberties from previous call to findlib. */
+  {
+    int test_libs[MAXLIBS];
+    int t;
+    gg_assert(liberties == findlib(str1, MAXLIBS, test_libs));
+    for (t = 0; t < liberties; ++t)
+      gg_assert(libs[t] == test_libs[t]);
+  }
+#endif
+
   for (r = 0; r < liberties; r++) {
     for (k = 0; k < 4; k++) {
       int pos = libs[r] + delta[k];
@@ -1495 +1506 @@
   SGFTree *save_sgf_dumptree = sgf_dumptree;
   int save_count_variations = count_variations;
   int result = 0;
+  int count_lib = countlib(str);
 
   /* We turn off the sgf traces here to avoid cluttering them up with
    * naive_ladder moves.
@@ -1502 +1514 @@
   sgf_dumptree = NULL;
   count_variations = 0;
 
-  if (countlib(str) == 1) {
+  if (count_lib == 1) {
     findlib(str, 1, move);
     result = WIN;
   }
-  else if (countlib(str) == 2)
+  else if (count_lib == 2)
     result = simple_ladder(str, move);
 
   /* Turn the sgf traces back on. */
@@ -2317 +2329 @@
   SGFTree *save_sgf_dumptree = sgf_dumptree;
   int save_count_variations = count_variations;
   int distance_limit;
+  int str2_onboard;
 
   /* We turn off the sgf traces here to avoid cluttering them up with
    * tactical reading moves.
@@ -2447 +2460 @@
   }
 
   /* Modify the distance values for the moves with various bonuses. */
+  if (ON_BOARD(str2))
+    str2_onboard = 1;
+  else
+    str2_onboard = 0;
+
   for (r = 0; r < num_moves; r++) {
     int move = moves[r];
     int adjacent_to_attacker = 0;
@@ -2476 +2494 @@
               gprintf("%o%1M -0.7, capture or atari of immediately connecting string\n", move);
           }
         }
-      }
+          }
       else if (board[pos] == color) {
-        if (countlib(pos) <= 2) {
+        int count_lib = countlib(pos);
+        if (count_lib <= 2) {
           distances[r] -= FP(0.2);
           if (verbose > 0)
             gprintf("%o%1M -0.2, adjacent to defender string with at most two liberties\n", move);
@@ -2491 +2510 @@
          * The following code compensates in such kind of situations.
          * See connection:111 and gunnar:53 for example.
          */
-        if (!connect_move && countlib(pos) == 1
+        if (!connect_move && count_lib == 1
             /* let's avoid ko and snapbacks */
             && accuratelib(move, other, 2, NULL) > 1) {
           int adjs[MAXCHAIN];
@@ -2523 +2542 @@
      * Neighbor strings with less than 3 liberties have already
      * generated a bonus above.
      */
-    if ((liberty_of_string(move, str1)
+    if ((liberty_of_string2(move, str1)
          && countlib(str1) == 3)
-        || (ON_BOARD(str2) && liberty_of_string(move, str2)
+        || (str2_onboard && liberty_of_string2(move, str2)
             && countlib(str2) == 3)) {
       distances[r] -= FP(0.1);
       if (verbose > 0)
@@ -4235 +4254 @@
   int save_count_variations = count_variations;
   int adj[MAXCHAIN];
   int libs[2];
+  int count_lib = countlib(str);
   
   /* We turn off the sgf traces here to avoid cluttering them up with
    * tactical reading moves.
@@ -4242 +4262 @@
   sgf_dumptree = NULL;
   count_variations = 0;
   
-  if (countlib(str) == 1 && find_defense(str, NULL) == 0)
+  if (count_lib == 1 && find_defense(str, NULL) == 0)
     result = 1;
 
-  if (countlib(str) == 2
+  if (count_lib == 2
       && chainlinks2(str, adj, 1) == 0
       && findlib(str, 2, libs) == 2
       && approxlib(libs[0], board[str], 2, NULL) == 1
@@ -4332 +4352 @@
   if (apos == bpos)
     return 1;
 
-  for (k = 0; k < 4; k++)
-    if (board[apos + delta[k]] == color
-        && countlib(apos + delta[k]) <= 3
-        && liberty_of_string(bpos, apos + delta[k]))
+  for (k = 0; k < 4; k++) {
+    int checked_pos = apos + delta[k];
+    if (board[checked_pos] == color
+        && countlib(checked_pos) <= 3
+        && liberty_of_string(bpos, checked_pos))
       return 1;
+  }
 
   return 0;
 }

gnugo/engine/reading.c

@@ -1032 +1032 @@
   int r;
 
   ASSERT1(IS_STONE(board[str]), str);
-  other = OTHER_COLOR(board[str]);
 
   /* Only handle strings with no way to capture immediately.
    * For now, we treat ko the same as unconditionally. */
@@ -1046 +1045 @@
    *
    * The test against 6 liberties is just an optimization.
    */
+  other = OTHER_COLOR(board[str]);
   liberties = findlib(str, MAXLIBS, libs);
   if (liberties > 1 && liberties < 6) {
     for (k = 0; k < liberties; k++) {
@@ -1065 +1065 @@
 
        if (!ON_BOARD(bb)
            || IS_STONE(board[bb])
-           || liberty_of_string(bb, str))
+           || liberty_of_string2(bb, str))
          continue;
 
        if (trymove(bb, other, "attack_threats-B", str)) {
@@ -1322 +1322 @@
      * it has already been done in the first loop of this function.
      */
     num_adjacent_stones = count_adjacent_stones(adjs[j], str, missing);
-    if (!liberty_of_string(lib, str)
+    if (!liberty_of_string2(lib, str)
         && num_adjacent_stones >= missing) {
       *move = lib;
       return 1;
@@ -1444 +1444 @@
   break_chain_moves(str, &moves);
   set_up_snapback_moves(str, lib, &moves);
 
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(0, NULL);
 
   /* If the string is a single stone and a capture would give a ko,
@@ -1552 +1552 @@
   if (stackp <= backfill_depth)
     special_rescue2_moves(str, libs, &moves);
 
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(0, &suggest_move);
 
   /* Look for backfilling moves. */
@@ -1586 +1586 @@
   special_rescue4_moves(str, libs, &moves);
   
   /* Only order and test the new set of moves. */
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(0, &suggest_move);
 
   /* If we haven't found any useful moves in first batches, be more
@@ -1618 +1618 @@
     break_chain4_moves(str, &moves, be_aggressive);
 
   /* Only order and test the new set of moves. */
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(0, &suggest_move);
 
   RETURN_RESULT(savecode, savemove, move, "saved move");
@@ -1680 +1680 @@
   if (stackp <= backfill2_depth)
     hane_rescue_moves(str, libs, &moves);
 
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(1, &suggest_move);
 
   /* This looks a little too expensive. */
@@ -1768 +1768 @@
   }
 
   /* Only order and test the new set of moves. */
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(1, &suggest_move);
 
   /* If nothing else works, we try playing a liberty of the
@@ -1783 +1783 @@
     break_chain3_moves(str, &moves, 0);
 
   /* Only order and test the new set of moves. */
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(1, &suggest_move);
 
   RETURN_RESULT(savecode, savemove, move, "saved move");
@@ -1850 +1850 @@
     squeeze_moves(str, &moves);
   }
 
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(1, &suggest_move);
 
   if (stackp <= depth) {
@@ -1859 +1859 @@
     bamboo_rescue_moves(str, liberties, libs, &moves);
   }
 
-  order_moves(str, &moves, color, read_function_name, *move);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, *move);
   DEFEND_TRY_MOVES(1, &suggest_move);
 
   RETURN_RESULT(savecode, savemove, move, "saved move");
@@ -2005 +2005 @@
   int other = OTHER_COLOR(color);
   int newlibs[4];
   int liberties;
-  int newstr;
+  int astr_pos;
   int k, r, s;
   
   for (r = 0; r < 2; r++) {
@@ -2017 +2017 @@
       continue;
 
     for (k = 0; k < 4; k++) {
-      if (board[alib + delta[k]] == color
-          && !same_string(alib + delta[k], str)) {
-        newstr = alib + delta[k];
-        liberties = findlib(newstr, 4, newlibs);
+      astr_pos = alib + delta[k];
+      if (board[astr_pos] == color
+          && !same_string(astr_pos, str)) {
+        liberties = findlib(astr_pos, 4, newlibs);
         
         for (s = 0; s < liberties && s < 4; s++) {
           if (!is_self_atari(newlibs[s], color))
             ADD_CANDIDATE_MOVE(newlibs[s], 0, *moves, "special_rescue2");
         }
-        break_chain_moves(newstr, moves);
-        break_chain2_efficient_moves(newstr, moves);
-        edge_clamp_moves(newstr, moves);
+        break_chain_moves(astr_pos, moves);
+        break_chain2_efficient_moves(astr_pos, moves);
+        edge_clamp_moves(astr_pos, moves);
       }
     }
   }
@@ -2284 +2284 @@
 
       liberties2 = findlib(bpos, 4, libs2);
       for (s = 0; s < liberties2; s++)
-        if (!liberty_of_string(libs2[s], str)
+        if (!liberty_of_string2(libs2[s], str)
             && !is_self_atari(libs2[s], color))
           ADD_CANDIDATE_MOVE(libs2[s], 0, *moves, "special_rescue5-A");
 
@@ -2469 +2469 @@
       int alibs[2];
       int alib = accuratelib(apos, other, 2, alibs);
 
-      if (liberty_of_string(apos, str))
+      if (liberty_of_string2(apos, str))
         continue;
 
       if (alib >= 2)
@@ -2521 +2521 @@
       continue;
 
     for (r = 0; r < num_libs2; r++)
-      if (!liberty_of_string(libs2[r], str)) {
+      if (!liberty_of_string2(libs2[r], str)) {
         potential_move = libs2[r];
         break;
       }
@@ -2542 +2542 @@
         previous_liberty = potential_move;
         potential_move = libs2[0];
       }
-      if (liberty_of_string(potential_move, str)) {
+      if (liberty_of_string2(potential_move, str)) {
         potential_move = NO_MOVE;
         break;
       }
@@ -2642 +2642 @@
         if (board[cpos] != color || !same_string(cpos, str))
           continue;
 
-        if (board[dpos] != EMPTY || !liberty_of_string(dpos, apos))
+        if (board[dpos] != EMPTY || !liberty_of_string2(dpos, apos))
           continue;
 
         epos = dpos + up;
 
-        if (board[epos] != EMPTY || !liberty_of_string(epos, apos))
+        if (board[epos] != EMPTY || !liberty_of_string2(epos, apos))
           continue;
 
         if (approxlib(dpos, color, 3, NULL) < 3)
@@ -3112 +3112 @@
         /* If stackp > depth and any boundary chain is in atari, assume safe.
          * However, if the captured chain is only of size 1, there can still
          * be a working ladder, so continue if that is the case.
-         * Also if the string in atari shares its liberty with the
-         * attacked string, drawing it out may enable the ladder to
-         * continue.
+         * Also if the string in atari shares its liberty with the
+         * attacked string, drawing it out may enable the ladder to
+         * continue.
          */
         if (stackp > depth
             && countstones(adjs[r]) > 1
@@ -3190 +3190 @@
       adj = chainlinks2(str, adjs, 2);
       for (r = 0; r < adj; r++) {
         int apos = adjs[r];
-        if (liberty_of_string(libs[0], apos)
-            && liberty_of_string(libs[1], apos))
+        if (liberty_of_string2(libs[0], apos)
+            && liberty_of_string2(libs[1], apos))
           break_chain_moves(apos, &moves);
       }
 
@@ -3230 +3230 @@
       abort();
     } /* switch (pass) */
 
-    order_moves(str, &moves, other, read_function_name, *move);
+    order_moves(str, &moves, other, READ_FUNCTION_NAME, *move);
     ATTACK_TRY_MOVES(0, &suggest_move);
   }
 
@@ -3373 +3373 @@
       abort();
     }
 
-    order_moves(str, &moves, other, read_function_name, *move);
+    order_moves(str, &moves, other, READ_FUNCTION_NAME, *move);
     ATTACK_TRY_MOVES(1, &suggest_move);
   } /* for (pass... */
 
@@ -3467 +3467 @@
       abort();
     }
 
-    order_moves(str, &moves, other, read_function_name, *move);
+    order_moves(str, &moves, other, READ_FUNCTION_NAME, *move);
     ATTACK_TRY_MOVES(1, &suggest_move);
   } /* for (pass = ... */
 
@@ -3681 +3681 @@
      * chain links.
      */
     for (s = 0; s < adj; s++)
-      if (liberty_of_string(apos, adjs[s])) {
+      if (liberty_of_string2(apos, adjs[s])) {
         bpos = adjs[s];
         break;
       }
@@ -3773 +3773 @@
   for (r = 0; r < adj; r++) {
     findlib(adjs[r], 2, libs);
     for (k = 0; k < 2; k++) {
-      if (!liberty_of_string(libs[k], str)
+      if (!liberty_of_string2(libs[k], str)
              && ((ON_BOARD1(SOUTH(libs[k]))
                      && liberty_of_string(SOUTH(libs[k]), str))
               || (ON_BOARD1(WEST(libs[k]))
@@ -4019 +4019 @@
   for (k = 0; k < 4; k++) {
     int l;
     int up = delta[k];
+    int up_apos;
 
     if (ON_BOARD(apos - up))
       continue;
-    if (board[apos + up] != color || !same_string(apos + up, str))
+    up_apos = apos + up;
+    if (board[up_apos] != color || !same_string(up_apos, str))
       return;
     
     for (l = 0; l < 2; l++) {
@@ -4036 +4038 @@
         right = -right;
 
       cpos = apos + right;
-      dpos = apos + right + up;
+      dpos = up_apos + right;
       epos = cpos + right;
       fpos = dpos + right;
 
@@ -4159 +4161 @@
     int min_liberties)
 {
   int r, s, t;
-  int color = OTHER_COLOR(board[str]);
+  int color = board[str];
+  int other = OTHER_COLOR(color);
   int xpos;
   int adj;
   int adj2;
@@ -4178 +4181 @@
     findlib(adjs[r], 2, libs);
     for (t = 0; t < 2; t++) {
       xpos = libs[t];
-      if (approxlib(xpos, color, min_liberties, NULL)
+      if (approxlib(xpos, other, min_liberties, NULL)
           + neighbor_of_string(xpos, str) >= min_liberties)
         ADD_CANDIDATE_MOVE(xpos, 0, *moves, "defend_secondary_chain2-A");
     }
@@ -4187 +4190 @@
     adj2 = chainlinks2(adjs[r], adjs2, 1);
     for (s = 0; s < adj2; s++) {
       findlib(adjs2[s], 1, &xpos);
-      if (!is_self_atari(xpos, color))
+      if (!is_self_atari(xpos, other))
         ADD_CANDIDATE_MOVE(xpos, 0, *moves, "defend_secondary_chain2-B");
     }
 
@@ -4197 +4200 @@
       findlib(adjs2[s], 2, libs);
       for (t = 0; t < 2; t++) {
         /* Only atari if target has no easy escape with his other liberty. */
-        if (approxlib(libs[1-t], OTHER_COLOR(color), 3, NULL) < 3 
-            &&  !is_self_atari(libs[t], color)) {
+        if (approxlib(libs[1-t], color, 3, NULL) < 3 
+            &&  !is_self_atari(libs[t], other)) {
           ADD_CANDIDATE_MOVE(libs[t], 0, *moves, "defend_secondary_chain2-C");
         }
       }
@@ -4365 +4368 @@
         if (!defend_secondary_chain1_moves(adjs[r], moves, 2))
           defend_secondary_chain2_moves(adjs[r], moves, 2);
       }
-    }
+        }
 
     if (unsafe[0] && unsafe[1]
         && (stackp <= backfill2_depth || have_common_lib(str, apos, NULL))) {
@@ -4823 +4826 @@
 
   break_chain_moves(str, &moves);
   set_up_snapback_moves(str, lib, &moves);
-  order_moves(str, &moves, color, read_function_name, NO_MOVE);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, NO_MOVE);
 
   for (k = 0; k < moves.num; k++) {
     int ko_capture;
@@ -4869 +4872 @@
          * better.
          */
         UPDATE_SAVED_KO_RESULT(savecode, savemove, acode, xpos);
-      }
+          }
       else
         popgo();
-    }
+        }
     else {
       int ko_pos;
       if (stackp <= ko_depth
@@ -5626 +5629 @@
   if (approxlib(libs[1], color, 4, NULL) <= 3)
     ADD_CANDIDATE_MOVE(libs[0], 0, moves, "simple_ladder");
 
-  order_moves(str, &moves, other, read_function_name, NO_MOVE);
+  order_moves(str, &moves, other, READ_FUNCTION_NAME, NO_MOVE);
 
   for (k = 0; k < moves.num; k++) {
     int ko_move;
@@ -5688 +5691 @@
   moves.num_tried = 0;
 
   break_chain_moves(str, &moves);
-  order_moves(str, &moves, color, read_function_name, NO_MOVE);
+  order_moves(str, &moves, color, READ_FUNCTION_NAME, NO_MOVE);
 
   for (k = 0; k < moves.num; k++) {
     int ko_move;

gnugo/engine/showbord.c

@@ -343 +343 @@
 }
 
 
-#ifndef HAVE_VARIADIC_DEFINE
+#if !defined(HAVE_VARIADIC_DEFINE) || defined(GG_TURN_OFF_DEBUGS)
 
 /* See gnugo.h for related TRACE family macro definitions */
 

gnugo/engine/unconditional.c

@@ -343 +343 @@
     
     findstones(pos, 2, stones);
     for (k = 0; k < 2 && isolated; k++) {
-      for (r = 0; r < 8 && isolated; r++) {
+      for (r = 0; r < 8; r++) {
         pos2 = stones[k] + delta[r];
         if (!ON_BOARD(pos2)
             || (board[pos2] == color
                 && !same_string(pos, pos2)))
+        {
           isolated = 0;
+          break;
+        }
       }
     }
 
@@ -457 +460 @@
             locally_played_moves--;
           }
         }
-      }
+          }
       if (countstones(pos) > 2)
         break;
-    }
+        }
   }
 
   /* Capture the strings involved in potential sekis. */

gnugo/engine/utils.c

@@ -731 +731 @@
 void
 set_depth_values(int level, int report_levels)
 {
-  static int node_limits[] = {500, 500, 450, 400, 400, 325, 275,
-                              200, 150, 100, 75, 50};
+  const int node_limits[] = {500, 500, 450, 400, 400, 325, 275,
+                             200, 150, 100, 75, 50};
   int depth_level;
 
   /*
@@ -858 +858 @@
 
   depth_offset = 0;
   
+#ifndef GG_TURN_OFF_TRACES
   if (report_levels) {
     fprintf(stderr, "at level %d:\n\n\
 depth: %d\n\
@@ -889 +890 @@
             connect_depth2, connection_node_limit, breakin_depth, 
             breakin_node_limit);
   }
+#else
+  UNUSED(report_levels);
+#endif
 }
 
 

gnugo/engine/value_moves.c

@@ -69 +69 @@
   }
 
   for (k = 0; k < strings; k++) {
+    int count_lib;
     if (worm[ss[k]].invincible)
       continue;
+    count_lib = countlib(ss[k]);
     if (board[ss[k]] == color) {
       int newlibs = approxlib(pos, color, MAXLIBS, NULL);
       own_strings++;
-      if (newlibs >= countlib(ss[k])) {
-        if (countlib(ss[k]) <= 4)
+      if (newlibs >= count_lib) {
+        if (count_lib <= 4)
           fewlibs++;
-        if (countlib(ss[k]) <= 2)
+        if (count_lib <= 2)
           fewlibs++;
       }
     }
     else {
-      if (countlib(ss[k]) <= 2)
+      if (count_lib <= 2)
         fewlibs++;
-      if (countlib(ss[k]) <= 1 && to_move) {
+      if (count_lib <= 1 && to_move) {
         int dummy[MAXCHAIN];
         fewlibs++;
         fewlibs += chainlinks2(ss[k], dummy, 1);
@@ -765 +767 @@
     int potential_semeai_move_found = 0;
     int other_move_reason_found = 0;
 
-    if (!ON_BOARD1(pos))
+    if (!ON_BOARD(pos))
       continue;
     for (k = 0; k < MAX_REASONS; k++) {