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;