init.c

   1 /*
   2  * FILE: init.c
   3  *
   4  * ----------------------------------------------------------------------
   5  * Copyright (c) 1993, 1994, 1995 Matthias Mutz
   6  * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
   7  *
   8  * GNU SHOGI is based on GNU CHESS
   9  *
  10  * Copyright (c) 1988, 1989, 1990 John Stanback
  11  * Copyright (c) 1992 Free Software Foundation
  12  *
  13  * This file is part of GNU SHOGI.
  14  *
  15  * GNU Shogi is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License as published by the
  17  * Free Software Foundation; either version 3 of the License,
  18  * or (at your option) any later version.
  19  *
  20  * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
  21  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  22  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  23  * for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License along
  26  * with GNU Shogi; see the file COPYING. If not, see
  27  * <http://www.gnu.org/licenses/>.
  28  * ----------------------------------------------------------------------
  29  *
  30  */
  31
  32 #include "gnushogi.h"
  33
  34 #if defined HAVE_GETTIMEOFDAY
  35 #include <sys/time.h>
  36 #endif
  37
  38 #include <signal.h>
  39
  40 #include "pattern.h"
  41
  42 /****************************************
  43  *     A variety of global flags.
  44  ****************************************/
  45
  46 /*
  47  * If hard_time_limit is nonzero, exceeding the time limit means
  48  * losing the game.
  49  */
  50
  51 short hard_time_limit = 1;
  52 short barebones       = 0;  /* Suppress printing of statistics
  53                              * (mainly for xshogi). */
  54 #ifdef LIST_ON_EXIT
  55 short nolist          = 0;  /* List the game after exit. */
  56 #else
  57 short nolist          = 1;  /* Don't list the game after exit. */
  58 #endif
  59
  60 /*
  61  * The default display type can be DISPLAY_RAW, DISPLAY_CURSES,
  62  * or DISPLAY_X; the default is DISPLAY_X to make life easier for xshogi.
  63  */
  64
  65 display_t display_type = DISPLAY_X;
  66
  67 unsigned int ttbllimit;
  68
  69 /* .... MOVE GENERATION VARIABLES AND INITIALIZATIONS .... */
  70
  71
  72 #define max(a, b) (((a) < (b))?(b):(a))
  73 #define odd(a) ((a) & 1)
  74
  75
  76 const small_short piece_of_ptype[NO_PTYPE_PIECES] =
  77 {
  78     pawn, lance, knight, silver, gold, bishop, rook, pbishop, prook, king,
  79     pawn, lance, knight, silver, gold
  80 };
  81
  82
  83 const small_short side_of_ptype[NO_PTYPE_PIECES] =
  84 {
  85     black, black, black, black, black, black, black, black, black, black,
  86     white, white, white, white, white
  87 };
  88
  89 #ifdef SAVE_NEXTPOS
  90 const small_short psweep[NO_PTYPE_PIECES] =
  91 {
  92     false, true, false, false, false, true, true, true, true, false,
  93     false, true, false, false, false
  94 };
  95 #endif
  96
  97 const small_short sweep[NO_PIECES] =
  98 {
  99     false, false, true, false, false, false, true, true,
 100     false, false, false, false, true, true, false
 101 };
 102
 103
 104 #if !defined EXTLANGFILE
 105
 106 char *CP[CPSIZE] =
 107
 108 {
 109 /* 000: eng: */ "",
 110 #ifdef LANGFILE
 111 #include LANGFILE
 112 #else
 113 #include "gnushogi.lng"
 114 #endif
 115 };
 116
 117 #else
 118
 119 char *CP[CPSIZE];
 120
 121 #endif
 122
 123
 124 /*
 125  * Determine the minimum number of moves for a piece from
 126  * square "f" to square "t". If the piece cannot reach "t",
 127  * the count is set to CANNOT_REACH.
 128  */
 129
 130 #define csquare(sq) ((side == black) ? sq : (NO_SQUARES - 1 - sq))
 131 #define crow(sq) row(csquare(sq))
 132 #define ccol(sq) column(csquare(sq))
 133
 134 short
 135 ptype_distance(short ptyp, short f, short t)
 136 {
 137     short side, piece;
 138     short colf, colt, rowf, rowt, dcol, drow;
 139
 140     if (f == t)
 141         return 0;
 142
 143     piece = piece_of_ptype[ptyp];
 144     side  = side_of_ptype[ptyp];
 145
 146     dcol = (colt = ccol(t)) - (colf = ccol(f));
 147     drow = (rowt = crow(t)) - (rowf = crow(f));
 148
 149     switch (piece)
 150     {
 151     case pawn:
 152         if ((dcol != 0) || (drow < 1))
 153             return CANNOT_REACH;
 154         else
 155             return drow;
 156
 157     case lance:
 158         if ((dcol != 0) || (drow < 1))
 159             return CANNOT_REACH;
 160         else
 161             return 1;
 162
 163     case knight:
 164         if (odd(drow) || (odd(drow / 2) != odd(dcol)))
 165             return CANNOT_REACH;
 166         else if ((drow == 0) || ((drow / 2) < abs(dcol)))
 167             return CANNOT_REACH;
 168         else
 169             return (drow / 2);
 170
 171     case silver:
 172         if (drow > 0)
 173         {
 174             if (odd(drow) == odd(dcol))
 175             {
 176                 return max(abs(drow), abs(dcol));
 177             }
 178             else
 179             {
 180                 if (abs(dcol) <= drow)
 181                     return drow;
 182                 else
 183                     return (max(abs(drow), abs(dcol)) + 1);
 184             }
 185         }
 186         else
 187         {
 188             if (odd(drow) == odd(dcol))
 189                 return (max(abs(drow), abs(dcol)));
 190             else
 191                 return (max(abs(drow) + 1, abs(dcol)) + 1);
 192         };
 193
 194     case gold:
 195     case ppawn:
 196     case pknight:
 197     case plance:
 198     case psilver:
 199         if (abs(dcol) == 0)
 200             return (abs(drow));
 201         else if (drow >= 0)
 202             return max(drow, abs(dcol));
 203         else
 204             return (abs(dcol) - drow);
 205
 206     case bishop:
 207         if (odd(dcol) != odd(drow))
 208             return CANNOT_REACH;
 209         else
 210             return ((abs(dcol) == abs(drow)) ? 1 : 2);
 211
 212     case pbishop:
 213         if (odd(dcol) != odd(drow))
 214         {
 215             if ((abs(dcol) <= 1) && (abs(drow) <= 1))
 216                 return 1;
 217             else if (abs(abs(dcol) - abs(drow)) == 1)
 218                 return 2;
 219             else
 220                 return 3;
 221         }
 222         else
 223         {
 224             return ((abs(dcol) == abs(drow)) ? 1 : 2);
 225         }
 226
 227     case rook:
 228         if ((dcol == 0) || (drow == 0))
 229             return 1;
 230         else
 231             return 2;
 232
 233     case prook:
 234         if ((dcol == 0) || (drow == 0))
 235             return 1;
 236         else if ((abs(dcol) == 1) && (abs(drow) == 1))
 237             return 1;
 238         else
 239             return 2;
 240
 241     case king:
 242         return max(abs(drow), abs(dcol));
 243
 244     default:
 245         /* should never occur */
 246         return (CANNOT_REACH);
 247     }
 248 }
 249
 250
 251 #ifdef SAVE_DISTDATA
 252 short
 253 distance(short a, short b)
 254 {
 255     return (short)computed_distance(a, b);
 256 }
 257 #else
 258 short
 259 distance(short a, short b)
 260 {
 261     return (use_distdata
 262             ? (short)(*distdata)[(int)a][(int)b]
 263             : (short)computed_distance(a, b));
 264 }
 265 #endif
 266
 267
 268 #ifdef SAVE_PTYPE_DISTDATA
 269 short
 270 piece_distance(short side, short piece, short f, short t)
 271 {
 272     return ((f > NO_SQUARES)
 273             ? (short)1
 274             : (short)ptype_distance(ptype[side][piece], f, t));
 275 }
 276 #else
 277 short
 278 piece_distance(short side, short piece, short f, short t)
 279 {
 280     return ((f > NO_SQUARES)
 281             ? (short)1
 282             : (use_ptype_distdata
 283                ? (short)(*ptype_distdata[ptype[side][piece]])[f][t]
 284                : (short)ptype_distance(ptype[side][piece], f, t)));
 285 }
 286 #endif
 287
 288
 289 void
 290 Initialize_dist(void)
 291 {
 292     short a, b, d, di, ptyp;
 293 #ifndef SAVE_DISTDATA
 294     for (a = 0; a < NO_SQUARES; a++)
 295     {
 296         for (b = 0; b < NO_SQUARES; b++)
 297         {
 298             d = abs(column(a) - column(b));
 299             di = abs(row(a) - row(b));
 300             (*distdata)[a][b] = (small_short)((d > di) ? d : di);
 301         }
 302     }
 303 #endif
 304 #ifndef SAVE_PTYPE_DISTDATA
 305     for (ptyp = 0; ptyp < NO_PTYPE_PIECES; ptyp++)
 306     {
 307         for (a = 0; a < NO_SQUARES; a++)
 308             for (b = 0; b < NO_SQUARES; b++)
 309                 (*ptype_distdata[ptyp])[a][b] = ptype_distance(ptyp, a, b);
 310     }
 311 #endif
 312 }
 313
 314
 315 /*
 316  * nextpos[ptype][from-square], nextdir[ptype][from-square] gives vector
 317  * of positions reachable from from-square in ppos with ptype such that the
 318  * sequence
 319  *
 320  *     ppos = nextpos[ptype][from-square];
 321  *     pdir = nextdir[ptype][from-square];
 322  *     u = ppos[sq];
 323  *
 324  *     do
 325  *     {
 326  *         u = ppos[u];
 327  *
 328  *         if(color[u] != neutral)
 329  *             u = pdir[u];
 330  *     }
 331  *     while (sq != u);
 332  *
 333  * will generate the sequence of all squares reachable from sq.
 334  *
 335  * If the path is blocked u = pdir[sq] will generate the continuation of the
 336  * sequence in other directions.
 337  */
 338
 339
 340 /*
 341  * ptype is used to separate black and white pawns, like this; ptyp =
 342  * ptype[side][piece] piece can be used directly in nextpos/nextdir when
 343  * generating moves for pieces that are not white pawns.
 344  */
 345
 346 const small_short ptype[2][NO_PIECES] =
 347 {
 348     {
 349         ptype_no_piece, ptype_pawn,  ptype_lance,  ptype_knight,
 350         ptype_silver,   ptype_gold,  ptype_bishop, ptype_rook,
 351         ptype_gold,     ptype_gold,  ptype_gold,   ptype_gold,
 352         ptype_pbishop,  ptype_prook, ptype_king
 353     },
 354     {
 355         ptype_no_piece, ptype_wpawn, ptype_wlance, ptype_wknight,
 356         ptype_wsilver,  ptype_wgold, ptype_bishop, ptype_rook,
 357         ptype_wgold,    ptype_wgold, ptype_wgold,  ptype_wgold,
 358         ptype_pbishop,  ptype_prook, ptype_king
 359     },
 360 };
 361
 362 const small_short promoted[NO_PIECES] =
 363 {
 364     no_piece, ppawn, plance, pknight, psilver, gold, pbishop, prook,
 365     ppawn, plance, pknight, psilver, pbishop, prook, king
 366 };
 367
 368 const small_short unpromoted[NO_PIECES] =
 369 {
 370     no_piece, pawn, lance, knight, silver, gold, bishop, rook,
 371     pawn, lance, knight, silver, bishop, rook, king
 372 };
 373
 374 const small_short is_promoted[NO_PIECES] =
 375 {
 376     false, false, false, false, false, false, false, false,
 377     true, true, true, true, true, true, false
 378 };
 379
 380 /* data used to generate nextpos/nextdir */
 381 #if !defined SAVE_NEXTPOS
 382 static
 383 #endif
 384 const small_short direc[NO_PTYPE_PIECES][8] =
 385 {
 386     {  11,   0,   0,   0,   0,   0,   0,   0 },   /*  0 ptype_pawn    */
 387     {  11,   0,   0,   0,   0,   0,   0,   0 },   /*  1 ptype_lance   */
 388     {  21,  23,   0,   0,   0,   0,   0,   0 },   /*  2 ptype_knight  */
 389     {  10,  11,  12, -12, -10,   0,   0,   0 },   /*  3 ptype_silver  */
 390     {  10,  11,  12,  -1,   1, -11,   0,   0 },   /*  4 ptype_gold    */
 391     {  10,  12, -12, -10,   0,   0,   0,   0 },   /*  5 ptype_bishop  */
 392     {  11,  -1,   1, -11,   0,   0,   0,   0 },   /*  6 ptype_rook    */
 393     {  10,  12, -12, -10,  11,  -1,   1, -11 },   /*  7 ptype_pbishop */
 394     {  11,  -1,   1, -11,  10,  12, -12, -10 },   /*  8 ptype_prook   */
 395     {  10,  11,  12,  -1,   1, -12, -11, -10 },   /*  9 ptype_king    */
 396     { -11,   0,   0,   0,   0,   0,   0,   0 },   /* 10 ptype_wpawn   */
 397     { -11,   0,   0,   0,   0,   0,   0,   0 },   /* 11 ptype_wlance  */
 398     { -21, -23,   0,   0,   0,   0,   0,   0 },   /* 12 ptype_wknight */
 399     { -10, -11, -12,  12,  10,   0,   0,   0 },   /* 13 ptype_wsilver */
 400     { -10, -11, -12,   1,  -1,  11,   0,   0 }
 401 };  /* 14 ptype_wgold */
 402
 403
 404 small_short diagonal(short d)
 405 {
 406   return (abs(d) == (NO_COLS+1) || abs(d) == (NO_COLS+3));
 407 }
 408
 409
 410 static const small_short max_steps[NO_PTYPE_PIECES] =
 411 {
 412     1, 8, 1, 1, 1, 8, 8, 8, 8, 1, 1, 8, 1, 1, 1
 413 };
 414
 415
 416 const small_short nunmap[(NO_COLS + 2)*(NO_ROWS + 4)] =
 417 {
 418     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 419     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 420     -1,  0,  1,  2,  3,  4,  5,  6,  7,  8, -1,
 421     -1,  9, 10, 11, 12, 13, 14, 15, 16, 17, -1,
 422     -1, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
 423     -1, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1,
 424     -1, 36, 37, 38, 39, 40, 41, 42, 43, 44, -1,
 425     -1, 45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
 426     -1, 54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
 427     -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, -1,
 428     -1, 72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
 429     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 430     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 431 };
 432
 433
 434 const small_short inunmap[NO_SQUARES] =
 435 {
 436      23,  24,  25,  26,  27,  28,  29,  30,  31,
 437      34,  35,  36,  37,  38,  39,  40,  41,  42,
 438      45,  46,  47,  48,  49,  50,  51,  52,  53,
 439      56,  57,  58,  59,  60,  61,  62,  63,  64,
 440      67,  68,  69,  70,  71,  72,  73,  74,  75,
 441      78,  79,  80,  81,  82,  83,  84,  85,  86,
 442      89,  90,  91,  92,  93,  94,  95,  96,  97,
 443     100, 101, 102, 103, 104, 105, 106, 107, 108,
 444     111, 112, 113, 114, 115, 116, 117, 118, 119
 445 };
 446
 447
 448 int InitFlag = false;
 449
 450
 451 #if defined SAVE_NEXTPOS
 452
 453 short
 454 next_direction(short ptyp, short *d, short sq)
 455 {
 456     short delta, to, sfrom = inunmap[sq];
 457
 458     do
 459     {
 460         (*d)++;
 461         if (*d >= 8)
 462             return sq;
 463
 464         delta = direc[ptyp][*d];
 465         if (delta == 0)
 466             return sq;
 467
 468         to = nunmap[sfrom + delta];
 469     }
 470     while (to < 0);
 471
 472     return to;
 473 }
 474
 475
 476 short
 477 next_position(short ptyp, short *d, short sq, short u)
 478 {
 479     if (*d < 4 && psweep[ptyp])
 480     {
 481         short to = nunmap[inunmap[u] + direc[ptyp][*d]];
 482
 483         if (to < 0)
 484             return next_direction(ptyp, d, sq);
 485         else
 486             return to;
 487     }
 488     else
 489     {
 490         return next_direction(ptyp, d, sq);
 491     }
 492 }
 493
 494
 495 short
 496 first_direction(short ptyp, short *d, short sq)
 497 {
 498     *d = -1;
 499     return next_direction(ptyp, d, sq);
 500 }
 501
 502 #else
 503
 504 /*
 505  * This procedure pre-calculates all moves for every piece from every
 506  * square.  This data is stored in nextpos/nextdir and used later in the
 507  * move generation routines.
 508  */
 509
 510 void
 511 Initialize_moves(void)
 512 {
 513     short ptyp, po, p0, d, di, s, delta;
 514     unsigned char *ppos, *pdir;
 515     short dest[8][9];
 516     short sorted[9];
 517     short steps[8];
 518     short fpo = inunmap[0], tpo = 1 + inunmap[NO_SQUARES-1];
 519
 520     /* pre-fill nextpos and nextdir with source position, probably so
 521      * (color[u] == neutral) stops to match once all moves have been seen
 522      */
 523     for (ptyp = 0; ptyp < NO_PTYPE_PIECES; ptyp++)
 524     {
 525         for (po = 0; po < NO_SQUARES; po++)
 526         {
 527             for (p0 = 0; p0 < NO_SQUARES; p0++)
 528             {
 529                 (*nextpos[ptyp])[po][p0] = (unsigned char)po;
 530                 (*nextdir[ptyp])[po][p0] = (unsigned char)po;
 531             }
 532         }
 533     }
 534
 535     for (ptyp = 0; ptyp < NO_PTYPE_PIECES; ptyp++)
 536     {
 537         for (po = fpo; po < tpo; po++)
 538         {
 539             if (nunmap[po] >= (small_short)0)
 540             {
 541                 ppos = (*nextpos[ptyp])[nunmap[po]];
 542                 pdir = (*nextdir[ptyp])[nunmap[po]];
 543
 544                 /* dest is a function of direction and steps */
 545                 for (d = 0; d < 8; d++)
 546                 {
 547                     dest[d][0] = nunmap[po];
 548                     delta = direc[ptyp][d];
 549
 550                     if (delta != 0)
 551                     {
 552                         p0 = po;
 553
 554                         for (s = 0; s < max_steps[ptyp]; s++)
 555                         {
 556                             p0 = p0 + delta;
 557
 558                             /*
 559                              * break if (off board) or (promoted rooks
 560                              * wishes to move two steps diagonal) or
 561                              * (promoted bishops wishes to move two steps
 562                              * non-diagonal)
 563                              */
 564                             if ((nunmap[p0] < (small_short)0)
 565                                 || ((ptyp == ptype_prook)
 566                                     && (s > 0)
 567                                     && diagonal(delta))
 568                                 || ((ptyp == ptype_pbishop)
 569                                     && (s > 0)
 570                                     && !diagonal(delta)))
 571                                 break;
 572                             else
 573                                 dest[d][s] = nunmap[p0];
 574                         }
 575                     }
 576                     else
 577                     {
 578                         s = 0;
 579                     }
 580
 581                     /*
 582                      * Sort dest in number of steps order; currently no sort
 583                      * is done due to compatibility with the move generation
 584                      * order in old gnuchess.
 585                      */
 586
 587                     steps[d] = s;
 588
 589                     for (di = d; s > 0 && di > 0; di--)
 590                     {
 591                         if (steps[sorted[di - 1]] == 0) /* should be: < s */
 592                             sorted[di] = sorted[di - 1];
 593                         else
 594                             break;
 595                     }
 596
 597                     sorted[di] = d;
 598                 }
 599
 600                 /*
 601                  * update nextpos/nextdir
 602                  */
 603
 604                 p0 = nunmap[po];
 605                 pdir[p0] = (unsigned char)dest[sorted[0]][0];
 606
 607                 for (d = 0; d < 8; d++)
 608                 {
 609                     for (s = 0; s < steps[sorted[d]]; s++)
 610                     {
 611                         ppos[p0] = (unsigned char)dest[sorted[d]][s];
 612                         p0 = dest[sorted[d]][s];
 613
 614                         if (d < 7)
 615                             pdir[p0] = (unsigned char)dest[sorted[d + 1]][0];
 616
 617                         /*
 618                          * else is already initialized
 619                          */
 620                     }
 621                 }
 622             }
 623         }
 624     }
 625 }
 626
 627 #endif
 628
 629
 630
 631 /*
 632  * Reset the board and other variables to start a new game.
 633  */
 634
 635 void
 636 NewGame(void)
 637 {
 638     short l, c, p, max_opening_sequence;
 639 #ifdef HAVE_GETTIMEOFDAY
 640     struct timeval tv;
 641 #endif
 642     compptr = oppptr = 0;
 643     stage = 0;
 644     stage2 = -1;    /* the game is not yet started */
 645     flag.illegal = flag.mate = flag.post = flag.quit
 646         = flag.reverse = flag.bothsides = flag.onemove = flag.force
 647         = false;
 648     flag.material = flag.coords = flag.hash = flag.easy
 649         = flag.beep = flag.rcptr
 650         = true;
 651     flag.stars  = flag.shade = flag.back = flag.musttimeout = false;
 652     flag.gamein = false;
 653     flag.rv     = true;
 654
 655     mycnt1 = mycnt2 = 0;
 656     GenCnt = NodeCnt = et0 = dither =  XCmore = 0;
 657     znodes = ZNODES;
 658     WAwindow = WAWNDW;
 659     WBwindow = WBWNDW;
 660     BAwindow = BAWNDW;
 661     BBwindow = BBWNDW;
 662     xwndw = BXWNDW;
 663
 664     if (!MaxSearchDepth)
 665         MaxSearchDepth = MAXDEPTH - 1;
 666
 667     contempt = 0;
 668     GameCnt = 0;
 669     Game50 = 1;
 670     CptrFlag[0] = TesujiFlag[0] = false;
 671     hint = OPENING_HINT;
 672     ZeroRPT();
 673     GameType[0] = GameType[1] = UNKNOWN;
 674     Pscore[0] = Tscore[0] = (SCORE_LIMIT + 3000);
 675     opponent = player = black;
 676     computer = white;
 677
 678     for (l = 0; l < TREE; l++)
 679         Tree[l].f = Tree[l].t = 0;
 680
 681     gsrand((unsigned int) 1);
 682
 683     if (!InitFlag)
 684     {
 685         for (c = black; c <= white; c++)
 686         {
 687             for (p = pawn; p <= king; p++)
 688             {
 689                 for (l = 0; l < NO_SQUARES; l++)
 690                 {
 691                     (*hashcode)[c][p][l].key
 692                          = (((unsigned long) urand()));
 693                     (*hashcode)[c][p][l].key
 694                         += (((unsigned long) urand()) << 16);
 695                     (*hashcode)[c][p][l].bd
 696                          = (((unsigned long) urand()));
 697                     (*hashcode)[c][p][l].bd
 698                         += (((unsigned long) urand()) << 16);
 699 #if SIZEOF_LONG == 8  /* 64-bit long i.e. 8 bytes */
 700                     (*hashcode)[c][p][l].key
 701                         += (((unsigned long) urand()) << 32);
 702                     (*hashcode)[c][p][l].key
 703                         += (((unsigned long) urand()) << 48);
 704                     (*hashcode)[c][p][l].bd
 705                         += (((unsigned long) urand()) << 32);
 706                     (*hashcode)[c][p][l].bd
 707                         += (((unsigned long) urand()) << 48);
 708 #endif
 709                 }
 710             }
 711         }
 712
 713         for (c = black; c <= white; c++)
 714         {
 715             for (p = pawn; p <= king; p++)
 716             {
 717                 for (l = 0; l < MAX_CAPTURED; l++)
 718                 {
 719                     (*drop_hashcode)[c][p][l].key
 720                          = (((unsigned long) urand()));
 721                     (*drop_hashcode)[c][p][l].key
 722                         += (((unsigned long) urand()) << 16);
 723                     (*drop_hashcode)[c][p][l].bd
 724                          = (((unsigned long) urand()));
 725                     (*drop_hashcode)[c][p][l].bd
 726                         += (((unsigned long) urand()) << 16);
 727 #if SIZEOF_LONG == 8  /* 64-bit long i.e. 8 bytes */
 728                     (*drop_hashcode)[c][p][l].key
 729                         += (((unsigned long) urand()) << 32);
 730                     (*drop_hashcode)[c][p][l].key
 731                         += (((unsigned long) urand()) << 48);
 732                     (*drop_hashcode)[c][p][l].bd
 733                         += (((unsigned long) urand()) << 32);
 734                     (*drop_hashcode)[c][p][l].bd
 735                         += (((unsigned long) urand()) << 48);
 736 #endif
 737                 }
 738             }
 739         }
 740     }
 741
 742     for (l = 0; l < NO_SQUARES; l++)
 743     {
 744         board[l] = Stboard[l];
 745         color[l] = Stcolor[l];
 746         Mvboard[l] = 0;
 747     }
 748
 749     ClearCaptured();
 750     ClearScreen();
 751     InitializeStats();
 752
 753 #ifdef HAVE_GETTIMEOFDAY
 754     gettimeofday(&tv, NULL);
 755     time0 = tv.tv_sec*100 + tv.tv_usec/10000;
 756 #else
 757     time0 = time((long *) 0);
 758 #endif
 759
 760     /* resetting reference time */
 761     ElapsedTime(COMPUTE_AND_INIT_MODE);
 762     flag.regularstart = true;
 763     Book = BOOKFAIL;
 764
 765     if (!InitFlag)
 766     {
 767         char sx[256];
 768         strcpy(sx, CP[169]);
 769
 770         if (TCflag)
 771             SetTimeControl();
 772         else if (MaxResponseTime == 0)
 773             SelectLevel(sx);
 774
 775         UpdateDisplay(0, 0, 1, 0);
 776         GetOpenings();
 777         GetOpeningPatterns(&max_opening_sequence);
 778
 779         InitFlag = true;
 780     }
 781
 782 #if ttblsz
 783     if (TTadd)
 784     {
 785         ZeroTTable();
 786         TTadd = 0;
 787     }
 788 #endif /* ttblsz */
 789
 790     hashbd = hashkey = 0;
 791     return;
 792 }
 793
 794
 795
 796 int
 797 Initialize_data(void)
 798 {
 799     size_t n;
 800     int i;
 801     char buffer[60];
 802     int doit = true;
 803
 804     {
 805         small_short x = -1;
 806
 807         if (x >= 0)
 808         {
 809             ShowMessage("datatype 'small_short' is unsigned; "
 810                         "check gnushogi.h\n");
 811             return 1;
 812         }
 813     }
 814
 815     n = sizeof(struct leaf) * (size_t)TREE;
 816     Tree = malloc(n);
 817
 818     if (!Tree)
 819     {
 820         sprintf(buffer, "Cannot allocate %ld bytes for search tree",
 821                 (long)n);
 822         ShowMessage(buffer);
 823         return 1;
 824     }
 825
 826     n = sizeof(hashcode_array);
 827     hashcode = malloc(n);
 828
 829     if (!hashcode)
 830     {
 831         sprintf(buffer, "Cannot allocate %ld bytes for hashcode", (long)n);
 832         ShowMessage(buffer);
 833         return 1;
 834     }
 835
 836     n = sizeof(drop_hashcode_array);
 837     drop_hashcode = malloc(n);
 838
 839     if (!drop_hashcode)
 840     {
 841         sprintf(buffer,
 842                 "Cannot allocate %ld bytes for drop_hashcode",
 843                 (long)n);
 844         ShowMessage(buffer);
 845         return 1;
 846     }
 847
 848     n = sizeof(struct GameRec) * (size_t)(MAXMOVES + MAXDEPTH);
 849     GameList = malloc(n);
 850
 851     if (!GameList)
 852     {
 853         sprintf(buffer,
 854                 "Cannot allocate %ld bytes for game record",
 855                 (long)n);
 856         ShowMessage(buffer);
 857         return 1;
 858     }
 859
 860 #if !defined SAVE_NEXTPOS
 861     n = sizeof(next_array);
 862
 863     for (i = 0; i < NO_PTYPE_PIECES; i++)
 864     {
 865         nextdir[i] = use_nextpos ? malloc(n) : NULL;
 866
 867         if (!nextdir[i])
 868         {
 869             if (use_nextpos)
 870             {
 871                 sprintf(buffer, "cannot allocate %ld space for nextdir %d",
 872                         (long)(n), i);
 873                 ShowMessage(buffer);
 874             }
 875
 876             nextdir[i] = NULL;
 877             use_nextpos = false;
 878         }
 879
 880         nextpos[i] = use_nextpos ? malloc(n) : NULL;
 881
 882         if (!nextpos[i])
 883         {
 884             if (use_nextpos)
 885             {
 886                 sprintf(buffer, "cannot allocate %ld space for nextpos %d",
 887                         (long)(n), i);
 888                 ShowMessage(buffer);
 889             }
 890
 891             use_nextpos = false;
 892         }
 893     }
 894
 895     if (!use_nextpos)
 896     {
 897         return 1;
 898     }
 899 #endif
 900
 901     n = sizeof(value_array);
 902     value = malloc(n);
 903
 904     if (!value)
 905     {
 906         ShowMessage("cannot allocate value space");
 907         return 1;
 908     }
 909
 910     n = sizeof(fscore_array);
 911     fscore = malloc(n);
 912
 913     if (!fscore)
 914     {
 915         ShowMessage("cannot allocate fscore space");
 916         return 1;
 917     }
 918
 919 #if defined HISTORY
 920     n = sizeof_history;
 921     history = malloc(n);
 922
 923     if (!history)
 924     {
 925         sprintf(buffer, "Cannot allocate %ld bytes for history table",
 926                 (long)sizeof_history);
 927         ShowMessage(buffer);
 928         use_history = false;
 929     }
 930 #endif
 931
 932 #if defined CACHE
 933     n = sizeof(struct etable) * (size_t)ETABLE;
 934
 935     for (i = 0; i < 2; i++)
 936     {
 937         etab[i] = use_etable ? malloc(n) : 0;
 938
 939         if (!etab[i])
 940         {
 941             sprintf(buffer, "Cannot allocate %ld bytes for cache table %ld",
 942                     (long)n, (long)i);
 943             ShowMessage(buffer);
 944             use_etable = false;
 945         }
 946     }
 947 #endif
 948
 949 #if ttblsz
 950
 951     if (rehash < 0)
 952         rehash = MAXrehash;
 953
 954     n = sizeof(struct hashentry)*(ttblsize + rehash);
 955
 956     while (doit && ttblsize > MINTTABLE)
 957     {
 958         ttable[0] = malloc(n);  /* FIXME: cast to the correct type. */
 959         ttable[1] = ttable[0] ? malloc(n) : NULL;
 960
 961         if (!ttable[0] || !ttable[1])
 962         {
 963             if (!ttable[0])
 964                 free(ttable[0]);
 965
 966             if (!ttable[1])
 967                 free(ttable[1]);
 968
 969             ttblsize = ttblsize >> 1;
 970             n = sizeof(struct hashentry) * (ttblsize + rehash);
 971         }
 972         else
 973         {
 974             doit = false;
 975         }
 976     }
 977
 978     if (ttblsize <= MINTTABLE)
 979     {
 980         use_ttable = false;
 981     }
 982
 983     if (use_ttable)
 984     {
 985         /* CHECKME: is the precedence here correct? */
 986         /* ttbllimit = ttblsize << 1 - ttblsize >> 2; */
 987         ttbllimit = (ttblsize << 1) - (ttblsize >> 2);
 988     }
 989     else
 990     {
 991         sprintf(buffer, "Cannot allocate %ld bytes for transposition table",
 992                 (long)(2 * n));
 993         ShowMessage(buffer);
 994         ttable[0] = ttable[1] = NULL;
 995     }
 996 #endif /* ttblsz */
 997
 998 #if !defined SAVE_DISTDATA
 999     n = sizeof(distdata_array);
1000     distdata = malloc(n);
1001
1002     if (!distdata)
1003     {
1004         ShowMessage("cannot allocate distdata space...");
1005         use_distdata = false;
1006     }
1007 #endif
1008
1009 #if !defined SAVE_PTYPE_DISTDATA
1010     n = sizeof(distdata_array);
1011
1012     for (i = 0; i < NO_PTYPE_PIECES; i++)
1013     {
1014         ptype_distdata[i] = use_ptype_distdata ? malloc(n) : 0;
1015
1016         if (!ptype_distdata[i])
1017         {
1018             sprintf(buffer,
1019                     "cannot allocate %ld bytes for ptype_distdata %d...",
1020                     (long)n, i);
1021             use_ptype_distdata = false;
1022         }
1023     }
1024 #endif
1025
1026     return 0;
1027 }
1028
1029
1030 #if defined EXTLANGFILE
1031
1032 #ifdef OLDLANGFILE
1033
1034 void
1035 InitConst(char *lang)
1036 {
1037     FILE *constfile;
1038     char s[256];
1039     char sl[5];
1040     char buffer[120];
1041     int len, entry;
1042     char *p, *q;
1043     constfile = fopen(LANGFILE, "r");
1044
1045     if (!constfile)
1046     {
1047         ShowMessage("NO LANGFILE");
1048         exit(1);
1049     }
1050
1051     while (fgets(s, sizeof(s), constfile))
1052     {
1053         if (s[0] == '!')
1054             continue;
1055
1056         len = strlen(s);
1057
1058         for (q = &s[len]; q > &s[8]; q--)
1059             if (*q == '}')
1060                 break;
1061
1062         if (q == &s[8])
1063         {
1064             ShowMessage("{ error in cinstfile");
1065             exit(1);
1066         }
1067
1068         *q = '\0';
1069
1070         if ((s[3] != ':') || (s[7] != ':') || (s[8] != '{'))
1071         {
1072             sprintf(buffer, "Langfile format error %s", s);
1073             ShowMessage(buffer);
1074             exit(1);
1075         }
1076
1077         s[3] = s[7] = '\0';
1078
1079         if (lang == NULL)
1080         {
1081             lang = sl;
1082             strcpy(sl, &s[4]);
1083         }
1084
1085         if (strcmp(&s[4], lang))
1086             continue;
1087
1088         entry = atoi(s);
1089
1090         if ((entry < 0) || (entry >= CPSIZE))
1091         {
1092             ShowMessage("Langfile number error");
1093             exit(1);
1094         }
1095
1096         for (q = p = &s[9]; *p; p++)
1097         {
1098             if (*p != '\\')
1099             {
1100                 *q++ = *p;
1101             }
1102             else if (*(p + 1) == 'n')
1103             {
1104                 *q++ = '\n';
1105                 p++;
1106             }
1107         }
1108
1109         *q = '\0';
1110
1111         if ((entry < 0) || (entry > 255))
1112         {
1113             sprintf(buffer, "Langfile error %d\n", entry);
1114             ShowMessage(buffer);
1115             exit(0);
1116         }
1117
1118         CP[entry] = (char *)GLOBAL_ALLOC((unsigned) strlen(&s[9]) + 1);
1119
1120         if (CP[entry] == NULL)
1121         {
1122             char buffer[80];
1123             sprintf(buffer, "CP MALLOC, entry %d", entry);
1124             perror(buffer);
1125             exit(0);
1126         }
1127
1128         strcpy(CP[entry], &s[9]);
1129     }
1130
1131     fclose(constfile);
1132 }
1133
1134 #else
1135
1136 void
1137 InitConst(char *lang)
1138 {
1139     FILE *constfile;
1140     char s[256];
1141     char sl[5];
1142     char buffer[120];
1143     int len, entry;
1144     char *p, *q;
1145     constfile = fopen(LANGFILE, "r");
1146
1147     if (!constfile)
1148     {
1149         ShowMessage("NO LANGFILE");
1150         exit(1);
1151     }
1152
1153     while (fgets(s, sizeof(s), constfile))
1154     {
1155         if (s[0] == '!')
1156             continue;
1157
1158         len = strlen(s);
1159
1160         if ((len > 3) && (s[3] == ':') || (len > 7) && (s[7] == ':'))
1161         {
1162             ShowMessage("old Langfile error");
1163             exit(1);
1164         }
1165
1166         if (len <= 15)
1167         {
1168             ShowMessage("length error in Langfile");
1169             exit(1);
1170         }
1171
1172         for (q = &s[len]; q > &s[15]; q--)
1173         {
1174             if (*q == '"')
1175                 break;
1176         }
1177
1178         if (q == &s[15])
1179         {
1180             ShowMessage("\" error in Langfile");
1181             exit(1);
1182         }
1183
1184         *q = '\0';
1185
1186         if ((s[6] != ':') || (s[10] != ':') || (s[15] != '"'))
1187         {
1188             sprintf(buffer, "Langfile format error %s", s);
1189             ShowMessage(buffer);
1190             exit(1);
1191         }
1192
1193         s[6] = s[10] = '\0';
1194
1195         if (lang == NULL)
1196         {
1197             lang = sl;
1198             strcpy(sl, &s[7]);
1199         }
1200
1201         if (strcmp(&s[7], lang))
1202             continue;
1203
1204         entry = atoi(&s[3]);
1205
1206         if ((entry < 0) || (entry >= CPSIZE))
1207         {
1208             ShowMessage("Langfile number error");
1209             exit(1);
1210         }
1211
1212         for (q = p = &s[16]; *p; p++)
1213         {
1214             if (*p != '\\')
1215             {
1216                 *q++ = *p;
1217             }
1218             else if (*(p + 1) == 'n')
1219             {
1220                 *q++ = '\n';
1221                 p++;
1222             }
1223         }
1224
1225         *q = '\0';
1226
1227         if ((entry < 0) || (entry > 255))
1228         {
1229             sprintf(buffer, "Langfile error %d\n", entry);
1230             ShowMessage(buffer);
1231             exit(0);
1232         }
1233
1234         CP[entry] = (char *)GLOBAL_ALLOC((unsigned)strlen(&s[16]) + 1);
1235
1236         if (CP[entry] == NULL)
1237         {
1238             char buffer[80];
1239             sprintf(buffer, "CP MALLOC, entry %d", entry);
1240             perror(buffer);
1241             exit(0);
1242         }
1243
1244         strcpy(CP[entry], &s[16]);
1245     }
1246
1247     fclose(constfile);
1248 }
1249
1250 #endif
1251
1252 #endif
1253
1254
1255 int
1256 InitMain(void)
1257 {
1258     gsrand(starttime = ((unsigned int)time((long *)0)));    /* init urand */
1259
1260 #if ttblsz
1261     ttblsize = ttblsz;
1262     rehash = -1;
1263 #endif /* ttblsz */
1264
1265     if (Initialize_data() != 0)
1266         return 1;
1267
1268 #if defined EXTLANGFILE
1269     InitConst(Lang);
1270 #endif
1271
1272     strcpy(ColorStr[0], CP[118]);
1273     strcpy(ColorStr[1], CP[119]);
1274
1275     XC = 0;
1276     MaxResponseTime = 0;
1277
1278     if (XSHOGI)
1279     {
1280         signal(SIGUSR1, TerminateSearch);
1281
1282         TCmoves      = 40;
1283         TCminutes    = 5;
1284         TCseconds    = 0;
1285         TCadd        = 0;
1286
1287         TCflag       = true;
1288         OperatorTime = 0;
1289         barebones    = 1;
1290     }
1291     else
1292     {
1293         TCflag       = false;
1294         OperatorTime = 0;
1295         barebones    = 0;
1296     }
1297
1298     Initialize();
1299     Initialize_dist();
1300     Initialize_eval();
1301 #if !defined SAVE_NEXTPOS
1302     Initialize_moves();
1303 #endif
1304
1305     NewGame();
1306
1307     flag.easy = ahead;
1308     flag.hash = hash;
1309
1310     if (xwin)
1311         xwndw = atoi(xwin);
1312
1313 #ifdef HASHFILE
1314     hashfile = NULL;
1315 #endif
1316
1317 #if ttblsz
1318 #ifdef HASHFILE
1319     hashfile = fopen(HASHFILE, RWA_ACC);
1320
1321     if (hashfile)
1322     {
1323         fseek(hashfile, 0L, SEEK_END);
1324         filesz = ftell(hashfile) / sizeof(struct fileentry) - 1 - MAXrehash;
1325         hashmask = filesz >> 1;
1326         hashbase = hashmask + 1;
1327     }
1328 #endif /* HASHFILE */
1329 #endif /* ttblsz */
1330
1331     savefile[0] = '\0';
1332     listfile[0] = '\0';
1333
1334     return 0;
1335 }
1336
1337
1338 void
1339 ExitMain(void)
1340 {
1341 #if ttblsz
1342 #ifdef HASHFILE
1343     if (hashfile)
1344         fclose(hashfile);
1345 #endif /* HASHFILE */
1346 #endif /* ttblsz */
1347
1348     ExitShogi();
1349 }
1350