apps/plugins/goban/sgf.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007-2009 Joshua Simmons <mud at majidejima dot com>
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "sgf.h"
  23 #include "sgf_storage.h"
  24 #include "types.h"
  25 #include "goban.h"
  26 #include "board.h"
  27 #include "display.h"
  28 #include "game.h"
  29 #include "util.h"
  30
  31 int sgf_fd = -1;
  32 int unhandled_fd = -1;
  33
  34 int tree_head = -1;
  35 int current_node = -1;
  36 int start_node = -1;
  37
  38 bool header_marked = false;
  39
  40 static int add_child_variation (int *variation_number);
  41
  42 static int get_move_from_node (int handle);
  43
  44 static bool is_important_node (int handle);
  45 static bool goto_next_important_node (bool forward);
  46 static bool retreat_node (void);
  47 static bool advance_node (void);
  48
  49 static bool do_add_stones (void);
  50 static void setup_handicap_helper (unsigned short pos);
  51
  52 static int undo_node_helper (void);
  53
  54 static void set_one_mark (unsigned short pos, enum prop_type_t type);
  55 static void set_label_mark (unsigned short pos, char to_set);
  56
  57 bool
  58 play_move_sgf (unsigned short pos, unsigned char color)
  59 {
  60     int handle;
  61     int prop_handle;
  62     int temp;
  63     int temp2;
  64     union prop_data_t temp_data;
  65     int saved = current_node;
  66
  67     if ((color != BLACK && color != WHITE) ||
  68         (!on_board (pos) && pos != PASS_POS))
  69     {
  70         return false;
  71     }
  72
  73
  74     /* go to the node before the next important node (move/add
  75        stone/variation) this is the right place to look for children, add
  76        variations, whatever. (if there is no next, we're already at the
  77        right place) */
  78
  79     if (get_node (current_node)->next >= 0)
  80     {
  81         current_node = get_node (current_node)->next;
  82
  83         /* true means forward */
  84         if (goto_next_important_node (true))
  85         {
  86             current_node = get_node (current_node)->prev;
  87         }
  88     }
  89
  90
  91     if ((temp = get_matching_child_sgf (pos, color)) >= 0)
  92     {
  93         /* don't have to do anything to set up temp as the right variation
  94            number */
  95
  96     }
  97     else
  98     {
  99         /* now either there were no children, or none matched the one we
 100            want so we have to add a new one */
 101
 102         /* first test if it's legal.  we don't do this above because SGF
 103            files are allowed to have illegal moves in them, and it seems
 104            to make sense to allow traversing those variations without
 105            making the user change to a different play_mode */
 106
 107         bool suicide_allowed = false;
 108
 109         if (rb->strcmp (header.ruleset, "NZ") == 0 ||
 110             rb->strcmp (header.ruleset, "GOE") == 0)
 111         {
 112             suicide_allowed = true;
 113         }
 114
 115         if (play_mode != MODE_FORCE_PLAY &&
 116             !legal_move_board (pos, color, suicide_allowed))
 117         {
 118             return false;
 119         }
 120
 121         handle = add_child_sgf (NULL);
 122
 123         if (handle < 0)
 124         {
 125             current_node = saved;
 126             return false;
 127         }
 128
 129         union prop_data_t temp_prop_data;
 130         temp_prop_data.position = pos;
 131
 132         prop_handle = add_prop_sgf (handle,
 133                                     color == BLACK ? PROP_BLACK_MOVE :
 134                                     PROP_WHITE_MOVE, temp_prop_data);
 135
 136         if (prop_handle < 0)
 137         {
 138             /* TODO: add code to completely remove the child which we
 139                added, and then uncomment the following line.  probably
 140                doens't matter much since we're out of memory, but
 141                whatever
 142                free_storage_sgf(handle); */
 143             rb->splash (2 * HZ,
 144                         "Out of memory led to invalid state.  Please exit.");
 145             current_node = saved;
 146             return false;
 147         }
 148
 149         set_game_modified();
 150
 151         temp = get_matching_child_sgf (pos, color);
 152     }
 153
 154     /* now, one way or another temp has been set to the child variation
 155        number that we should follow, so all we need to do is "choose" it
 156        and redo_node_sgf */
 157
 158     current_node = get_node (current_node)->next;
 159     temp_data.number = temp;
 160
 161     temp2 = add_or_set_prop_sgf (current_node,
 162                                  PROP_VARIATION_CHOICE, temp_data);
 163     /* free up a superfluous prop */
 164     if (temp == 0)
 165     {
 166         delete_prop_handle_sgf (current_node, temp2);
 167     }
 168
 169     current_node = saved;
 170     return redo_node_sgf ();
 171 }
 172
 173 bool
 174 add_mark_sgf (unsigned short pos, enum prop_type_t type)
 175 {
 176     union prop_data_t temp_data;
 177     int temp_handle;
 178     enum prop_type_t original_type;
 179
 180     if (!on_board (pos) || current_node < 0)
 181     {
 182         return false;
 183     }
 184
 185     if (type == PROP_CIRCLE ||
 186         type == PROP_SQUARE ||
 187         type == PROP_TRIANGLE ||
 188         type == PROP_MARK || type == PROP_DIM || type == PROP_SELECTED)
 189     {
 190         temp_data.position = pos;
 191
 192         if ((temp_handle = get_prop_pos_sgf (type, temp_data)) >= 0)
 193         {
 194             original_type = get_prop (temp_handle)->type;
 195             delete_prop_handle_sgf (current_node, temp_handle);
 196
 197             if (type == original_type)
 198             {
 199                 set_one_mark (pos, PROP_INVALID);
 200                 return true;
 201             }
 202         }
 203
 204         add_prop_sgf (current_node, type, temp_data);
 205         set_one_mark (pos, type);
 206
 207         return true;
 208     }
 209     else if (type == PROP_LABEL)
 210     {
 211 #define MIN_LABEL 'a'
 212 #define MAX_LABEL 'f'
 213         int temp_prop_handle = get_node (current_node)->props;
 214
 215         while (temp_prop_handle >= 0)
 216         {
 217             struct prop_t *temp_prop = get_prop (temp_prop_handle);
 218
 219             if (temp_prop->type == PROP_LABEL &&
 220                 temp_prop->data.position == pos)
 221             {
 222                 char to_set = temp_prop->data.label_extra;
 223                 ++to_set;
 224                 if (to_set > MAX_LABEL)
 225                 {
 226                     delete_prop_handle_sgf (current_node, temp_prop_handle);
 227                     set_one_mark (pos, PROP_INVALID);
 228                     return true;
 229                 }
 230
 231                 temp_prop->data.label_extra = to_set;
 232                 set_label_mark (pos, to_set);
 233                 return true;
 234             }
 235
 236             temp_prop_handle = temp_prop->next;
 237         }
 238
 239         temp_data.label_extra = MIN_LABEL;
 240         temp_data.position = pos;
 241
 242         add_prop_sgf (current_node, type, temp_data);
 243         set_label_mark (pos, MIN_LABEL);
 244         return true;
 245     }
 246     else
 247     {
 248         return false;
 249     }
 250 }
 251
 252 bool
 253 add_stone_sgf (unsigned short pos, unsigned char color)
 254 {
 255     int handle;
 256     int prop_handle;
 257     int saved = current_node;
 258     union prop_data_t temp_data;
 259     enum prop_type_t temp_type;
 260     int var_number;
 261     int temp;
 262
 263     if (!on_board (pos))
 264     {
 265         return false;
 266     }
 267
 268     if (color == get_point_board (pos))
 269     {
 270         return false;
 271     }
 272
 273     if ((!is_important_node (current_node) ||
 274          (current_node == start_node && get_move_sgf () < 0)) ||
 275         (get_prop_sgf (current_node, PROP_ADD_BLACK, NULL) >= 0 ||
 276          get_prop_sgf (current_node, PROP_ADD_WHITE, NULL) >= 0 ||
 277          get_prop_sgf (current_node, PROP_ADD_EMPTY, NULL) >= 0) ||
 278         get_node (current_node)->props < 0)
 279     {
 280
 281         if (color == BLACK)
 282         {
 283             temp_type = PROP_ADD_BLACK;
 284         }
 285         else if (color == WHITE)
 286         {
 287             temp_type = PROP_ADD_WHITE;
 288         }
 289         else
 290         {
 291             temp_type = PROP_ADD_EMPTY;
 292         }
 293
 294         temp_data.position = pos;
 295
 296         handle = get_prop_pos_sgf (temp_type, temp_data);
 297
 298         /* we have to always delete the old one and conditionally create a
 299            new one (instead of trying to reuse the old one by changing
 300            the type of it) because if we don't, our invariant with
 301            respect to like-properties being grouped together in the
 302            property list can easily be violated */
 303         if (handle >= 0)
 304         {
 305             temp_data.stone_extra = get_prop (handle)->data.stone_extra;
 306             delete_prop_handle_sgf (current_node, handle);
 307         }
 308         else
 309         {
 310             temp_data.stone_extra = 0;
 311             if (get_point_board (pos) == EMPTY)
 312             {
 313                 temp_data.stone_extra |= FLAG_ORIG_EMPTY;
 314             }
 315             else if (get_point_board (pos) == BLACK)
 316             {
 317                 temp_data.stone_extra |= FLAG_ORIG_BLACK;
 318             }
 319             /* else do nothing */
 320         }
 321
 322         /* now we've saved the information about what the board was
 323            originally like, we can do the actual set */
 324
 325         set_point_board (pos, color);
 326
 327         /* test if what we currently did just returned the board back to
 328            its original for this position.  if so, we DON'T create a new
 329            PROP_ADD_*, because it's not needed (we already deleted the old
 330            one, so in that case we just return) */
 331         if (((temp_data.stone_extra & FLAG_ORIG_EMPTY) && color == EMPTY) ||
 332             (!(temp_data.stone_extra & FLAG_ORIG_EMPTY) &&
 333              (((temp_data.stone_extra & FLAG_ORIG_BLACK) && color == BLACK) ||
 334               (!(temp_data.stone_extra & FLAG_ORIG_BLACK) && color == WHITE))))
 335         {
 336             /* do nothing, set back to original */
 337         }
 338         else
 339         {
 340             /* we're not set back to original, so add a prop for it */
 341             add_prop_sgf (current_node, temp_type, temp_data);
 342         }
 343
 344         set_game_modified();
 345
 346         return true;
 347     }
 348     else
 349     {
 350         /* we have to make a child variation and add stones in it */
 351
 352         /* go to the node before the next important node (move/add
 353            stone/variation) this is the right place to look for children,
 354            add variations, whatever. (if there is no next, we're already
 355            at the right place) */
 356
 357         if (get_node (current_node)->next >= 0)
 358         {
 359             current_node = get_node (current_node)->next;
 360
 361             /* true means forward */
 362             if (goto_next_important_node (true))
 363             {
 364                 current_node = get_node (current_node)->prev;
 365             }
 366         }
 367
 368         handle = add_child_sgf (&var_number);
 369
 370         if (handle < 0)
 371         {
 372             rb->splash (2 * HZ, "Out of memory!");
 373             return false;
 374         }
 375
 376         temp_data.position = pos;
 377
 378         if (color == BLACK)
 379         {
 380             temp_type = PROP_ADD_BLACK;
 381         }
 382         else if (color == WHITE)
 383         {
 384             temp_type = PROP_ADD_WHITE;
 385         }
 386         else
 387         {
 388             temp_type = PROP_ADD_EMPTY;
 389         }
 390
 391         prop_handle = add_prop_sgf (handle, temp_type, temp_data);
 392
 393         if (prop_handle < 0)
 394         {
 395             /* TODO: add code to completely remove the child which we
 396                added, and then uncomment the following line.  probably
 397                doens't matter much since we're out of memory, but
 398                whatever
 399                free_storage_sgf(handle); */
 400             rb->splash (2 * HZ, "Out of memory!");
 401             return false;
 402         }
 403
 404         set_game_modified();
 405
 406         /* now, "choose" the variation that we just added */
 407
 408         current_node = get_node (current_node)->next;
 409         temp_data.number = var_number;
 410
 411         temp = add_or_set_prop_sgf (current_node,
 412                                     PROP_VARIATION_CHOICE, temp_data);
 413
 414         /* free up a superfluous prop */
 415         if (var_number == 0)
 416         {
 417             delete_prop_handle_sgf (current_node, temp);
 418         }
 419
 420         current_node = saved;
 421
 422         /* and follow to our choice, returning since we already did the
 423            work */
 424         return redo_node_sgf ();
 425     }
 426
 427     return false;
 428 }
 429
 430 bool
 431 undo_node_sgf (void)
 432 {
 433     int result = undo_node_helper ();
 434
 435     /* if we undid a ko threat, we need to figure out what the ko_pos is
 436        there's no simple way to do this except to undo one /more/ move,
 437        and then redo back to this location. (we could store it, but this
 438        isn't that bad) Note: this doesn't need to recurse because we don't
 439        care what previous move's ko positions were (since the tree is
 440        already set in stone basically, it wouldn't change anything). */
 441     if (result == 1)
 442     {
 443         int backward_move_num = move_num - 1;
 444         int saved_current = current_node;
 445
 446         while (move_num > backward_move_num)
 447         {
 448             result = undo_node_helper ();
 449
 450             if (result < 0)
 451             {
 452                 DEBUGF
 453                     ("couldn't undo to previous move in ko threat handling!\n");
 454                 return false;
 455             }
 456         }
 457
 458         /* now we're backed up to the previous move before our destination
 459            so, let's go forward again until we get to the node we were at
 460          */
 461
 462         while (current_node != saved_current)
 463         {
 464             if (!redo_node_sgf ())
 465             {
 466                 DEBUGF
 467                     ("redoing to correct node failed on ko threat handling!\n");
 468                 return false;
 469             }
 470         }
 471     }
 472     else if (result < 0)
 473     {
 474         DEBUGF ("initial undo failed!\n");
 475         return false;
 476     }
 477
 478     set_all_marks_sgf ();
 479
 480     /* if there is a move in this node, move the screen so that it is
 481        visible */
 482     int handle = get_move_sgf ();
 483     if (handle >= 0)
 484     {
 485         move_display (get_prop (handle)->data.position);
 486     }
 487
 488     return true;
 489 }
 490
 491 static int
 492 undo_node_helper (void)
 493 {
 494     bool ko_threat_move = false;
 495
 496     if (current_node == start_node)
 497     {
 498         /* refuse to undo the initial SGF node, which is tree_head if
 499            handicap == 0 or 1.  If handicap >= 2, start_node is the node
 500            with the handicap crap and added moves on it.  don't let the
 501            user undo past that */
 502         DEBUGF ("not undoing start_node\n");
 503         return -1;
 504     }
 505
 506     struct prop_t *temp_move = get_prop (get_move_sgf ());
 507
 508     if (temp_move)
 509     {
 510         int undone_caps = 0;
 511         int undone_suicides = 0;
 512         unsigned short move_pos = temp_move->data.position;
 513         unsigned char move_color = temp_move->type == PROP_BLACK_MOVE ? BLACK :
 514             WHITE;
 515
 516         unsigned short flags = temp_move->data.stone_extra;
 517
 518         if (move_pos != PASS_POS)
 519         {
 520
 521             if (flags & FLAG_N_CAP)
 522             {
 523                 undone_caps += flood_fill_board (NORTH (move_pos),
 524                                                  OTHER (move_color));
 525             }
 526             if (flags & FLAG_S_CAP)
 527             {
 528                 undone_caps += flood_fill_board (SOUTH (move_pos),
 529                                                  OTHER (move_color));
 530             }
 531             if (flags & FLAG_E_CAP)
 532             {
 533                 undone_caps += flood_fill_board (EAST (move_pos),
 534                                                  OTHER (move_color));
 535             }
 536             if (flags & FLAG_W_CAP)
 537             {
 538                 undone_caps += flood_fill_board (WEST (move_pos),
 539                                                  OTHER (move_color));
 540             }
 541
 542             if (flags & FLAG_SELF_CAP)
 543             {
 544                 undone_suicides += flood_fill_board (move_pos, move_color);
 545             }
 546
 547             if (flags & FLAG_ORIG_EMPTY)
 548             {
 549                 set_point_board (move_pos, EMPTY);
 550             }
 551             else if (flags & FLAG_ORIG_BLACK)
 552             {
 553                 set_point_board (move_pos, BLACK);
 554             }
 555             else
 556             {
 557                 set_point_board (move_pos, WHITE);
 558             }
 559         }
 560
 561         if (move_color == BLACK)
 562         {
 563             black_captures -= undone_caps;
 564             white_captures -= undone_suicides;
 565         }
 566         else
 567         {
 568             white_captures -= undone_caps;
 569             black_captures -= undone_suicides;
 570         }
 571
 572         if (flags & FLAG_KO_THREAT)
 573         {
 574             ko_threat_move = true;
 575         }
 576
 577         --move_num;
 578         current_player = OTHER (current_player);
 579     }
 580     else
 581     {
 582         /* test for added stones! */
 583         struct prop_t *temp_prop;
 584
 585         temp_prop = get_prop (get_node (current_node)->props);
 586
 587         while (temp_prop)
 588         {
 589             if ((temp_prop->type == PROP_ADD_BLACK ||
 590                  temp_prop->type == PROP_ADD_WHITE ||
 591                  temp_prop->type == PROP_ADD_EMPTY) &&
 592                 on_board (temp_prop->data.position))
 593             {
 594                 if (temp_prop->data.stone_extra & FLAG_ORIG_EMPTY)
 595                 {
 596                     set_point_board (temp_prop->data.position, EMPTY);
 597                 }
 598                 else if (temp_prop->data.stone_extra & FLAG_ORIG_BLACK)
 599                 {
 600                     set_point_board (temp_prop->data.position, BLACK);
 601                 }
 602                 else
 603                 {
 604                     set_point_board (temp_prop->data.position, WHITE);
 605                 }
 606             }
 607
 608             temp_prop = get_prop (temp_prop->next);
 609         }
 610     }
 611
 612     if (!retreat_node ())
 613     {
 614         return -1;
 615     }
 616
 617     if (ko_threat_move)
 618     {
 619         return 1;
 620     }
 621
 622     return 0;
 623 }
 624
 625 bool
 626 redo_node_sgf (void)
 627 {
 628     if (!advance_node ())
 629     {
 630         return false;
 631     }
 632
 633     set_all_marks_sgf ();
 634
 635     int temp_move = get_move_sgf ();
 636     if (temp_move >= 0)
 637     {
 638         struct prop_t *move_prop = get_prop (temp_move);
 639         unsigned short pos = move_prop->data.position;
 640         unsigned char color =
 641             move_prop->type == PROP_BLACK_MOVE ? BLACK : WHITE;
 642
 643         if (color != current_player)
 644         {
 645             DEBUGF ("redo_node_sgf: wrong color!\n");
 646         }
 647
 648         /* zero out the undo information and set the ko threat flag to the
 649            correct value */
 650
 651         move_prop->data.stone_extra = 0;
 652
 653         if (ko_pos != INVALID_POS)
 654         {
 655             move_prop->data.stone_extra |= FLAG_KO_THREAT;
 656         }
 657
 658         ko_pos = INVALID_POS;
 659
 660         if (pos == PASS_POS)
 661         {
 662             rb->splashf (HZ / 2, "%s Passes",
 663                          color == BLACK ? "Black" : "White");
 664         }
 665         else
 666         {
 667             int n_cap, s_cap, e_cap, w_cap, self_cap;
 668
 669             n_cap = s_cap = e_cap = w_cap = self_cap = 0;
 670
 671             if (get_point_board (pos) == EMPTY)
 672             {
 673                 move_prop->data.stone_extra |= FLAG_ORIG_EMPTY;
 674             }
 675             else if (get_point_board (pos) == BLACK)
 676             {
 677                 move_prop->data.stone_extra |= FLAG_ORIG_BLACK;
 678             }
 679             /* else do nothing */
 680
 681             set_point_board (pos, color);
 682
 683             /* do captures on the 4 cardinal directions, if the opponent
 684                stones are breathless */
 685             if (get_point_board (NORTH (pos)) == OTHER (color) &&
 686                 get_liberties_board (NORTH (pos)) == 0)
 687             {
 688                 n_cap = flood_fill_board (NORTH (pos), EMPTY);
 689                 move_prop->data.stone_extra |= FLAG_N_CAP;
 690             }
 691             if (get_point_board (SOUTH (pos)) == OTHER (color) &&
 692                 get_liberties_board (SOUTH (pos)) == 0)
 693             {
 694                 s_cap = flood_fill_board (SOUTH (pos), EMPTY);
 695                 move_prop->data.stone_extra |= FLAG_S_CAP;
 696             }
 697             if (get_point_board (EAST (pos)) == OTHER (color) &&
 698                 get_liberties_board (EAST (pos)) == 0)
 699             {
 700                 e_cap = flood_fill_board (EAST (pos), EMPTY);
 701                 move_prop->data.stone_extra |= FLAG_E_CAP;
 702             }
 703             if (get_point_board (WEST (pos)) == OTHER (color) &&
 704                 get_liberties_board (WEST (pos)) == 0)
 705             {
 706                 w_cap = flood_fill_board (WEST (pos), EMPTY);
 707                 move_prop->data.stone_extra |= FLAG_W_CAP;
 708             }
 709
 710             /* then check for suicide */
 711             if (get_liberties_board (pos) == 0)
 712             {
 713                 self_cap = flood_fill_board (pos, EMPTY);
 714                 move_prop->data.stone_extra |= FLAG_SELF_CAP;
 715             }
 716
 717
 718             /* now check for a ko, with the following requirements: 1) we
 719                captured one opponent stone 2) we placed one stone (not
 720                connected to a larger group) 3) we have one liberty */
 721
 722             if (!self_cap &&
 723                 (n_cap + s_cap + e_cap + w_cap == 1) &&
 724                 get_liberties_board (pos) == 1 &&
 725                 get_point_board (NORTH (pos)) != color &&
 726                 get_point_board (SOUTH (pos)) != color &&
 727                 get_point_board (EAST (pos)) != color &&
 728                 get_point_board (WEST (pos)) != color)
 729             {
 730                 /* We passed all tests, so there is a ko to set. The
 731                    ko_pos is our single liberty location */
 732
 733                 if (get_point_board (NORTH (pos)) == EMPTY)
 734                 {
 735                     ko_pos = NORTH (pos);
 736                 }
 737                 else if (get_point_board (SOUTH (pos)) == EMPTY)
 738                 {
 739                     ko_pos = SOUTH (pos);
 740                 }
 741                 else if (get_point_board (EAST (pos)) == EMPTY)
 742                 {
 743                     ko_pos = EAST (pos);
 744                 }
 745                 else
 746                 {
 747                     ko_pos = WEST (pos);
 748                 }
 749             }
 750
 751             if (color == BLACK)
 752             {
 753                 black_captures += n_cap + s_cap + e_cap + w_cap;
 754                 white_captures += self_cap;
 755             }
 756             else
 757             {
 758                 white_captures += n_cap + s_cap + e_cap + w_cap;
 759                 black_captures += self_cap;
 760             }
 761
 762             /* this will move the cursor near this move if it was off the
 763                screen */
 764             move_display (pos);
 765         }
 766
 767         ++move_num;
 768         current_player = OTHER (color);
 769
 770         goto redo_node_sgf_succeeded;
 771     }
 772     else if (do_add_stones ())
 773     {
 774         goto redo_node_sgf_succeeded;
 775     }
 776
 777     return false;
 778     char comment_buffer[512];
 779
 780 redo_node_sgf_succeeded:
 781 #if !defined(GBN_TEST)
 782     if (auto_show_comments &&
 783         read_comment_sgf (comment_buffer, sizeof (comment_buffer)))
 784     {
 785         unsigned int i;
 786         for (i = 0; i < sizeof (comment_buffer); ++i)
 787         {
 788             /* newlines display badly in rb->splash, so replace them
 789              * with spaces
 790              */
 791             if (comment_buffer[i] == '\n' ||
 792                 comment_buffer[i] == '\r')
 793             {
 794                 comment_buffer[i] = ' ';
 795             }
 796             else if (comment_buffer[i] == '\0')
 797             {
 798                 break;
 799             }
 800         }
 801         draw_screen_display();
 802         rb->splash(HZ / 3, comment_buffer);
 803         rb->button_clear_queue();
 804         rb->action_userabort(TIMEOUT_BLOCK);
 805     }
 806 #else
 807     (void) comment_buffer;
 808 #endif
 809
 810     return true;
 811 }
 812
 813 int
 814 mark_child_variations_sgf (void)
 815 {
 816     int result;
 817     int saved = current_node;
 818     struct node_t *node = get_node (current_node);
 819
 820     int move_handle;
 821
 822     if (!node)
 823     {
 824         return 0;
 825     }
 826
 827     current_node = node->next;
 828     goto_next_important_node (true);
 829
 830     result = num_variations_sgf ();
 831
 832     if (result > 1)
 833     {
 834         int i;
 835         int branch_node = current_node;
 836         for (i = 0; i < result; ++i)
 837         {
 838             go_to_variation_sgf (i);
 839             goto_next_important_node (true);
 840
 841             move_handle = get_move_sgf ();
 842
 843             if (move_handle >= 0)
 844             {
 845                 set_one_mark (get_prop (move_handle)->data.position,
 846                               get_prop (move_handle)->type);
 847             }
 848
 849             current_node = branch_node;
 850         }
 851     }
 852
 853     current_node = saved;
 854
 855     return result;
 856 }
 857
 858 void
 859 set_all_marks_sgf (void)
 860 {
 861     struct prop_t *prop = get_prop (get_node (current_node)->props);
 862
 863     while (prop)
 864     {
 865         if (prop->type == PROP_LABEL)
 866         {
 867             set_label_mark (prop->data.position, prop->data.label_extra);
 868         }
 869         else if (prop->type == PROP_COMMENT)
 870         {
 871             set_comment_display (true);
 872         }
 873         else
 874         {
 875             set_one_mark (prop->data.position, prop->type);
 876         }
 877         prop = get_prop (prop->next);
 878     }
 879 }
 880
 881 static void
 882 set_one_mark (unsigned short pos, enum prop_type_t type)
 883 {
 884     switch (type)
 885     {
 886     case PROP_CIRCLE:
 887         set_mark_display (pos, 'c');
 888         break;
 889     case PROP_SQUARE:
 890         set_mark_display (pos, 's');
 891         break;
 892     case PROP_TRIANGLE:
 893         set_mark_display (pos, 't');
 894         break;
 895     case PROP_MARK:
 896         set_mark_display (pos, 'm');
 897         break;
 898     case PROP_DIM:
 899         set_mark_display (pos, 'd');
 900         break;
 901     case PROP_SELECTED:
 902         set_mark_display (pos, 'S');
 903         break;
 904     case PROP_BLACK_MOVE:
 905         set_mark_display (pos, 'b');
 906         break;
 907     case PROP_WHITE_MOVE:
 908         set_mark_display (pos, 'w');
 909         break;
 910     case PROP_INVALID:
 911         set_mark_display (pos, ' ');
 912     default:
 913         break;
 914     }
 915 }
 916
 917 static void
 918 set_label_mark (unsigned short pos, char to_set)
 919 {
 920     set_mark_display (pos, to_set | (1 << 7));
 921 }
 922
 923 static bool
 924 do_add_stones (void)
 925 {
 926     bool ret_val = false;
 927     struct prop_t *temp_prop;
 928     int temp_handle;
 929
 930     if (current_node < 0)
 931     {
 932         return false;
 933     }
 934
 935     temp_handle = get_node (current_node)->props;
 936     temp_prop = get_prop (temp_handle);
 937
 938     while (temp_prop)
 939     {
 940         if (temp_prop->type == PROP_ADD_BLACK ||
 941             temp_prop->type == PROP_ADD_WHITE ||
 942             temp_prop->type == PROP_ADD_EMPTY)
 943         {
 944
 945             temp_prop->data.stone_extra = 0;
 946
 947             /* TODO: we could delete do-nothing PROP_ADD_*s here */
 948
 949             if (get_point_board (temp_prop->data.position) == EMPTY)
 950             {
 951                 temp_prop->data.stone_extra |= FLAG_ORIG_EMPTY;
 952             }
 953             else if (get_point_board (temp_prop->data.position) == BLACK)
 954             {
 955                 temp_prop->data.stone_extra |= FLAG_ORIG_BLACK;
 956             }
 957             /* else, do nothing */
 958
 959             if (temp_prop->type == PROP_ADD_BLACK ||
 960                 temp_prop->type == PROP_ADD_WHITE)
 961             {
 962                 set_point_board (temp_prop->data.position,
 963                                  temp_prop->type == PROP_ADD_BLACK ? BLACK :
 964                                  WHITE);
 965                 ret_val = true;
 966             }
 967             else
 968             {
 969                 set_point_board (temp_prop->data.position, EMPTY);
 970
 971                 ret_val = true;
 972             }
 973         }
 974
 975         temp_handle = temp_prop->next;
 976         temp_prop = get_prop (temp_handle);
 977     }
 978
 979     return ret_val;
 980 }
 981
 982 int
 983 add_child_sgf (int *variation_number)
 984 {
 985     int node_handle;
 986     struct node_t *node;
 987     struct node_t *current = get_node (current_node);
 988
 989     if (current->next < 0)
 990     {
 991         node_handle = alloc_storage_sgf ();
 992         node = get_node (node_handle);
 993
 994         if (node_handle < 0 || !current)
 995         {
 996             return NO_NODE;
 997         }
 998
 999         node->prev = current_node;
1000         node->next = NO_NODE;
1001         node->props = NO_PROP;
1002
1003         current->next = node_handle;
1004
1005         if (variation_number)
1006         {
1007             *variation_number = 0;
1008         }
1009
1010         return node_handle;
1011     }
1012     else
1013     {
1014         return add_child_variation (variation_number);
1015     }
1016 }
1017
1018 int
1019 add_prop_sgf (int node, enum prop_type_t type, union prop_data_t data)
1020 {
1021     int new_prop;
1022     int temp_prop_handle;
1023
1024     if (node < 0)
1025     {
1026         return NO_PROP;
1027     }
1028
1029     new_prop = alloc_storage_sgf ();
1030
1031     if (new_prop < 0)
1032     {
1033         return NO_PROP;
1034     }
1035
1036     get_prop (new_prop)->type = type;
1037     get_prop (new_prop)->data = data;
1038
1039     /* check if the new_prop goes at the start */
1040     if (get_node (node)->props == NO_PROP ||
1041         (type == PROP_VARIATION &&
1042          get_prop (get_node (node)->props)->type != PROP_VARIATION))
1043     {
1044
1045         if (get_node (node)->props >= 0)
1046         {
1047             get_prop (new_prop)->next = get_node (node)->props;
1048         }
1049         else
1050         {
1051             get_prop (new_prop)->next = NO_PROP;
1052         }
1053
1054         get_node (node)->props = new_prop;
1055         return new_prop;
1056     }
1057
1058     temp_prop_handle = get_node (node)->props;
1059
1060     while (1)
1061     {
1062         if (get_prop (temp_prop_handle)->next < 0 ||
1063             (get_prop (temp_prop_handle)->type == type &&
1064              get_prop (get_prop (temp_prop_handle)->next)->type != type))
1065         {
1066             /* new_prop goes after the current one either because we're at
1067                the end of the props list, or because we're adding a prop
1068                after the ones of its same type */
1069             get_prop (new_prop)->next = get_prop (temp_prop_handle)->next;
1070             get_prop (temp_prop_handle)->next = new_prop;
1071
1072             return new_prop;
1073         }
1074
1075         temp_prop_handle = get_prop (temp_prop_handle)->next;
1076     }
1077 }
1078
1079 int
1080 get_prop_pos_sgf (enum prop_type_t type, union prop_data_t data)
1081 {
1082     int temp_prop_handle;
1083     struct prop_t *prop;
1084
1085     if (current_node < 0)
1086     {
1087         return -1;
1088     }
1089
1090     temp_prop_handle = get_node (current_node)->props;
1091
1092     while (temp_prop_handle >= 0)
1093     {
1094         prop = get_prop (temp_prop_handle);
1095
1096         if ((type == PROP_ADD_BLACK ||
1097              type == PROP_ADD_WHITE ||
1098              type == PROP_ADD_EMPTY)
1099             &&
1100             (prop->type == PROP_ADD_BLACK ||
1101              prop->type == PROP_ADD_WHITE ||
1102              prop->type == PROP_ADD_EMPTY)
1103             && (prop->data.position == data.position))
1104         {
1105             return temp_prop_handle;
1106         }
1107
1108         if ((type == PROP_CIRCLE ||
1109              type == PROP_SQUARE ||
1110              type == PROP_TRIANGLE ||
1111              type == PROP_MARK ||
1112              type == PROP_DIM ||
1113              type == PROP_SELECTED) &&
1114             (prop->type == PROP_CIRCLE ||
1115              prop->type == PROP_SQUARE ||
1116              prop->type == PROP_TRIANGLE ||
1117              prop->type == PROP_MARK ||
1118              prop->type == PROP_DIM ||
1119              prop->type == PROP_SELECTED) &&
1120             (prop->data.position == data.position))
1121         {
1122             return temp_prop_handle;
1123         }
1124
1125         temp_prop_handle = get_prop (temp_prop_handle)->next;
1126     }
1127
1128     return -1;
1129 }
1130
1131 int
1132 add_or_set_prop_sgf (int node, enum prop_type_t type, union prop_data_t data)
1133 {
1134     int temp_prop_handle;
1135
1136     if (node < 0)
1137     {
1138         return NO_PROP;
1139     }
1140
1141     temp_prop_handle = get_prop_sgf (node, type, NULL);
1142
1143     if (temp_prop_handle >= 0)
1144     {
1145         get_prop (temp_prop_handle)->data = data;
1146         return temp_prop_handle;
1147     }
1148
1149     /* there was no prop to set, so we need to add one */
1150     return add_prop_sgf (node, type, data);
1151 }
1152
1153 int
1154 get_prop_sgf (int node, enum prop_type_t type, int *previous_prop)
1155 {
1156     int previous_handle = NO_PROP;
1157     int current_handle;
1158
1159     if (node < 0)
1160     {
1161         return NO_PROP;
1162     }
1163
1164     if (get_node (node)->props < 0)
1165     {
1166         return NO_PROP;
1167     }
1168
1169     current_handle = get_node (node)->props;
1170
1171     while (current_handle >= 0)
1172     {
1173         if (get_prop (current_handle)->type == type || type == PROP_ANY)
1174         {
1175             if (previous_prop)
1176             {
1177                 *previous_prop = previous_handle;
1178             }
1179
1180             return current_handle;
1181         }
1182         else
1183         {
1184             previous_handle = current_handle;
1185             current_handle = get_prop (current_handle)->next;
1186         }
1187     }
1188
1189     return NO_PROP;
1190 }
1191
1192 bool
1193 delete_prop_sgf (int node, enum prop_type_t type)
1194 {
1195     if (node < 0)
1196     {
1197         return false;
1198     }
1199
1200     return delete_prop_handle_sgf (node, get_prop_sgf (node, type, NULL));
1201 }
1202
1203 bool
1204 delete_prop_handle_sgf (int node, int prop)
1205 {
1206     int previous;
1207
1208     if (prop < 0 || node < 0 || get_node (node)->props < 0)
1209     {
1210         return false;
1211     }
1212
1213     if (get_node (node)->props == prop)
1214     {
1215         get_node (node)->props = get_prop (get_node (node)->props)->next;
1216         free_storage_sgf (prop);
1217         return true;
1218     }
1219
1220     previous = get_node (node)->props;
1221
1222     while (get_prop (previous)->next != prop && get_prop (previous)->next >= 0)
1223     {
1224         previous = get_prop (previous)->next;
1225     }
1226
1227     if (get_prop (previous)->next < 0)
1228     {
1229         return false;
1230     }
1231     else
1232     {
1233         get_prop (previous)->next = get_prop (get_prop (previous)->next)->next;
1234         free_storage_sgf (prop);
1235         return true;
1236     }
1237 }
1238
1239 int
1240 read_comment_sgf (char *buffer, size_t buffer_size)
1241 {
1242     size_t bytes_read = 0;
1243
1244     int prop_handle = get_prop_sgf (current_node, PROP_COMMENT, NULL);
1245
1246     if (prop_handle < 0)
1247     {
1248         return 0;
1249     }
1250
1251     if (unhandled_fd < 0)
1252     {
1253         DEBUGF ("unhandled file is closed?!\n");
1254         return 0;
1255     }
1256
1257     if (rb->lseek (unhandled_fd, get_prop (prop_handle)->data.number,
1258                    SEEK_SET) < 0)
1259     {
1260         DEBUGF ("couldn't seek in unhandled_fd\n");
1261         return -1;
1262     }
1263
1264     if (!read_char_no_whitespace (unhandled_fd) == 'C' ||
1265         !read_char_no_whitespace (unhandled_fd) == '[')
1266     {
1267         DEBUGF ("comment prop points to incorrect place in unhandled_fd!!\n");
1268         return -1;
1269     }
1270
1271     /* make output a string, the lazy way */
1272     rb->memset (buffer, 0, buffer_size);
1273     ++bytes_read;
1274
1275     bool done = false;
1276     bool escaped = false;
1277
1278     while ((buffer_size > bytes_read) && !done)
1279     {
1280         int temp = read_char (unhandled_fd);
1281
1282         switch (temp)
1283         {
1284         case ']':
1285             if (!escaped)
1286             {
1287                 done = true;
1288                 break;
1289             }
1290             *buffer = temp;
1291             ++buffer;
1292             ++bytes_read;
1293             escaped = false;
1294             break;
1295
1296         case -1:
1297             DEBUGF ("encountered end of file before end of comment!\n");
1298             done = true;
1299             break;
1300
1301         case '\\':
1302             escaped = !escaped;
1303             if (escaped)
1304             {
1305                 break;
1306             }
1307
1308         default:
1309             *buffer = temp;
1310             ++buffer;
1311             ++bytes_read;
1312             escaped = false;
1313             break;
1314         }
1315     }
1316
1317     return bytes_read;
1318 }
1319
1320 int
1321 write_comment_sgf (char *string)
1322 {
1323     char *orig_string = string;
1324
1325     int prop_handle = get_prop_sgf (current_node, PROP_COMMENT, NULL);
1326
1327     int start_of_comment = -1;
1328     bool overwriting = false;
1329
1330     int bytes_written = 0;
1331
1332     set_game_modified();
1333
1334     if (unhandled_fd < 0)
1335     {
1336         DEBUGF ("unhandled file is closed?!\n");
1337         return 0;
1338     }
1339
1340     if (prop_handle >= 0)
1341     {
1342         if ((start_of_comment = rb->lseek (unhandled_fd,
1343                                            get_prop (prop_handle)->data.number,
1344                                            SEEK_SET)) < 0)
1345         {
1346             DEBUGF ("couldn't seek in unhandled_fd\n");
1347             return -1;
1348         }
1349         else
1350         {
1351             overwriting = true;
1352         }
1353     }
1354     else
1355     {
1356         overwriting = false;
1357     }
1358
1359   start_of_write_wcs:
1360
1361     if (overwriting)
1362     {
1363         if (!read_char_no_whitespace (unhandled_fd) == 'C' ||
1364             !read_char_no_whitespace (unhandled_fd) == '[')
1365         {
1366             DEBUGF ("non-comment while overwriting!!\n");
1367             return -1;
1368         }
1369     }
1370     else
1371     {
1372         start_of_comment = rb->lseek (unhandled_fd, 0, SEEK_END);
1373
1374         if (start_of_comment < 0)
1375         {
1376             DEBUGF ("error seeking to end in write_comment_sgf\n");
1377             return -1;
1378         }
1379
1380         write_char (unhandled_fd, 'C');
1381         write_char (unhandled_fd, '[');
1382     }
1383
1384
1385     bool overwrite_escaped = false;
1386
1387     while (*string)
1388     {
1389         if (overwriting)
1390         {
1391             int orig_char = peek_char (unhandled_fd);
1392
1393             switch (orig_char)
1394             {
1395             case '\\':
1396                 overwrite_escaped = !overwrite_escaped;
1397                 break;
1398
1399             case ']':
1400                 if (overwrite_escaped)
1401                 {
1402                     overwrite_escaped = false;
1403                     break;
1404                 }
1405                 /* otherwise, fall through */
1406
1407             case -1:
1408
1409                 /* we reached the end of the part we can put our comment
1410                    in, but there's more comment to write, so we should
1411                    start again, this time making a new comment (the old
1412                    becomes wasted space in unhandled_fd, but it doesn't
1413                    really hurt anything except extra space on disk */
1414
1415                 overwriting = false;
1416                 string = orig_string;
1417                 bytes_written = 0;
1418                 goto start_of_write_wcs;
1419                 break;
1420
1421             default:
1422                 overwrite_escaped = false;
1423                 break;
1424             }
1425         }
1426
1427         switch (*string)
1428         {
1429         case '\\':
1430         case ']':
1431             write_char (unhandled_fd, '\\');
1432
1433             /* fall through */
1434
1435         default:
1436             write_char (unhandled_fd, *string);
1437             break;
1438         }
1439
1440         ++string;
1441         ++bytes_written;
1442     }
1443
1444     /* finish out the record */
1445     write_char (unhandled_fd, ']');
1446     write_char (unhandled_fd, ';');
1447
1448     /* and put the reference into the unhandled_fd into the comment prop */
1449     union prop_data_t temp_data;
1450     temp_data.number = start_of_comment;
1451
1452     add_or_set_prop_sgf (current_node, PROP_COMMENT, temp_data);
1453     set_comment_display (true);
1454     return bytes_written;
1455 }
1456
1457 bool
1458 has_more_nodes_sgf (void)
1459 {
1460     int saved = current_node;
1461     bool ret_val = false;
1462
1463     if (current_node < 0)
1464     {
1465         return false;
1466     }
1467
1468     current_node = get_node (current_node)->next;
1469
1470     if (current_node >= 0)
1471     {
1472         /* returns true if it finds an important node */
1473         ret_val = goto_next_important_node (true);
1474     }
1475
1476     current_node = saved;
1477     return ret_val;
1478 }
1479
1480 /* logic is different here because the first node in a tree is a valid
1481    place to go */
1482 bool
1483 has_prev_nodes_sgf (void)
1484 {
1485     if (current_node < 0)
1486     {
1487         return false;
1488     }
1489
1490     return current_node != start_node;
1491 }
1492
1493 int
1494 get_move_sgf (void)
1495 {
1496     int result = -1;
1497     int saved_current = current_node;
1498
1499     goto_next_important_node (true);
1500
1501     result = get_move_from_node (current_node);
1502
1503     current_node = saved_current;
1504     return result;
1505 }
1506
1507 static int
1508 get_move_from_node (int handle)
1509 {
1510     int prop_handle;
1511
1512     if (handle < 0)
1513     {
1514         return -2;
1515     }
1516
1517     prop_handle = get_node (handle)->props;
1518
1519
1520     while (prop_handle >= 0)
1521     {
1522         if (get_prop (prop_handle)->type == PROP_BLACK_MOVE ||
1523             get_prop (prop_handle)->type == PROP_WHITE_MOVE)
1524         {
1525             return prop_handle;
1526         }
1527
1528         prop_handle = get_prop (prop_handle)->next;
1529     }
1530
1531     return -1;
1532 }
1533
1534 static bool
1535 retreat_node (void)
1536 {
1537     int result = get_node (current_node)->prev;
1538
1539     if (current_node == start_node)
1540     {
1541         return false;
1542     }
1543
1544     if (result < 0)
1545     {
1546         return false;
1547     }
1548     else
1549     {
1550         clear_marks_display ();
1551
1552         current_node = result;
1553
1554         /* go backwards to the next important node (move/add
1555            stone/variation/etc.) */
1556         goto_next_important_node (false);
1557         return true;
1558     }
1559 }
1560
1561 static bool
1562 advance_node (void)
1563 {
1564     int result = get_node (current_node)->next;
1565
1566     if (result < 0)
1567     {
1568         return false;
1569     }
1570     else
1571     {
1572         clear_marks_display ();
1573
1574         current_node = result;
1575
1576         /* go forward to the next move/add stone/variation/etc. node */
1577         goto_next_important_node (true);
1578         result = get_prop_sgf (current_node, PROP_VARIATION_CHOICE, NULL);
1579
1580         if (result >= 0)
1581         {
1582             go_to_variation_sgf (get_prop (result)->data.number);
1583         }
1584
1585         return true;
1586     }
1587 }
1588
1589 int
1590 num_variations_sgf (void)
1591 {
1592     int result = 1;
1593     struct prop_t *temp_prop;
1594     struct node_t *temp_node = get_node (current_node);
1595
1596     if (temp_node == 0)
1597     {
1598         return 0;
1599     }
1600
1601     if (temp_node->prev >= 0)
1602     {
1603         temp_node = get_node (get_node (temp_node->prev)->next);
1604     }
1605
1606     temp_prop = get_prop (temp_node->props);
1607
1608     while (temp_prop)
1609     {
1610         if (temp_prop->type == PROP_VARIATION)
1611         {
1612             ++result;
1613         }
1614         else
1615         {
1616             /* variations are at the beginning of the prop list */
1617             break;
1618         }
1619
1620         temp_prop = get_prop (temp_prop->next);
1621     }
1622
1623     return result;
1624 }
1625
1626 bool
1627 go_to_variation_sgf (unsigned int num)
1628 {
1629     int saved = current_node;
1630     struct node_t *temp_node = get_node (current_node);
1631     struct prop_t *temp_prop;
1632
1633     if (!temp_node)
1634     {
1635         return false;
1636     }
1637
1638     temp_node = get_node (temp_node->prev);
1639
1640     if (!temp_node)
1641     {
1642         return false;
1643     }
1644
1645     temp_node = get_node (current_node = temp_node->next);
1646
1647     if (!temp_node)
1648     {
1649         current_node = saved;
1650         return false;
1651     }
1652
1653     temp_prop = get_prop (temp_node->props);
1654
1655     while (num)
1656     {
1657         if (!temp_prop || temp_prop->type != PROP_VARIATION)
1658         {
1659             current_node = saved;
1660             return false;
1661         }
1662
1663         if (num == 1)
1664         {
1665             current_node = temp_prop->data.node;
1666             break;
1667         }
1668
1669         temp_prop = get_prop (temp_prop->next);
1670         --num;
1671     }
1672
1673     return true;
1674 }
1675
1676 int
1677 get_matching_child_sgf (unsigned short pos, unsigned char color)
1678 {
1679     struct node_t *temp_node;
1680     struct prop_t *temp_prop;
1681     int variation_count = 0;
1682     int saved;
1683
1684     /* set true later in a loop if we want a prop in the first variation
1685        which means that we shouldn't check that branch for children */
1686     bool dont_check_first_var_children = false;
1687
1688     temp_node = get_node (current_node);
1689
1690     if (!temp_node)
1691     {
1692         return -3;
1693     }
1694
1695     temp_node = get_node (temp_node->next);
1696
1697     if (!temp_node)
1698     {
1699         return -2;
1700     }
1701
1702     temp_prop = get_prop (temp_node->props);
1703
1704     while (temp_prop)
1705     {
1706         if (temp_prop->type == PROP_VARIATION)
1707         {
1708             ++variation_count;
1709             saved = current_node;
1710             current_node = temp_prop->data.node;
1711
1712             struct prop_t *temp_move = get_prop (get_move_sgf ());
1713
1714             current_node = saved;
1715
1716             if (temp_move &&
1717                 temp_move->data.position == pos &&
1718                 ((color == BLACK && temp_move->type == PROP_BLACK_MOVE) ||
1719                  (color == WHITE && temp_move->type == PROP_WHITE_MOVE)))
1720             {
1721                 return variation_count;
1722             }
1723         }
1724         else if ((temp_prop->type == PROP_BLACK_MOVE && color == BLACK) ||
1725                  (temp_prop->type == PROP_WHITE_MOVE && color == WHITE))
1726         {
1727             if (temp_prop->data.position == pos)
1728             {
1729                 return 0;
1730             }
1731             else
1732             {
1733                 return -4;
1734             }
1735         }
1736         else if (temp_prop->type == PROP_ADD_WHITE ||
1737                  temp_prop->type == PROP_ADD_BLACK ||
1738                  temp_prop->type == PROP_ADD_EMPTY)
1739         {
1740             dont_check_first_var_children = true;
1741         }
1742
1743         temp_prop = get_prop (temp_prop->next);
1744     }
1745
1746     if (dont_check_first_var_children)
1747     {
1748         return -1;
1749     }
1750     else
1751     {
1752         saved = current_node;
1753         current_node = temp_node->next;
1754
1755         struct prop_t *temp_move = get_prop (get_move_sgf ());
1756         if (temp_move &&
1757             pos == temp_move->data.position &&
1758             color == (temp_move->type == PROP_BLACK_MOVE ? BLACK : WHITE))
1759         {
1760             current_node = saved;
1761             return 0;
1762         }
1763
1764         current_node = saved;
1765         return -1;
1766     }
1767 }
1768
1769 int
1770 next_variation_sgf (void)
1771 {
1772     int saved = current_node;
1773     int saved_start = start_node;
1774     union prop_data_t temp_data;
1775     int prop_handle;
1776     int num_vars = 0;
1777
1778     if (current_node < 0 || get_node (current_node)->prev < 0)
1779     {
1780         return -1;
1781     }
1782
1783     start_node = NO_NODE;
1784
1785
1786
1787     if (num_variations_sgf () < 2)
1788     {
1789
1790         current_node = saved;
1791         start_node = saved_start;
1792         return -2;
1793     }
1794
1795     /* now we're at a branch node which we should go to the next variation
1796        (we were at the "chosen" one, so go to the next one after that,
1797        (mod the number of variations)) */
1798
1799     int chosen = 0;
1800     int branch_node = get_node (get_node (current_node)->prev)->next;
1801
1802     prop_handle = get_prop_sgf (branch_node, PROP_VARIATION_CHOICE, NULL);
1803
1804     if (prop_handle >= 0)
1805     {
1806         chosen = get_prop (prop_handle)->data.number;
1807     }
1808
1809     ++chosen;
1810
1811     if (chosen >= (num_vars = num_variations_sgf ()))
1812     {
1813         chosen = 0;
1814     }
1815
1816     temp_data.number = chosen;
1817     add_or_set_prop_sgf (branch_node, PROP_VARIATION_CHOICE, temp_data);
1818
1819     if (!undo_node_sgf ())
1820     {
1821         current_node = saved;
1822         start_node = saved_start;
1823         return -3;
1824     }
1825
1826     if (redo_node_sgf ())
1827     {
1828         start_node = saved_start;
1829         return chosen + 1;
1830     }
1831     else
1832     {
1833         current_node = saved;
1834         start_node = saved_start;
1835         return -4;
1836     }
1837 }
1838
1839 int
1840 add_child_variation (int *variation_number)
1841 {
1842     struct node_t *temp_node = get_node (current_node);
1843     struct prop_t *temp_prop;
1844     int temp_prop_handle;
1845     int new_node = alloc_storage_sgf ();
1846     int new_prop = alloc_storage_sgf ();
1847     int temp_variation_number;
1848
1849     if (new_node < 0 || new_prop < 0)
1850     {
1851         if (new_node >= 0)
1852         {
1853             free_storage_sgf (new_node);
1854         }
1855         if (new_prop >= 0)
1856         {
1857             free_storage_sgf (new_prop);
1858         }
1859
1860         return NO_NODE;
1861     }
1862
1863     if (!temp_node)
1864     {
1865         free_storage_sgf (new_node);
1866         free_storage_sgf (new_prop);
1867
1868         return NO_NODE;
1869     }
1870
1871     temp_node = get_node (temp_node->next);
1872
1873     if (!temp_node)
1874     {
1875         free_storage_sgf (new_node);
1876         free_storage_sgf (new_prop);
1877
1878         return NO_NODE;
1879     }
1880
1881     get_node (new_node)->prev = current_node;
1882     get_node (new_node)->next = NO_NODE;
1883     get_node (new_node)->props = NO_PROP;
1884
1885     get_prop (new_prop)->type = PROP_VARIATION;
1886     get_prop (new_prop)->next = NO_PROP;
1887     get_prop (new_prop)->data.node = new_node;
1888
1889     temp_prop_handle = temp_node->props;
1890
1891     if (temp_prop_handle < 0)
1892     {
1893         temp_node->props = new_prop;
1894
1895         if (variation_number)
1896         {
1897             *variation_number = 1;
1898         }
1899
1900         return new_node;
1901     }
1902
1903     if (get_prop (temp_prop_handle)->type != PROP_VARIATION)
1904     {
1905         get_prop (new_prop)->next = temp_node->props;
1906         temp_node->props = new_prop;
1907
1908         if (variation_number)
1909         {
1910             *variation_number = 1;
1911         }
1912
1913         return new_node;
1914     }
1915
1916     /* the lowest it can be, since 1 isn't it */
1917     temp_variation_number = 2;
1918
1919     while (1)
1920     {
1921         temp_prop = get_prop (temp_prop_handle);
1922         if (temp_prop->next < 0 ||
1923             get_prop (temp_prop->next)->type != PROP_VARIATION)
1924         {
1925             get_prop (new_prop)->next = temp_prop->next;
1926             temp_prop->next = new_prop;
1927
1928             if (variation_number)
1929             {
1930                 *variation_number = temp_variation_number;
1931             }
1932
1933             return new_node;
1934         }
1935
1936         ++temp_variation_number;
1937         temp_prop_handle = temp_prop->next;
1938     }
1939 }
1940
1941 static bool
1942 is_important_node (int handle)
1943 {
1944     struct prop_t *temp_prop;
1945
1946     if (handle < 0)
1947     {
1948         return false;
1949     }
1950
1951     if (handle == start_node)
1952     {
1953         return true;
1954     }
1955
1956     if (get_node (handle)->prev < 0)
1957     {
1958         return true;
1959     }
1960
1961     temp_prop = get_prop (get_node (handle)->props);
1962
1963     while (temp_prop)
1964     {
1965         if (temp_prop->type == PROP_BLACK_MOVE ||
1966             temp_prop->type == PROP_WHITE_MOVE ||
1967             temp_prop->type == PROP_ADD_BLACK ||
1968             temp_prop->type == PROP_ADD_WHITE ||
1969             temp_prop->type == PROP_ADD_EMPTY ||
1970             temp_prop->type == PROP_VARIATION)
1971         {
1972             return true;
1973         }
1974
1975         temp_prop = get_prop (temp_prop->next);
1976     }
1977
1978     return false;
1979 }
1980
1981 static bool
1982 goto_next_important_node (bool forward)
1983 {
1984     int temp_node = current_node;
1985     int last_good = temp_node;
1986
1987     while (temp_node >= 0 && !is_important_node (temp_node))
1988     {
1989         last_good = temp_node;
1990
1991         temp_node = forward ? get_node (temp_node)->next :
1992             get_node (temp_node)->prev;
1993
1994     }
1995
1996     if (temp_node < 0)
1997     {
1998         current_node = last_good;
1999     }
2000     else
2001     {
2002         current_node = temp_node;
2003     }
2004
2005     if (temp_node < 0)
2006     {
2007         return false;
2008     }
2009     else
2010     {
2011         return true;
2012     }
2013 }
2014
2015 bool
2016 is_handled_sgf (enum prop_type_t type)
2017 {
2018     if (type == PROP_BLACK_MOVE ||
2019         type == PROP_WHITE_MOVE ||
2020         type == PROP_ADD_BLACK ||
2021         type == PROP_ADD_WHITE ||
2022         type == PROP_ADD_EMPTY ||
2023         type == PROP_CIRCLE || type == PROP_SQUARE || type == PROP_TRIANGLE ||
2024 #if 0
2025         /* these marks are stupid and nobody uses them.  if we could find
2026            a good way to draw them we could do them anyway, but no reason
2027            to unless it's easy */
2028         type == PROP_DIM || type == PROP_SELECTED ||
2029 #endif
2030         type == PROP_COMMENT ||
2031         type == PROP_MARK ||
2032         type == PROP_LABEL ||
2033         type == PROP_GAME ||
2034         type == PROP_FILE_FORMAT ||
2035         type == PROP_APPLICATION ||
2036         type == PROP_CHARSET ||
2037         type == PROP_SIZE ||
2038         type == PROP_KOMI ||
2039         type == PROP_BLACK_NAME ||
2040         type == PROP_WHITE_NAME ||
2041         type == PROP_BLACK_RANK ||
2042         type == PROP_WHITE_RANK ||
2043         type == PROP_BLACK_TEAM ||
2044         type == PROP_WHITE_TEAM ||
2045         type == PROP_DATE ||
2046         type == PROP_ROUND ||
2047         type == PROP_EVENT ||
2048         type == PROP_PLACE ||
2049         type == PROP_OVERTIME ||
2050         type == PROP_RESULT ||
2051         type == PROP_TIME_LIMIT ||
2052         type == PROP_RULESET ||
2053         type == PROP_HANDICAP || type == PROP_VARIATION_TYPE)
2054     {
2055         return true;
2056     }
2057
2058     return false;
2059 }
2060
2061 void
2062 setup_handicap_sgf (void)
2063 {
2064     union prop_data_t temp_data;
2065
2066     if (header.handicap <= 1)
2067     {
2068         return;
2069     }
2070
2071     current_node = start_node;
2072
2073     temp_data.number = header.handicap;
2074     add_prop_sgf (current_node, PROP_HANDICAP, temp_data);
2075
2076     /* now, add the actual stones */
2077
2078     if ((board_width != 19 && board_width != 13 && board_width != 9) ||
2079         board_width != board_height || header.handicap > 9)
2080     {
2081         rb->splashf (5 * HZ,
2082                      "Use the 'Add Black' tool to add %d handicap stones!",
2083                      header.handicap);
2084         return;
2085     }
2086
2087     int handicaps_to_place = header.handicap;
2088
2089     int low_coord = 0, mid_coord = 0, high_coord = 0;
2090
2091     if (board_width == 19)
2092     {
2093         low_coord = 3;
2094         mid_coord = 9;
2095         high_coord = 15;
2096     }
2097     else if (board_width == 13)
2098     {
2099         low_coord = 3;
2100         mid_coord = 6;
2101         high_coord = 9;
2102     }
2103     else if (board_width == 9)
2104     {
2105         low_coord = 2;
2106         mid_coord = 4;
2107         high_coord = 6;
2108     }
2109
2110     /* first four go in the corners */
2111     handicaps_to_place -= 2;
2112     setup_handicap_helper (POS (high_coord, low_coord));
2113     setup_handicap_helper (POS (low_coord, high_coord));
2114
2115     if (!handicaps_to_place)
2116     {
2117         goto done_adding_stones;
2118     }
2119
2120     --handicaps_to_place;
2121     setup_handicap_helper (POS (high_coord, high_coord));
2122
2123     if (!handicaps_to_place)
2124     {
2125         goto done_adding_stones;
2126     }
2127
2128     --handicaps_to_place;
2129     setup_handicap_helper (POS (low_coord, low_coord));
2130
2131     if (!handicaps_to_place)
2132     {
2133         goto done_adding_stones;
2134     }
2135
2136     /* now done with first four, if only one left it goes in the center */
2137     if (handicaps_to_place == 1)
2138     {
2139         --handicaps_to_place;
2140         setup_handicap_helper (POS (mid_coord, mid_coord));
2141     }
2142     else
2143     {
2144         handicaps_to_place -= 2;
2145         setup_handicap_helper (POS (high_coord, mid_coord));
2146         setup_handicap_helper (POS (low_coord, mid_coord));
2147     }
2148
2149     if (!handicaps_to_place)
2150     {
2151         goto done_adding_stones;
2152     }
2153
2154     /* done with first 6 */
2155
2156     if (handicaps_to_place == 1)
2157     {
2158         --handicaps_to_place;
2159         setup_handicap_helper (POS (mid_coord, mid_coord));
2160     }
2161     else
2162     {
2163         handicaps_to_place -= 2;
2164         setup_handicap_helper (POS (mid_coord, high_coord));
2165         setup_handicap_helper (POS (mid_coord, low_coord));
2166     }
2167
2168     if (!handicaps_to_place)
2169     {
2170         goto done_adding_stones;
2171     }
2172
2173     /* done with first eight, there can only be the tengen remaining */
2174
2175     setup_handicap_helper (POS (mid_coord, mid_coord));
2176
2177   done_adding_stones:
2178     goto_handicap_start_sgf ();
2179     return;
2180 }
2181
2182 static void
2183 setup_handicap_helper (unsigned short pos)
2184 {
2185     union prop_data_t temp_data;
2186
2187     temp_data.position = pos;
2188
2189     add_prop_sgf (current_node, PROP_ADD_BLACK, temp_data);
2190 }
2191
2192 void
2193 goto_handicap_start_sgf (void)
2194 {
2195     if (start_node != tree_head)
2196     {
2197         current_node = get_node (start_node)->prev;
2198         redo_node_sgf ();
2199     }
2200 }
2201
2202 bool
2203 post_game_setup_sgf (void)
2204 {
2205     int temp_handle = alloc_storage_sgf ();
2206     int saved = current_node;
2207
2208     if (temp_handle < 0)
2209     {
2210         return false;
2211     }
2212
2213     union prop_data_t temp_data;
2214     temp_data.number = 0;       /* meaningless */
2215
2216     if (!header_marked)
2217     {
2218         add_prop_sgf (tree_head, PROP_ROOT_PROPS, temp_data);
2219         header_marked = true;
2220     }
2221
2222     get_node (temp_handle)->next = current_node;
2223     get_node (temp_handle)->prev = NO_NODE;
2224     get_node (temp_handle)->props = NO_PROP;
2225
2226     current_node = temp_handle;
2227
2228     redo_node_sgf ();
2229
2230     if (current_node == temp_handle)
2231     {
2232         current_node = saved;
2233     }
2234
2235     free_storage_sgf (temp_handle);
2236
2237     return true;
2238 }