Ticket #148: loops.patch

engine/board.c

@@ -1972 +1972 @@
    * it is not optimized much.
    */
   else {
-    int k;
+    const int *cur_delta, *last_delta;
     int other = OTHER_COLOR(color);
 
-    for (k = 0; k < 4; k++) {
-      int neighbor_pos = pos + delta[k];
+    cur_delta = delta;
+    last_delta = cur_delta + 4;
+    for (; cur_delta < last_delta; cur_delta++) {
+      int neighbor_pos = pos + *cur_delta;
 
       if (LIBERTY(neighbor_pos)
           && (ally1 < 0 || !NEIGHBOR_OF_STRING(neighbor_pos, ally1, color))
@@ -2106 +2108 @@
 do_approxlib(int pos, int color, int maxlib, int *libs,
              struct board_cache_entry *entry)
 {
-  int k;
+  int *cur_lib, *last_lib;
   int liberties = 0;
-  int checked_pos, str_nr, str_libs, checked_lib;
+  int checked_pos, str_nr;
 
   /* Look for empty neighbors and the liberties of the adjacent
    * strings of the given color. The algorithm below won't work
@@ -2138 +2140 @@
   }
   else if (board[checked_pos] == color) {
     str_nr = string_number[checked_pos];
-    str_libs = string[str_nr].liberties;
-    for (k = 0; k < str_libs; k++) {
-      checked_lib = string_libs[str_nr].list[k];
-      if (UNMARKED_LIBERTY(checked_lib)) {
+    cur_lib = string_libs[str_nr].list;
+    last_lib = cur_lib + string[str_nr].liberties;
+    for (; cur_lib < last_lib; cur_lib++) {
+      if (UNMARKED_LIBERTY(*cur_lib)) {
         if (libs != NULL)
-          libs[liberties] = checked_lib;
+          libs[liberties] = *cur_lib;
         liberties++;
         if (liberties >= maxlib)
           return liberties;
-        MARK_LIBERTY(checked_lib);
+        MARK_LIBERTY(*cur_lib);
       }
     }
   }
@@ -2166 +2168 @@
   }
   else if (board[checked_pos] == color) {
     str_nr = string_number[checked_pos];
-    str_libs = string[str_nr].liberties;
-    for (k = 0; k < str_libs; k++) {
-      checked_lib = string_libs[str_nr].list[k];
-      if (UNMARKED_LIBERTY(checked_lib)) {
+    cur_lib = string_libs[str_nr].list;
+    last_lib = cur_lib + string[str_nr].liberties;
+    for (; cur_lib < last_lib; cur_lib++) {
+      if (UNMARKED_LIBERTY(*cur_lib)) {
         if (libs != NULL)
-          libs[liberties] = checked_lib;
+          libs[liberties] = *cur_lib;
         liberties++;
         if (liberties >= maxlib)
           return liberties;
-        MARK_LIBERTY(checked_lib);
+        MARK_LIBERTY(*cur_lib);
       }
     }
   }
@@ -2194 +2196 @@
   }
   else if (board[checked_pos] == color) {
     str_nr = string_number[checked_pos];
-    str_libs = string[str_nr].liberties;
-    for (k = 0; k < str_libs; k++) {
-      checked_lib = string_libs[str_nr].list[k];
-      if (UNMARKED_LIBERTY(checked_lib)) {
+    cur_lib = string_libs[str_nr].list;
+    last_lib = cur_lib + string[str_nr].liberties;
+    for (; cur_lib < last_lib; cur_lib++) {
+      if (UNMARKED_LIBERTY(*cur_lib)) {
         if (libs != NULL)
-          libs[liberties] = checked_lib;
+          libs[liberties] = *cur_lib;
         liberties++;
         if (liberties >= maxlib)
           return liberties;
-        MARK_LIBERTY(checked_lib);
+        MARK_LIBERTY(*cur_lib);
       }
     }
   }
@@ -2224 +2226 @@
   }
   else if (board[checked_pos] == color) {
     str_nr = string_number[checked_pos];
-    str_libs = string[str_nr].liberties;
-    for (k = 0; k < str_libs; k++) {
-      checked_lib = string_libs[str_nr].list[k];
-      if (UNMARKED_LIBERTY(checked_lib)) {
+    cur_lib = string_libs[str_nr].list;
+    last_lib = cur_lib + string[str_nr].liberties;
+    for (; cur_lib < last_lib; cur_lib++) {
+      if (UNMARKED_LIBERTY(*cur_lib)) {
         if (libs != NULL)
-          libs[liberties] = checked_lib;
+          libs[liberties] = *cur_lib;
         liberties++;
         if (liberties >= maxlib)
           return liberties;
-        MARK_LIBERTY(checked_lib);
+        MARK_LIBERTY(*cur_lib);
       }
     }
   }
@@ -2259 +2261 @@
 slow_approxlib(int pos, int color, int maxlib, int *libs,
                struct board_cache_entry *entry)
 {
-  int k;
+  const int *delta_o, *delta_i, *last_delta = delta + 4;
   int liberties = 0;
   int checked_pos, checked_pos2;
   int pos2, str_nr, first_stone;
@@ -2268 +2270 @@
   MARK_LIBERTY(pos);
   string_mark++;
 
-  for (k = 0; k < 4; k++) {
-    checked_pos = pos + delta[k];
+  for (delta_o = delta; delta_o < last_delta; delta_o++) {
+    checked_pos = pos + *delta_o;
     if (board[checked_pos] == EMPTY) {
       if (ml[checked_pos] != liberty_mark) {
         if (libs)
@@ -2286 +2288 @@
       pos2 = first_stone;
       do {
         int l;
-        for (l = 0; l < 4; l++) {
-          checked_pos2 = pos2 + delta[l];
+        for (delta_i = delta; delta_i < last_delta; delta_i++) {
+          checked_pos2 = pos2 + *delta_i;
           if (UNMARKED_LIBERTY(checked_pos2)) {
             if (libs)
               libs[liberties] = checked_pos2;
@@ -2414 +2416 @@
 do_accuratelib(int pos, int color, int maxlib, int *libs,
                struct board_cache_entry *entry)
 {
-  int k, l;
+  const int *act_delta, *last_delta;
+  int *act_lib, *last_lib;
   int lib_count = 0;
-  int lib;
   int captured[4];
   int captures = 0;
+  int *act_capture, *check_capture, *last_capture;
   int first_stone;
   int stone_pos;
   int checked_lib;
@@ -2427 +2430 @@
   liberty_mark++;
   MARK_LIBERTY(pos);
 
-  for (k = 0; k < 4; k++) {
-    int checked_pos = pos + delta[k];
+  act_delta = delta;
+  last_delta = act_delta + 4;
+  for (; act_delta < last_delta; act_delta++) {
+    int checked_pos = pos + *act_delta;
     if (board[checked_pos] == EMPTY) {
       if (ml[checked_pos] != liberty_mark) {
         /* A trivial liberty */
@@ -2451 +2456 @@
           /* The easy case - we already have all (necessary) liberties of
            * the string listed
            */
-          struct string_liberties_data *sl = string_libs + neighbor_nr;
-          for (l = 0; l < liberties; l++) {
-            lib = sl->list[l];
-            if (UNMARKED_LIBERTY(lib)) {
+          act_lib = (string_libs + neighbor_nr)->list;
+          last_lib = act_lib + liberties;
+          for (; act_lib < last_lib; act_lib++) {
+            if (UNMARKED_LIBERTY(*act_lib)) {
               if (libs)
-                libs[lib_count] = lib;
+                libs[lib_count] = *act_lib;
               lib_count++;
               if (lib_count >= maxlib)
                 return lib_count;
 
-              MARK_LIBERTY(lib);
+              MARK_LIBERTY(*act_lib);
             }
           }
         }
@@ -2531 +2536 @@
   }
 
   /* Now we look at all the captures found in the previous step */
-  for (k = 0; k < captures; k++) {
+  act_capture = captured;
+  last_capture = captured + captures;
+  for (; act_capture < last_capture; act_capture++) {
     int capture_nr;
-    first_stone = captured[k];
+    first_stone = *act_capture;
 
     /* Add the stone adjacent to (pos) to the list of liberties if
      * it is not also adjacent to an own marked string (otherwise,
@@ -2557 +2564 @@
 
     /* Check if we already know of this capture. */
     capture_nr = string_number[stone_pos];
-    for (l = 0; l < k; l++)
-      if (string_number[captured[l]] == capture_nr)
+    check_capture = captured;
+    for (; check_capture < act_capture; check_capture++)
+      if (string_number[*check_capture] == capture_nr)
         break;
 
-    if (l == k) {
+    if (check_capture == act_capture) {
       /* Traverse all the stones of the capture and add to the list
        * of liberties those, which are adjacent to at least one own
        * marked string.
@@ -2602 +2610 @@
 count_common_libs(int str1_pos, int str2_pos)
 {
   int all_libs1[MAXLIBS], *libs1;
+  int *last_lib;
   int liberties1, liberties2;
   int str1_nr, str2_nr;
   int commonlibs = 0;
-  int k;
   int color;
 
   ASSERT_ON_BOARD1(str1_pos);
@@ -2636 +2644 @@
       /* Speed optimization: NEIGHBOR_OF_STRING is quite expensive */
       liberty_mark++;
       
-      for (k = 0; k < liberties1; k++)
-        MARK_LIBERTY(libs1[k]);
+      last_lib = libs1 + liberties1;
+      for (; libs1 < last_lib; libs1++)
+        MARK_LIBERTY(*libs1);
 
       libs1 = string_libs[str2_nr].list;
-      for (k = 0; k < liberties2; k++)
-        if (ml[libs1[k]] == liberty_mark)
+      last_lib = libs1 + liberties2;
+      for (; libs1 < last_lib; libs1++)
+        if (ml[*libs1] == liberty_mark)
           commonlibs++;
 
       return commonlibs;
@@ -2653 +2663 @@
   }
   
   color = string[str2_nr].color;
-  for (k = 0; k < liberties1; k++)
-    if (NEIGHBOR_OF_STRING(libs1[k], str2_nr, color))
+  last_lib = libs1 + liberties1;
+  for (; libs1 < last_lib; libs1++)
+    if (NEIGHBOR_OF_STRING(*libs1, str2_nr, color))
       commonlibs++;
   
   return commonlibs;
@@ -2673 +2684 @@
 find_common_libs(int str1_pos, int str2_pos, int maxlib, int *libs)
 {
   int all_libs1[MAXLIBS], *libs1;
+  int *last_lib;
   int liberties1, liberties2;
   int str1_nr, str2_nr;
   int commonlibs = 0;
-  int k;
   int color;
 
   ASSERT_ON_BOARD1(str1_pos);
@@ -2708 +2719 @@
       /* Speed optimization: NEIGHBOR_OF_STRING is quite expensive */
       liberty_mark++;
 
-      for (k = 0; k < liberties1; k++)
-        MARK_LIBERTY(libs1[k]);
-      
+      last_lib = libs1 + liberties1;
+      for (; libs1 < last_lib; libs1++)
+        MARK_LIBERTY(*libs1);
+
       libs1 = string_libs[str2_nr].list;
-      for (k = 0; k < liberties2; k++)
-        if (ml[libs1[k]] == liberty_mark) {
-          if (commonlibs < maxlib)
-            libs[commonlibs] = libs1[k];
+      last_lib = libs1 + liberties2;
+      for (; libs1 < last_lib; libs1++)
+        if (ml[*libs1] == liberty_mark) {
+          if (commonlibs < maxlib)
+            libs[commonlibs] = *libs1;
           commonlibs++;
         }
       
@@ -2728 +2741 @@
   }
   
   color = string[str2_nr].color;
-  for (k = 0; k < liberties1; k++)
-    if (NEIGHBOR_OF_STRING(libs1[k], str2_nr, color)) {
+  last_lib = libs1 + liberties1;
+  for (; libs1 < last_lib; libs1++)
+    if (NEIGHBOR_OF_STRING(*libs1, str2_nr, color)) {
       if (commonlibs < maxlib)
-        libs[commonlibs] = libs1[k];
+        libs[commonlibs] = *libs1;
       commonlibs++;
     }
   
@@ -2746 +2760 @@
 have_common_lib(int str1_pos, int str2_pos, int *lib)
 {
   int all_libs1[MAXLIBS], *libs1;
+  int *last_lib;
   int liberties1, liberties2;
   int str1_nr, str2_nr;
-  int k;
   int color;
 
   ASSERT_ON_BOARD1(str1_pos);
@@ -2780 +2794 @@
   }
 
   color = string[str2_nr].color;
-  for (k = 0; k < liberties1; k++) {
-    if (NEIGHBOR_OF_STRING(libs1[k], str2_nr, color)) {
+  last_lib = libs1 + liberties1;
+  for (; libs1 < last_lib; libs1++)
+    if (NEIGHBOR_OF_STRING(*libs1, str2_nr, color)) {
       if (lib)
-        *lib = libs1[k];
+        *lib = *libs1;
       return 1;
     }
-  }
   
   return 0;
 }
@@ -2818 +2832 @@
   int str_nr;
   int size;
   int pos;
-  int k;
-  int limit;
+  int *limit;
 
   ASSERT_ON_BOARD1(str_pos);
   ASSERT1(IS_STONE(board[str_pos]), str_pos);
@@ -2829 +2842 @@
   
   /* Traverse the stones of the string, by following the cyclic chain. */
   pos = FIRST_STONE(str_nr);
-  limit = maxstones > size ? size : maxstones;
-  for (k = 0; k < limit; k++) {
-    stones[k] = pos;
+  limit = stones + (maxstones > size ? size : maxstones);
+  for (; stones < limit; stones++) {
+    *stones = pos;
     pos = NEXT_STONE(pos);
   }
 
@@ -2886 +2899 @@
 int 
 chainlinks(int str_pos, int adj[MAXCHAIN])
 {
-  struct string_neighbors_data *sn;
-  int k;
+  int *cur_neighbor, *last_neigbor;
   int neighbors;
 
   ASSERT1(IS_STONE(board[str_pos]), str_pos);
@@ -2896 +2908 @@
    * desired information.
    */
   neighbors = string[string_number[str_pos]].neighbors;
-  sn = string_neighbors + string_number[str_pos];
-  for (k = 0; k < neighbors; k++)
-    adj[k] = string[sn->list[k]].origin;
+  cur_neighbor = (string_neighbors + string_number[str_pos])->list;
+  last_neigbor = cur_neighbor + neighbors;
+  for (; cur_neighbor < last_neigbor; adj++, cur_neighbor++)
+    *adj = string[*cur_neighbor].origin;
 
   return neighbors;
 }
@@ -2912 +2925 @@
 int
 chainlinks2(int str_pos, int adj[MAXCHAIN], int lib)
 {
-  struct string_neighbors_data *sn;
-  int k;
-  int neighbors, max_neighbors;
+  int *cur_neighbor, *last_neigbor;
+  int neighbors;
 
   ASSERT1(IS_STONE(board[str_pos]), str_pos);
 
@@ -2922 +2934 @@
    * right number of liberties.
    */
   neighbors = 0;
-  max_neighbors = string[string_number[str_pos]].neighbors;
-  sn = string_neighbors + string_number[str_pos];
-  for (k = 0; k < max_neighbors; k++) {
-    if (string[sn->list[k]].liberties == lib)
-      adj[neighbors++] = string[sn->list[k]].origin;
+  cur_neighbor = (string_neighbors + string_number[str_pos])->list;
+  last_neigbor = cur_neighbor + string[string_number[str_pos]].neighbors;
+  for (; cur_neighbor < last_neigbor; cur_neighbor++) {
+    if (string[*cur_neighbor].liberties == lib)
+      adj[neighbors++] = string[*cur_neighbor].origin;
   }
   return neighbors;
 }
@@ -2940 +2952 @@
 int
 chainlinks3(int str_pos, int adj[MAXCHAIN], int lib)
 {
-  struct string_neighbors_data *sn;
-  int k;
-  int neighbors, max_neighbors;
+  int *cur_neighbor, *last_neigbor;
+  int neighbors;
 
   ASSERT1(IS_STONE(board[str_pos]), str_pos);
 
@@ -2950 +2961 @@
    * right number of liberties.
    */
   neighbors = 0;
-  max_neighbors = string[string_number[str_pos]].neighbors;
-  sn = string_neighbors + string_number[str_pos];
-  for (k = 0; k < max_neighbors; k++) {
-    if (string[sn->list[k]].liberties <= lib)
-      adj[neighbors++] = string[sn->list[k]].origin;
+  cur_neighbor = (string_neighbors + string_number[str_pos])->list;
+  last_neigbor = cur_neighbor + string[string_number[str_pos]].neighbors;
+  for (; cur_neighbor < last_neigbor; cur_neighbor++) {
+    if (string[*cur_neighbor].liberties <= lib)
+      adj[neighbors++] = string[*cur_neighbor].origin;
   }
   return neighbors;
 }
@@ -2972 +2983 @@
 int 
 extended_chainlinks(int str_pos, int adj[MAXCHAIN], int both_colors)
 {
-  struct string_neighbors_data *sn;
-  int n;
-  int r;
+  int *cur_neighbor, *last_neigbor;
   int libs[MAXLIBS];
-  int liberties;
+  int *cur_lib, *last_lib;
   int checked_pos;
   int color;
   int other;
-  int neighbors;
   int str_nr;
+  int *cur_adj;
 
   ASSERT1(IS_STONE(board[str_pos]), str_pos);
 
   str_nr = string_number[str_pos];
   color = string[str_nr].color;
   other = OTHER_COLOR(color);
-  sn = string_neighbors + str_nr;
   string_mark++;
+  cur_adj = adj;
 
   /* We already have the list of directly adjacent strings ready, just
    * copy it and mark the strings. We also mark ourselves in case
@@ -2997 +3006 @@
    */
   MARK_STRING(str_nr);
 
-  neighbors = string[str_nr].neighbors;
-  for (n = 0; n < neighbors; n++) {
-    adj[n] = string[sn->list[n]].origin;
-    MARK_STRING(sn->list[n]);
+  cur_neighbor = (string_neighbors + str_nr)->list;
+  last_neigbor = cur_neighbor + string[str_nr].neighbors;
+  for (; cur_neighbor < last_neigbor; cur_neighbor++) {
+    *cur_adj++ = string[*cur_neighbor].origin;
+    MARK_STRING(*cur_neighbor);
   }
 
   /* Get the liberties. */
-  liberties = findlib(str_pos, MAXLIBS, libs);
+  cur_lib = libs;
+  last_lib = cur_lib + findlib(str_pos, MAXLIBS, libs);
 
   /* Look for unmarked strings next to a liberty and add the
    * ones which are found to the output.
    */
-  for (r = 0; r < liberties; r++) {
-    checked_pos = SOUTH(libs[r]);
+  for (; cur_lib < last_lib; cur_lib++) {
+    checked_pos = SOUTH(*cur_lib);
     if (board[checked_pos] == other
         || (both_colors && board[checked_pos] == color)) {
       str_nr = string_number[checked_pos];
       if (UNMARKED_STRING(str_nr)) {
         MARK_STRING(str_nr);
-        adj[n++] = string[str_nr].origin;
+        *cur_adj++ = string[str_nr].origin;
       }
     }
 
-    checked_pos = WEST(libs[r]);
+    checked_pos = WEST(*cur_lib);
     if (board[checked_pos] == other
         || (both_colors && board[checked_pos] == color)) {
       str_nr = string_number[checked_pos];
       if (UNMARKED_STRING(str_nr)) {
         MARK_STRING(str_nr);
-        adj[n++] = string[str_nr].origin;
+        *cur_adj++ = string[str_nr].origin;
       }
     }
 
-    checked_pos = NORTH(libs[r]);
+    checked_pos = NORTH(*cur_lib);
     if (board[checked_pos] == other
         || (both_colors && board[checked_pos] == color)) {
       str_nr = string_number[checked_pos];
       if (UNMARKED_STRING(str_nr)) {
         MARK_STRING(str_nr);
-        adj[n++] = string[str_nr].origin;
+        *cur_adj++ = string[str_nr].origin;
       }
     }
 
-    checked_pos = EAST(libs[r]);
+    checked_pos = EAST(*cur_lib);
     if (board[checked_pos] == other
         || (both_colors && board[checked_pos] == color)) {
       str_nr = string_number[checked_pos];
       if (UNMARKED_STRING(str_nr)) {
         MARK_STRING(str_nr);
-        adj[n++] = string[str_nr].origin;
+        *cur_adj++ = string[str_nr].origin;
       }
     }
   }
   
-  return n;
+  return cur_adj - adj;
 }
 
 
@@ -3321 +3332 @@
 int
 adjacent_strings(int str1_pos, int str2_pos)
 {
-  int k;
+  int *last_neighbor;
   int neighbors1, neighbors2;
   int str1_nr, str2_nr;
   int *neighbors_list;
@@ -3344 +3355 @@
   else
     neighbors_list = string_neighbors[str1_nr].list;
   
-  for (k = 0; k < neighbors1; k++)
-    if (neighbors_list[k] == str2_nr)
+  last_neighbor = neighbors_list + neighbors1;
+  for (; neighbors_list < last_neighbor; neighbors_list++)
+    if (*neighbors_list == str2_nr)
       return 1;
 
   return 0;
@@ -3553 +3565 @@
 int
 move_in_stack(int pos, int cutoff)
 {
-  int k;
-  for (k = cutoff; k < stackp; k++)
-    if (stack[k] == pos)
+  int *act, *last;
+  act = stack + cutoff;
+  last = stack + stackp;
+  for (; act < last; act++)
+    if (*act == pos)
       return 1;
   
   return 0;
@@ -3757 +3771 @@
 propagate_string(int stone_pos, int str_pos, int color)
 {
   int size = 1;
-  int k;
+  const int *act_delta, *last_delta;
   
   if (stone_pos == str_pos) {
     /* Start a new string. */
@@ -3771 +3785 @@
   }
 
   /* Look in all four directions for more stones to add. */
-  for (k = 0; k < 4; k++) {
-    int new_pos = stone_pos + delta[k];
+  act_delta = delta;
+  last_delta = act_delta + 4;
+  for (; act_delta < last_delta; act_delta++) {
+    int new_pos = stone_pos + *act_delta;
     if (board[new_pos] == color
         && string_number[new_pos] == -1)
       size += propagate_string(new_pos, str_pos, color);
@@ -3874 +3890 @@
 update_liberties(int str_nr)
 {
   int pos;
-  int k;
+  int liberties;
   int first_stone;
+  int *cur_lib, *limit;
 
   /* Push the old information. */
   PUSH_VALUE(string[str_nr].liberties);
-  for (k = 0; k < string[str_nr].liberties && k < MAX_LIBERTIES; k++) {
-    PUSH_VALUE(string_libs[str_nr].list[k]);
-  }
+  liberties = string[str_nr].liberties;
+  cur_lib = string_libs[str_nr].list;
+  limit = cur_lib + (liberties < MAX_LIBERTIES ? liberties : MAX_LIBERTIES);
+  for (; cur_lib < limit; cur_lib++)
+    PUSH_VALUE(*cur_lib);
   string[str_nr].liberties = 0;
 
   /* Clear the liberty mark. */
@@ -3936 +3955 @@
       PUSH_VALUE(sn->list[s->neighbors - 1]);
       PUSH_VALUE(sn->list[k]);
       PUSH_VALUE(s->neighbors);
-      sn->list[k] = sn->list[s->neighbors - 1];
       s->neighbors--;
+      sn->list[k] = sn->list[s->neighbors];
 #ifndef GG_TURN_OFF_ASSERTS
       done = 1;
 #endif
@@ -3972 +3991 @@
         PUSH_VALUE(sl->list[s->liberties - 1]);
         PUSH_VALUE(sl->list[k]);
         PUSH_VALUE(s->liberties);
-        sl->list[k] = sl->list[s->liberties - 1];
         s->liberties--;
+        sl->list[k] = sl->list[s->liberties];
         break;
       }
   }
@@ -3988 +4007 @@
 do_remove_string(int str_nr)
 {
   int pos;
-  int k;
-  int *str_neighbors_list = string_neighbors[str_nr].list;
   struct string_data *str_data = string + str_nr;
   int size = str_data->size;
-  int neighbors = str_data->neighbors;
+  int *str_neighbors_list = string_neighbors[str_nr].list;
+  int *last_neighbor = str_neighbors_list + str_data->neighbors;
   int first_stone;
 
   /* Traverse the stones of the string, by following the cyclic chain. */
@@ -4012 +4030 @@
    * update_liberties().
    */
   if (size == 1) {
-    for (k = 0; k < neighbors; k++) {
-      int neighbor_nr = str_neighbors_list[k];
+    for (; str_neighbors_list < last_neighbor; str_neighbors_list++) {
+      int neighbor_nr = *str_neighbors_list;
       int *neighbor_libs = &(string[neighbor_nr].liberties);
 
       remove_neighbor(neighbor_nr, str_nr);
@@ -4028 +4046 @@
     int other = OTHER_COLOR(str_data->color);
     int pos2 = NEXT_STONE(pos);
 
-    for (k = 0; k < neighbors; k++) {
-      int neighbor_nr = str_neighbors_list[k];  
+    for (; str_neighbors_list < last_neighbor; str_neighbors_list++) {
+      int neighbor_nr = *str_neighbors_list;
       int *neighbor_libs = &(string[neighbor_nr].liberties);
 
       remove_neighbor(neighbor_nr, str_nr);
@@ -4049 +4067 @@
     }
   }
   else {
-    for (k = 0; k < neighbors; k++) {
-      remove_neighbor(str_neighbors_list[k], str_nr);
-      update_liberties(str_neighbors_list[k]);
+    for (; str_neighbors_list < last_neighbor; str_neighbors_list++) {
+      remove_neighbor(*str_neighbors_list, str_nr);
+      update_liberties(*str_neighbors_list);
     }
   }
 
@@ -4174 +4192 @@
 static void
 extend_neighbor_string(int pos, int str_nr, int color)
 {
-  int k;
   int liberties_updated = 0;
   int other = OTHER_COLOR(color);
   int checked_pos;
-  int *neighbors_list = string_neighbors[str_nr].list;
+  int *neighbors_list, *last_neighbor;
 
   /* Link in the stone in the cyclic list. */
   int origin = string[str_nr].origin;
@@ -4214 +4231 @@
 
   /* Mark old neighbors of the string. */
   string_mark++;
-  for (k = 0; k < string[str_nr].neighbors; k++)
-    string[neighbors_list[k]].mark = string_mark;
+  neighbors_list = string_neighbors[str_nr].list;
+  last_neighbor = neighbors_list + string[str_nr].neighbors;
+  for (; neighbors_list < last_neighbor; neighbors_list++)
+    string[*neighbors_list].mark = string_mark;
 
   /* Look at the neighbor locations of pos for new liberties and/or
    * neighbor strings.
@@ -4302 +4321 @@
 static void
 assimilate_string(int str_nr, int ass_pos)
 {
-  int k;
   int last;
   int ass_nr = string_number[ass_pos];
   int first_stone;
+  int *cur_neighbor, *last_neigbor;
   string[str_nr].size += string[ass_nr].size;
 
   /* Walk through the assimilated string stones and change
@@ -4339 +4358 @@
    * been marked before this function is called.
    */
   if (string[ass_nr].liberties <= MAX_LIBERTIES) {
-    for (k = 0; k < string[ass_nr].liberties; k++) {
-      int lib_pos = string_libs[ass_nr].list[k];
-      if (UNMARKED_LIBERTY(lib_pos)) {
-        ADD_AND_MARK_LIBERTY(str_nr, lib_pos);
+    int *cur_lib = string_libs[ass_nr].list;
+    int *last_lib = cur_lib + string[ass_nr].liberties;
+    for (; cur_lib < last_lib; cur_lib++) {
+      if (UNMARKED_LIBERTY(*cur_lib)) {
+        ADD_AND_MARK_LIBERTY(str_nr, *cur_lib);
       }
     }
   }
@@ -4367 +4387 @@
    * known neighbors of str_nr are assumed to have been marked before this
    * function is called.
    */
-  for (k = 0; k < string[ass_nr].neighbors; k++) {
-    int neighbor_nr = string_neighbors[ass_nr].list[k];
+  cur_neighbor = string_neighbors[ass_nr].list;
+  last_neigbor = cur_neighbor + string[ass_nr].neighbors;
+  for (; cur_neighbor < last_neigbor; cur_neighbor++) {
+    int neighbor_nr = *cur_neighbor;
     remove_neighbor(neighbor_nr, ass_nr);
     if (string[neighbor_nr].mark != string_mark) {
       PUSH_VALUE(string[neighbor_nr].neighbors);
@@ -4764 +4786 @@
     else { \
       (*number_opponent)++; \
       if (string[str_nr].liberties == 1) { \
-        int r; \
         int *neighbors_list = string_neighbors[str_nr].list; \
-        int neighbors = string[str_nr].neighbors; \
+        int *last_neighbor = neighbors_list + string[str_nr].neighbors; \
         (*captured_stones) += string[str_nr].size; \
-        for (r = 0; r < neighbors; r++) { \
-          if (string[neighbors_list[r]].liberties == 1) \
-            (*saved_stones) += string[neighbors_list[r]].size; \
+        for (; neighbors_list < last_neighbor; neighbors_list++) { \
+          if (string[*neighbors_list].liberties == 1) \
+            (*saved_stones) += string[*neighbors_list].size; \
         } \
       } \
       else if (string[str_nr].liberties == 2 && UNMARKED_STRING(str_nr)) { \

engine/matchpat.c

@@ -741 +741 @@
                     struct pattern *pattern, int ll, void *callback_data,
                     signed char goal[BOARDMAX])
 {
-  int k;                        /* Iterate over elements of pattern */
+  struct patval *cur_pat, *last_pat; /* Iterate over elements of pattern */
   int found_goal = (goal == NULL);
   
 #if PROFILE_PATTERNS
@@ -754 +754 @@
 #endif
 
   /* Iterate over the elements of the pattern. */
-  for (k = 0; k < pattern->patlen; k++) {
+  cur_pat = pattern->patn;
+  last_pat = cur_pat + pattern->patlen;
+  for (; cur_pat < last_pat; cur_pat++) {
                                 /* match each point */
     int pos;                    /* absolute (board) co-ords of 
                                    (transformed) pattern element */
 
     /* transform pattern real coordinate... */
-    pos = AFFINE_TRANSFORM(pattern->patn[k].offset, ll, anchor);
+    pos = AFFINE_TRANSFORM(cur_pat->offset, ll, anchor);
     ASSERT_ON_BOARD1(pos);
 
     /* goal check */

engine/movelist.c

@@ -55 +55 @@
 int
 discarded_move_known(int move, int max_points, int points[])
 {
-  int k;
+  int *last_point = points + max_points;
 
-  for (k = 0; k < max_points; k++) {
-    if (points[k] == 0)
+  for (; points < last_point; points++) {
+    if (*points == 0)
       return 0;
-    if (points[k] == move)
+    if (*points == move)
       return 1;
   }
   return 0;
@@ -122 +122 @@
 void
 movelist_change_discarded(int move, int max_points, int points[])
 {
-  int k;
+  int *last_point = points + max_points;
 
   /* We store only max_points discarded moves. */
-  for (k = 0; k < max_points; k++) {
-    if (points[k] == move)
+  for (; points < last_point; points++) {
+    if (*points == move)
       return;
 
-    if (points[k] == 0) {
-      points[k] = move;
+    if (*points == 0) {
+      *points = move;
       return;
     }
   }

engine/unconditional.c

@@ -47 +47 @@
   int libs[MAXLIBS];
   int liberties;
   int pos;
-  int k;
+  int *cur_lib, *last_lib;
   
   while (something_captured) {
     /* Nothing captured so far in this turn of the loop. */
@@ -63 +63 @@
         continue;
 
       /* Try to capture the string at pos. */
-      liberties = findlib(pos, MAXLIBS, libs);
+      cur_lib = libs;
+      last_lib = cur_lib + findlib(pos, MAXLIBS, libs);
       save_moves = moves_played;
-      for (k = 0; k < liberties; k++)
-        moves_played += trymove(libs[k], other, "unconditional_life", pos);
+      for (; cur_lib < last_lib; cur_lib++)
+        moves_played += trymove(*cur_lib, other, "unconditional_life", pos);
       
       /* Successful if already captured or a single liberty remains.
        * Otherwise we must rewind and take back the last batch of moves.
@@ -326 +327 @@
   int other = OTHER_COLOR(color);
   int libs[MAXLIBS];
   int liberties;
+  int *cur_lib, *last_lib;
   int pos;
-  int k, r;
+  int k;
   int moves_played;
   int potential_sekis[BOARDMAX];
   int none_invincible;
@@ -345 +347 @@
     int stones[2];
     int pos2;
     int checked_stone;
+    const int *cur_delta, *last_delta;
     
     if (board[pos] != color
         || find_origin(pos) != pos
@@ -354 +357 @@
     findstones(pos, 2, stones);
     for (k = 0; k < 2 && isolated; k++) {
       checked_stone = stones[k];
-      for (r = 0; r < 8; r++) {
-        pos2 = checked_stone + delta[r];
+      cur_delta = delta;
+      last_delta = cur_delta + 8;
+      for (; cur_delta < last_delta; cur_delta++) {
+        pos2 = checked_stone + *cur_delta;
         if (!ON_BOARD(pos2)
             || (board[pos2] == color
                 && !same_string(pos, pos2)))
@@ -399 +404 @@
       continue;
       
     /* Play as many liberties as we can. */
-    liberties = findlib(pos, MAXLIBS, libs);
-    for (k = 0; k < liberties; k++) {
-      moves_played += trymove(libs[k], other, "unconditional_life", pos);
+    cur_lib = libs;
+    last_lib = cur_lib + findlib(pos, MAXLIBS, libs);
+    for (; cur_lib < last_lib; cur_lib++) {
+      moves_played += trymove(*cur_lib, other, "unconditional_life", pos);
     }
   }
 
@@ -424 +430 @@
 
   /* Now see whether there are any significant sekis on the board. */
   for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+    int r;
     if (!potential_sekis[pos]
         || board[pos] == EMPTY
         || find_origin(pos) != pos)
@@ -478 +485 @@
     if (!potential_sekis[pos] || board[pos] == EMPTY)
       continue;
     /* Play as many liberties as we can. */
-    liberties = findlib(pos, MAXLIBS, libs);
-    for (k = 0; k < liberties; k++)
-      moves_played += trymove(libs[k], other, "unconditional_life", pos);
+    cur_lib = libs;
+    last_lib = cur_lib + findlib(pos, MAXLIBS, libs);
+    for (; cur_lib < last_lib; cur_lib++)
+      moves_played += trymove(*cur_lib, other, "unconditional_life", pos);
   }
     
   /* All opponent strings liberties are now inside opponent territory

engine/worm.c

@@ -102 +102 @@
   
   gg_assert(stackp == 0);
 
-  /* Count liberties of different orders and initialize cutstone fields. */
+  /* Count liberties of different orders. */
   for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+    int lib1;
     if (IS_STONE(board[pos]) && is_worm_origin(pos, pos)) {
-      int lib1, lib2, lib3, lib4;
-      
-      ping_cave(pos, &lib1, &lib2, &lib3, &lib4);
+      ping_cave(pos, &lib1, &worm[pos].liberties2, &worm[pos].liberties3,
+                &worm[pos].liberties4);
       ASSERT1(worm[pos].liberties == lib1, pos);
-      worm[pos].liberties2 = lib2;
-      worm[pos].liberties3 = lib3;
-      worm[pos].liberties4 = lib4;
-      worm[pos].cutstone = 0;
-      worm[pos].cutstone2 = 0;
       propagate_worm(pos);
     }
   }
@@ -745 +740 @@
 find_worm_attacks_and_defenses()
 {
   int str;
-  int k;
   int acode, dcode;
   int attack_point;
   int defense_point;
   static int libs[MAXLIBS];
-  int liberties;
   int color;
   int other;
+  int pos;
 
    /* 1. Start with finding attack points. */
   for (str = BOARDMIN; str < BOARDMAX; str++) {
@@ -779 +773 @@
     if (!IS_STONE(board[str]) || !is_worm_origin(str, str))
       continue;
 
-    if (worm[str].attack_codes[0] != 0) {
+    if (worm[str].attack_codes[0]) {
 
       TRACE("considering defense of %1m\n", str);
       dcode = find_defense(str, &defense_point);
-      if (dcode != 0) {
+      if (dcode) {
         TRACE("worm at %1m can be defended at %1m\n", str, defense_point);
         if (defense_point != NO_MOVE)
           change_defense(str, defense_point, dcode);
@@ -815 +809 @@
   
   /*
    * 5. Find additional attacks and defenses by testing all immediate
-   *    liberties. Further attacks and defenses are found by pattern
-   *    matching and by trying whether each attack or defense point
-   *    attacks or defends other strings.
+   *    liberties. 
    */
   for (str = BOARDMIN; str < BOARDMAX; str++) {
-    color = board[str];
-    if (!IS_STONE(color) || !is_worm_origin(str, str))
+    int *cur_lib, *last_lib;
+    if (!IS_STONE(board[str]) || !is_worm_origin(str, str)
+        || !worm[str].attack_codes[0])
       continue;
-    
+
+    color = board[str];
     other = OTHER_COLOR(color);
     
-    if (worm[str].attack_codes[0] == 0)
-      continue;
-    
     /* There is at least one attack on this group. Try the
      * liberties.
      */
-    liberties = findlib(str, MAXLIBS, libs);
+    cur_lib = libs;
+    last_lib = cur_lib + findlib(str, MAXLIBS, libs);
     
-    for (k = 0; k < liberties; k++) {
-      int pos = libs[k];
-      if (!attack_move_known(pos, str)) {
+    for (; cur_lib < last_lib; cur_lib++) {
+      pos = *cur_lib;
+      if (!attack_move_known(pos, str)
+          && !discarded_move_known(pos, MAX_TACTICAL_POINTS,
+                                   worm[str].discarded_attacks)) {
         /* Try to attack on the liberty. Don't consider
          * send-two-return-one moves.
          */
@@ -855 +849 @@
         }
       }
       /* Try to defend at the liberty. */
-      if (!defense_move_known(pos, str)) {
-        if (worm[str].defense_codes[0] != 0)
-          if (trymove(pos, color, "make_worms", NO_MOVE)) {
+      if (worm[str].defense_codes[0] && !defense_move_known(pos, str)
+          && !discarded_move_known(pos, MAX_TACTICAL_POINTS,
+                                   worm[str].discarded_defenses)) {
+        if (trymove(pos, color, "make_worms", NO_MOVE)) {
+          if (countlib(pos) > 1) {
             acode = attack(str, NULL);
             if (acode != WIN)
               change_defense(str, pos, REVERSE_RESULT(acode));
-            popgo();
           }
+          popgo();
+        }
       }
     }
   }
@@ -1215 +1212 @@
 void 
 propagate_worm(int pos)
 {
-  int k;
-  int num_stones;
+  int *cur_stone, *last_stone;
   int stones[MAX_BOARD * MAX_BOARD];
   gg_assert(stackp == 0);
   ASSERT1(IS_STONE(board[pos]), pos);
 
-  num_stones = findstones(pos, MAX_BOARD * MAX_BOARD, stones);
-  for (k = 0; k < num_stones; k++)
-    if (stones[k] != pos)
-      memcpy(worm + stones[k], worm + pos, sizeof(struct worm_data));
+  cur_stone = stones;
+  last_stone = cur_stone + findstones(pos, MAX_BOARD * MAX_BOARD, stones);
+  for (; cur_stone < last_stone; cur_stone++)
+    if (*cur_stone != pos)
+      memcpy(worm + (*cur_stone), worm + pos, sizeof(struct worm_data));
 }
 
 
@@ -1576 +1573 @@
                 void *data)
 {
   int move;
-  int k;
+  struct patval *cur_el, *last_el;
   UNUSED(data);
 
   gg_assert(stackp==0);
@@ -1604 +1601 @@
   }
 
   /* Loop through pattern elements in search of X strings to attack. */
-  for (k = 0; k < pattern->patlen; ++k) { /* match each point */
-    if (pattern->patn[k].att == ATT_X) {
+  cur_el = pattern->patn;
+  last_el = cur_el + pattern->patlen;
+  for (; cur_el < last_el; ++cur_el) { /* match each point */
+    if (cur_el->att == ATT_X) {
       /* transform pattern real coordinate */
-      int pos = AFFINE_TRANSFORM(pattern->patn[k].offset, ll, anchor);
+      int pos = AFFINE_TRANSFORM(cur_el->offset, ll, anchor);
 
       int str = worm[pos].origin;
 
@@ -1672 +1671 @@
                  void *data)
 {
   int move;
-  int k;
+  struct patval *cur_el, *last_el;
   UNUSED(data);
 
   gg_assert(stackp==0);
@@ -1700 +1699 @@
   }
 
   /* Loop through pattern elements in search for O strings to defend. */
-  for (k = 0; k < pattern->patlen; ++k) { /* match each point */
-    if (pattern->patn[k].att == ATT_O) {
+  cur_el = pattern->patn;
+  last_el = cur_el + pattern->patlen;
+  for (; cur_el < last_el; ++cur_el) { /* match each point */
+    if (cur_el->att == ATT_O) {
       /* transform pattern real coordinate */
-      int pos = AFFINE_TRANSFORM(pattern->patn[k].offset, ll, anchor);
+      int pos = AFFINE_TRANSFORM(cur_el->offset, ll, anchor);
       int str = worm[pos].origin;
 
       if (worm[str].attack_codes[0] == 0