Use gcore for creating core dump on segfault
[capablanca.git] / lasker-2.2.3 / src / algcheck.c
1 /*
2    Copyright (c) 1993 Richard V. Nash.
3    Copyright (c) 2000 Dan Papasian
4    Copyright (C) Andrew Tridgell 2002
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21
22 #include "includes.h"
23
24 /* Well, lets see if I can list the possibilities
25  * Piece moves
26  * Ne4
27  * Nxe4
28  * Nce4
29  * Ncxe4
30  * R2f3
31  * R2xf3
32  * Special pawn moves
33  * e4
34  * ed
35  * exd
36  * exd5
37  * ed5
38  * Drop moves (bughouse, board edit)
39  * P@f7 P*f7
40  * #f7 #Nf7
41  * (o-o, o-o-o) Castling is handled earlier, so don't worry about that
42  * Of course any of these can have a + or ++ or = string on the end, just
43  * cut that off.
44  */
45
46 /* f - file
47  * r - rank
48  * p - piece
49  * x - x
50  * @ - drop character (bughouse)
51  */
52 static char *alg_list[] = {
53   "fxfr", "pxfr",               /* These two get confused in case of bishop */
54   "ffr", "pfr",                 /* These two get confused in case of bishop */
55   "pffr",
56   "pfxfr",
57   "prfr",
58   "prxfr",
59   "fr",
60   "ff",
61   "fxf",
62   "p@fr",
63   "#fr",
64   "#pfr",
65   NULL
66 };
67
68 #define ALG_UNKNOWN -1
69
70 static int get_move_info(const char *str, int *piece, int *ff, int *fr, int *tf, int *tr, int *bishconfusion)
71 {
72   char tmp[1024];
73   char *s;
74   int i, j, len;
75   char c;
76   int matchVal = -1;
77   int lpiece, lff, lfr, ltf, ltr;
78
79   *bishconfusion = 0;
80   strlcpy(tmp, str, sizeof(tmp));
81   if ((s = strchr(tmp, '+'))) { /* Cut off any check marks */
82     *s = '\0';
83   }
84   if ((s = strchr(tmp, '='))) { /* Cut off any promotion marks */
85     *s = '\0';
86   }
87   if ((s = strchr(tmp, '#'))) { /* Cut off any 'mates' marks */
88     *s = '\0';
89   }
90   *piece = *ff = *fr = *tf = *tr = ALG_UNKNOWN;
91   len = strlen(tmp);
92   for (i = 0; alg_list[i]; i++) {
93     lpiece = lff = lfr = ltf = ltr = ALG_UNKNOWN;
94     if (strlen(alg_list[i]) != len)
95       continue;
96     for (j = len - 1; j >= 0; j--) {
97       switch (alg_list[i][j]) {
98       case 'f':
99         if ((tmp[j] < 'a') || (tmp[j] > 'l')) // [HGM] upto l-file
100           goto nomatch;
101         if (ltf == ALG_UNKNOWN)
102           ltf = tmp[j] - 'a';
103         else
104           lff = tmp[j] - 'a';
105         break;
106       case 'r':
107         if ((tmp[j] < '0') || (tmp[j] > '9')) // [HGM] also match 0- and 9-rank
108           goto nomatch;
109         if (ltr == ALG_UNKNOWN)
110           ltr = tmp[j] - '0'; // [HGM] allow 0-rank for Xiangqi, correct later
111         else
112           lfr = tmp[j] - '0';
113         break;
114       case 'p':
115         if (isupper(tmp[j]))
116           c = tolower(tmp[j]);
117         else
118           c = tmp[j];
119         if (c == 'k')
120           lpiece = KING;
121         else if (c == 'e')   // [HGM] note that som piece indicators are ambiguous,
122           lpiece = ELEPHANT; //       and their true meaning depends on the variant,
123         else if (c == 'v')   //       which we do not know at this point.
124           lpiece = CENTAUR;
125         else if (c == 's')
126           lpiece = SILVER;
127         else if (c == 'g')
128           lpiece = GOLD;
129         else if (c == 'l')
130           lpiece = LANCE;
131         else if (c == 'f')
132           lpiece = FERZ;
133         else if (c == 'h')
134           lpiece = HORSE;
135         else if (c == 'w')
136           lpiece = WAZIR;
137         else if (c == 'o')
138           lpiece = SQUIRREL;
139         else if (c == 'q')
140           lpiece = QUEEN;
141         else if (c == 'c')
142           lpiece = MARSHALL;
143         else if (c == 'a')
144           lpiece = CARDINAL;
145         else if (c == 'm')
146           lpiece = MAN;
147         else if (c == 'r')
148           lpiece = ROOK;
149         else if (c == 'b')
150           lpiece = BISHOP;
151         else if (c == 'n')
152           lpiece = KNIGHT;
153         else if (c == 'p')
154           lpiece = PAWN;
155         else if (c == 'd')
156           lpiece = DRAGONKING;
157         else
158           goto nomatch;
159         break;
160       case 'x':
161         if ((tmp[j] != 'x') && (tmp[j] != 'X'))
162           goto nomatch;
163         break;
164       case '@':
165         if (tmp[j] != '@' && tmp[j] != '*')
166           goto nomatch;
167         lff = lfr = ALG_DROP;
168         break;
169       case '#':
170         if (tmp[j] != '#')
171           goto nomatch;
172         lff = lfr = ALG_DROP;
173         break;
174       default:
175         d_printf( "Unknown character in algebraic parsing\n");
176         break;
177       }
178     }
179     if (lpiece == ALG_UNKNOWN)
180       lpiece = PAWN;
181     if (lpiece == PAWN && (lfr == ALG_UNKNOWN)) {       /* ffr or ff */
182       if (lff != ALG_UNKNOWN) {
183         if (lff == ltf)
184           goto nomatch;
185         if ((lff - ltf != 1) && (ltf - lff != 1))
186           goto nomatch;
187       }
188     }
189     *piece = lpiece;            /* We have a match */
190     *tf = ltf;
191     *tr = ltr;
192     *ff = lff;
193     *fr = lfr;
194     if (matchVal != -1) {
195       /* We have two matches, it must be that Bxc4 vs. bxc4 problem */
196       /* Or it could be the Bc4 vs bc4 problem */
197       *bishconfusion = 1;
198     }
199     matchVal = i;
200 nomatch:;
201   }
202
203   if (matchVal != -1)
204     return MS_ALG;
205   else
206     return MS_NOTMOVE;
207 }
208
209 int alg_is_move(const char *mstr)
210 {
211         int piece=0, ff=0, fr=0, tf=0, tr=0, bc=0;
212
213         return get_move_info(mstr, &piece, &ff, &fr, &tf, &tr, &bc);
214 }
215
216 /* add any promotion qualifier from a move string */
217 static void add_promotion(struct game_state_t *gs, const char *mstr, struct move_t * mt)
218 {
219         char *s;
220         int piece, i;
221         s = strchr(mstr, '=');
222         if (s == NULL) {
223                 return;
224         }
225         if(gs->promoType == 3) { // handle Shogi promotions
226                 piece = gs->board[mt->fromFile][mt->fromRank];
227                 if(colorval(piece) == WHITE && mt->fromRank < gs->ranks - gs->ranks/3
228                                             && mt->toRank   < gs->ranks - gs->ranks/3 ) return;
229                 if(colorval(piece) == BLACK && mt->fromRank >= gs->ranks/3
230                                             && mt->toRank   >= gs->ranks/3 ) return;
231                 switch(piecetype(piece)) {
232                     case PAWN:
233                     case LANCE:
234                     case HONORABLEHORSE:
235                     case SILVER:
236                         if(s[1] != '+' && s[1] != '^' && s[1] != 'G' && s[1] != 'g') return;
237                         piece = GOLD; break;
238                     case BISHOP:
239                         if(s[1] != '+' && s[1] != '^' && s[1] != 'H' && s[1] != 'h') return;
240                         piece = DRAGONHORSE; break;
241                     case ROOK:
242                         if(s[1] != '+' && s[1] != '^' && s[1] != 'D' && s[1] != 'd') return;
243                         piece = DRAGONKING; break;
244                     default: return; // others do not promote, so ignore
245                 }
246                 mt->piecePromotionTo = piece | colorval(gs->board[mt->fromFile][mt->fromRank]);
247                 return;
248         }
249
250       if(gs->drops != 2 || (gs->onMove == WHITE ? 0 : gs->ranks-1) != mt->fromRank) { // [HGM] always accept if backrank mover in Seirawan
251         if (piecetype(gs->board[mt->fromFile][mt->fromRank]) != PAWN &&
252             piecetype(gs->board[mt->fromFile][mt->fromRank]) != HOPLITE) {
253                 return;
254         }
255         if (mt->toRank < gs->ranks - gs->promoZone && mt->toRank >= gs->promoZone) {
256                 return;
257         }
258       }
259
260         switch (tolower(s[1])) {
261         case 'f':
262                 piece = FERZ2;
263                 break;
264         case 'q':
265                 piece = QUEEN;
266                 break;
267         case 'c':
268                 if(piecetype(gs->board[mt->fromFile][mt->fromRank]) == HOPLITE) piece = CAPTAIN; else
269                 if(!gs->capablancaPieces) return; // [HGM] should make variant-dependent piece mask
270                 piece = MARSHALL;
271                 break;
272         case 'a':
273                 if(!gs->capablancaPieces) return;
274                 piece = CARDINAL;
275                 break;
276         case 'm':
277                 if(!gs->royalKnight) return; // [HGM] only in knightmate
278                 piece = MAN;
279                 break;
280         case 'r':
281                 piece = ROOK;
282                 break;
283         case 'b':
284                 piece = BISHOP;
285                 break;
286         case 'n':
287                 if(gs->royalKnight) return; // [HGM] not in knightmate
288                 piece = KNIGHT;
289                 break;
290         // Superchess promotons: filtered out later by promoType
291         case 'g':
292                 if(piecetype(gs->board[mt->fromFile][mt->fromRank]) == HOPLITE) piece = GENERAL; else
293                 piece = MASTODON;
294                 break;
295         case 'o':
296                 piece = SQUIRREL;
297                 break;
298         case 'w':
299                 if(piecetype(gs->board[mt->fromFile][mt->fromRank]) == HOPLITE) piece = WARLORD; else
300                 piece = WOODY;
301                 break;
302         case 'k':
303                 if(piecetype(gs->board[mt->fromFile][mt->fromRank]) != HOPLITE) return;
304                 piece = KING;
305                 break;
306         case 'l':
307                 if(piecetype(gs->board[mt->fromFile][mt->fromRank]) != HOPLITE) return;
308                 piece = LIEUTENANT;
309                 break;
310         case 'v':
311                 piece = CENTAUR;
312                 break;
313         case 'e':
314                 piece = gs->drops == 2 ? SELEPHANT : EMPRESS; // for Seirawan
315                 break;
316         case 's':
317                 piece = PRINCESS;
318                 break;
319         case 'h':
320                 if(gs->drops != 2) return;
321                 piece = HAWK;
322                 break;
323         default:
324                 return;
325         }
326         i = colorval(gs->board[mt->fromFile][mt->fromRank]) == WHITE ? 0 : 1;
327         if(gs->promoType == 2 && gs->holding[i][piece-1] == 0) return; // only if piece was captured
328         if(piece >= WOODY && piece < KING && (gs->promoType != 2 || gs->promoZone == 3)) return; // reserved for Superchess
329
330         mt->piecePromotionTo = piece | colorval(gs->board[mt->fromFile][mt->fromRank]);
331 }
332
333 /* We already know it is algebraic, get the move squares */
334 int alg_parse_move(char *mstr, struct game_state_t * gs, struct move_t * mt)
335 {
336         int f=0, r=0, tmpr=0, posf=0, posr=0, posr2=0;
337         int piece=0, ff=0, fr=0, tf=0, tr=0, bc=0;
338
339   if (get_move_info(mstr, &piece, &ff, &fr, &tf, &tr, &bc) != MS_ALG) {
340     d_printf( "CHESSD: Shouldn't try to algebraicly parse non-algabraic move string.\n");
341     return MOVE_ILLEGAL;
342   }
343   // [HGM] check if move does not stray off board
344   if(gs->ranks < 10) { 
345     if(tr == 0 || fr == 0) return MOVE_ILLEGAL; // used nonexistent 0-rank
346     if(tr != ALG_UNKNOWN) tr--; if(fr != ALG_UNKNOWN) fr--; // shift to lowest rank = 1
347   }
348   if(tr >= gs->ranks || fr >= gs->ranks || tf >= gs->files || ff >= gs->files)
349     return MOVE_ILLEGAL;
350
351   // [HGM] resolve ambiguity in piece, type based on variant
352   switch(piece) {
353     case ELEPHANT:
354       if(strstr(gs->variant, "super"))   piece = EMPRESS; else
355       if(strstr(gs->variant, "seirawan"))piece = SELEPHANT; else
356       if(strstr(gs->variant, "great"))   piece = MODERNELEPHANT; else
357       if(strstr(gs->variant, "courier")) piece = ALFIL2;
358       break;
359     case CARDINAL:
360       if(strstr(gs->variant, "super")) piece = AMAZON; else
361       if(strstr(gs->variant, "xiangqi")) piece = MANDARIN;
362       break;
363     case MARSHALL:
364       if(strstr(gs->variant, "xiangqi")) piece = CANNON;
365       break;
366     case SILVER:
367       if(strstr(gs->variant, "super")) piece = PRINCESS;
368       if(strstr(gs->variant, "great")) piece = MAN2;
369       break;
370     case BISHOP:
371       if(strstr(gs->variant, "shatranj")) piece = ALFIL;
372       break;
373     case QUEEN:
374       if(strstr(gs->variant, "shatranj")) piece = FERZ;
375       break;
376     case WAZIR:
377       if(strstr(gs->variant, "super")) piece = WOODY;
378       break;
379     case KNIGHT:
380       if(strstr(gs->variant, "shogi")) piece = HONORABLEHORSE;
381       break;
382     case MAN:
383       if(strstr(gs->variant, "great")) piece = MINISTER;
384       break;
385     case HORSE:
386       if(strstr(gs->variant, "shogi")) piece = DRAGONHORSE; else
387       if(strstr(gs->variant, "seirawan")) piece = HAWK; else
388       if(strstr(gs->variant, "great")) piece = PRIESTESS;
389       break;
390     case GOLD:
391       if(strstr(gs->variant, "great")) piece = MASTODON;
392       break;
393   }
394
395   /* Resolve ambiguities in to-ness */
396   if (tf == ALG_UNKNOWN) {
397           d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
398           return MOVE_AMBIGUOUS;        /* Must always know to file */
399   }
400   if (tr == ALG_UNKNOWN) {
401     posr = posr2 = ALG_UNKNOWN;
402     if (piece != PAWN) {
403             d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
404             return MOVE_AMBIGUOUS;
405     }
406     if (ff == ALG_UNKNOWN) {
407             d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
408             return MOVE_AMBIGUOUS;
409     }
410     /* Need to find pawn on ff that can take to tf and fill in ranks */
411     for (InitPieceLoop(gs->board, &f, &r, gs->onMove);
412          NextPieceLoop(gs->board, &f, &r, gs->onMove, gs->files, gs->ranks);) {
413       if ((ff != ALG_UNKNOWN) && (ff != f))
414         continue;
415       if (piecetype(gs->board[f][r]) != piece)
416         continue;
417       if (gs->onMove == WHITE) {
418         tmpr = r + 1;
419       } else {
420         tmpr = r - 1;
421       }
422 /*      if ((gs->board[tf][tmpr] == NOPIECE) ||
423           (iscolor(gs->board[tf][tmpr], gs->onMove))) continue;*/
424 /* patch from Soso, added by Sparky 3/16/95                    */
425       if (gs->board[tf][tmpr] == NOPIECE) {
426         if ((gs->ep_possible[((gs->onMove == WHITE) ? 0 : 1)][ff]) != (tf - ff))
427           continue;
428       } else {
429         if (iscolor(gs->board[tf][tmpr], gs->onMove))
430           continue;
431       }
432
433       if (legal_andcheck_move(gs, f, r, tf, tmpr)) {
434               if ((posr != ALG_UNKNOWN) && (posr2 != ALG_UNKNOWN)) {
435                       d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
436                       return MOVE_AMBIGUOUS;
437               }
438         posr = tmpr;
439         posr2 = r;
440       }
441     }
442     tr = posr;
443     fr = posr2;
444   } else if (bc) {              /* Could be bxc4 or Bxc4, tr is known */
445     ff = ALG_UNKNOWN;
446     fr = ALG_UNKNOWN;
447     for (InitPieceLoop(gs->board, &f, &r, gs->onMove);
448          NextPieceLoop(gs->board, &f, &r, gs->onMove, gs->files, gs->ranks);) {
449             if ((piecetype(gs->board[f][r]) != PAWN) && (piecetype(gs->board[f][r]) != piece)) {
450                     // note that the interpretation Bxc4 is matched last, and has set piece to BISHOP
451                     continue;
452             }
453             if (legal_andcheck_move(gs, f, r, tf, tr)) {
454                     if ((piecetype(gs->board[f][r]) == PAWN) && (f != tolower(mstr[0]) - 'a')) {
455                             continue;
456                     }
457
458                     /* if its a lowercase 'b' then prefer the pawn move if there is one */
459                     if ((ff != ALG_UNKNOWN) && (fr != ALG_UNKNOWN) &&
460                         piecetype(gs->board[f][r]) == PAWN && mstr[0] >= 'a') {
461                             ff = f;
462                             fr = r;
463                             continue;
464                     }
465
466                     if ((ff != ALG_UNKNOWN) && (fr != ALG_UNKNOWN) &&
467                         piecetype(gs->board[ff][fr]) == PAWN && mstr[0] >= 'a') {
468                             continue;
469                     }
470
471                     if ((ff != ALG_UNKNOWN) && (fr != ALG_UNKNOWN)) {
472                             d_printf("Ambiguous %s(%d) mstr=%s\n", __FUNCTION__, __LINE__, mstr);
473                             return (MOVE_AMBIGUOUS);
474                     }
475                     ff = f;
476                     fr = r;
477             }
478     }
479   } else {                      /* The from position is unknown */
480     posf = ALG_UNKNOWN;
481     posr = ALG_UNKNOWN;
482     if ((ff == ALG_UNKNOWN) || (fr == ALG_UNKNOWN)) {
483       /* Need to find a piece that can go to tf, tr */
484       for (InitPieceLoop(gs->board, &f, &r, gs->onMove);
485            NextPieceLoop(gs->board, &f, &r, gs->onMove, gs->files, gs->ranks);) {
486         if ((ff != ALG_UNKNOWN) && (ff != f))
487           continue;
488         if ((fr != ALG_UNKNOWN) && (fr != r))
489           continue;
490         if (piecetype(gs->board[f][r]) != piece)
491           continue;
492         if (legal_andcheck_move(gs, f, r, tf, tr)) {
493                 if ((posf != ALG_UNKNOWN) && (posr != ALG_UNKNOWN)) {
494                         d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
495                         return MOVE_AMBIGUOUS;
496                 }
497           posf = f;
498           posr = r;
499         }
500       }
501     } else if (ff == ALG_DROP) {
502       if (legal_andcheck_move(gs, ALG_DROP, piece, tf, tr)) {
503         posf = ALG_DROP;
504         posr = piece;
505       }
506     }
507     ff = posf;
508     fr = posr;
509   }
510   if ((tf == ALG_UNKNOWN) || (tr == ALG_UNKNOWN) ||
511       (ff == ALG_UNKNOWN) || (fr == ALG_UNKNOWN))
512     return MOVE_ILLEGAL;
513   mt->fromFile = ff;
514   mt->fromRank = fr;
515   mt->toFile = tf;
516   mt->toRank = tr;
517
518   add_promotion(gs, mstr, mt);
519
520   return MOVE_OK;
521 }
522
523 /* A assumes the move has yet to be made on the board */
524
525 /* Soso: rewrote alg_unparse function.
526  * Algebraic deparser - sets the mStr variable with move description
527  * in short notation. Used in last move report and in 'moves' command.
528  */
529
530 char *alg_unparse(struct game_state_t * gs, struct move_t * mt)
531 {
532   static char mStr[20];
533   char tmp[20];
534   int piece, f, r;
535   int ambig, r_ambig, f_ambig;
536   struct game_state_t fakeMove;
537
538   if (mt->fromFile == ALG_DROP) {
539     piece = mt->fromRank;
540   } else {
541     piece = piecetype(gs->board[mt->fromFile][mt->fromRank]);
542   }
543
544   if (mt->fromFile == ALG_CASTLE) {
545     int r = gs->onMove == WHITE ? 1 : gs->ranks;
546     if(mt->toFile > mt->toRank) { // [HGM] castle: K ends right of R
547       strcpy(mStr, "O-O");
548     }
549     if (mt->toFile < mt->toRank) { // [HGM] castle: K ends left of R
550       strcpy(mStr, "O-O-O");
551     }
552     if(gs->drops == 2) {
553         if(mt->piecePromotionTo < 0) snprintf(mStr, 20, "%c%de%d", mt->fromRank + 'a', r, r);
554         goto suffix; // [HGM] in Seirawan castling can have gating suffix
555     }
556     goto check;
557   }
558   strcpy(mStr, "");
559   switch (piece) {
560   case PAWN:
561     if (mt->fromFile == ALG_DROP) {
562       strcpy(mStr,"P");
563     } else if (mt->fromFile != mt->toFile 
564             || gs->board[mt->toFile][mt->toRank] != NOPIECE) { // [HGM] XQ: forward captures as "axa6"
565       sprintf(tmp, "%c", mt->fromFile + 'a');
566       strcpy(mStr, tmp);
567     }
568     break;
569   case KNIGHT:
570     strcpy(mStr, "N");
571     break;
572   case BISHOP:
573     strcpy(mStr, "B");
574     break;
575   case ROOK:
576     strcpy(mStr, "R");
577     break;
578   case ALFIL2:
579   case AMAZON:
580   case CARDINAL:
581     strcpy(mStr, "A");
582     break;
583   case CAPTAIN:
584   case CANNON:
585   case MARSHALL:
586     strcpy(mStr, "C");
587     break;
588   case MAN:
589     strcpy(mStr, "M");
590     break;
591   case FERZ:
592   case QUEEN:
593     strcpy(mStr, "Q");
594     break;
595   case EMPRESS:
596   case ELEPHANT:
597   case SELEPHANT:
598     strcpy(mStr, "E");
599     break;
600   case ALFIL:
601     strcpy(mStr, "B");
602     break;
603   case FERZ2:
604     strcpy(mStr, "F");
605     break;
606   case WARLORD:
607   case WOODY:
608   case WAZIR:
609     strcpy(mStr, "W");
610     break;
611   case SQUIRREL:
612     strcpy(mStr, "O");
613     break;
614   case CENTAUR:
615     strcpy(mStr, "V");
616     break;
617   case HORSE:
618   case DRAGONHORSE:
619   case HAWK:
620   case HOPLITE:
621     strcpy(mStr, "H");
622     break;
623   case HONORABLEHORSE:
624     strcpy(mStr, "N");
625     break;
626   case DRAGONKING:
627     strcpy(mStr, "D");
628     break;
629   case LIEUTENANT:
630   case LANCE:
631     strcpy(mStr, "L");
632     break;
633   case PRINCESS:
634   case SILVER:
635     strcpy(mStr, "S");
636     break;
637   case MASTODON:
638   case GENERAL:
639   case GOLD:
640     strcpy(mStr, "G");
641     break;
642   case MANDARIN:
643     strcpy(mStr, "A");
644     break;
645   case KING:
646     strcpy(mStr, "K");
647     break;
648   default:
649     strcpy(mStr, "");
650     break;
651   }
652
653   if (mt->fromFile == ALG_DROP) {
654     strcat(mStr, "@");
655   } else {
656   /* Checks for ambiguity in short notation ( Ncb3, R8e8 or so) */
657   if (piece != PAWN) {
658     ambig = r_ambig = f_ambig = 0;
659     for (r = 0; r < gs->ranks; r++)
660       for (f = 0; f < gs->files; f++) {
661         if ((gs->board[f][r] != NOPIECE) && iscolor(gs->board[f][r], gs->onMove)
662             && (piecetype(gs->board[f][r]) == piece) &&
663             ((f != mt->fromFile) || (r != mt->fromRank))) {
664           if (legal_move(gs, f, r, mt->toFile, mt->toRank)) {
665             fakeMove = *gs;
666             fakeMove.board[f][r] = NOPIECE;
667             fakeMove.board[mt->toFile][mt->toRank] = piece | gs->onMove;
668             fakeMove.onMove = CToggle(fakeMove.onMove);
669             gs->onMove = CToggle(gs->onMove);
670
671 #if 0
672             d_printf("possible move %c%d%c%d against %c%d%c%d\n",
673                      'a' + f, r+1,
674                      'a' + mt->toFile, mt->toRank+1,
675                      'a' + mt->fromFile, mt->fromRank+1,
676                      'a' + mt->toFile, mt->toRank+1);
677 #endif
678
679             if (!in_check(&fakeMove)) {
680                     ambig++;
681                     if (f == mt->fromFile) {
682                             ambig++;
683                             f_ambig++;
684                     }
685                     if (r == mt->fromRank) {
686                             ambig++;
687                             r_ambig++;
688                     }
689             }
690             gs->onMove = CToggle(gs->onMove);
691           }
692         }
693       }
694     if (ambig > 0) {
695       /* Ambiguity in short notation, need to add file,rank or _both_ in
696          notation */
697       if (f_ambig == 0) {
698         sprintf(tmp, "%c", mt->fromFile + 'a');
699         strcat(mStr, tmp);
700       } else if (r_ambig == 0) {
701         sprintf(tmp, "%d", mt->fromRank + 1 - (gs->ranks > 9));
702         strcat(mStr, tmp);
703       } else {
704         sprintf(tmp, "%c%d", mt->fromFile + 'a', mt->fromRank + 1 - (gs->ranks > 9));
705         strcat(mStr, tmp);
706       }
707     }
708   }
709   if ((gs->board[mt->toFile][mt->toRank] != NOPIECE) ||
710       ((piece == PAWN) && (mt->fromFile != mt->toFile))) {
711     strcat(mStr, "x");
712   }
713   }
714   sprintf(tmp, "%c%d", mt->toFile + 'a', mt->toRank + 1 - (gs->ranks > 9));
715   strcat(mStr, tmp);
716 suffix:
717   if ((piece == PAWN || piece == HOPLITE || gs->promoType == 3 || gs->drops == 2) && (mt->piecePromotionTo != NOPIECE)) {
718     strcat(mStr, "=");          /* = before promoting piece */
719     switch (piecetype(abs(mt->piecePromotionTo))) {
720     case KING:
721       strcat(mStr, "K");
722       break;
723     case KNIGHT:
724       strcat(mStr, "N");
725       break;
726     case BISHOP:
727       strcat(mStr, "B");
728       break;
729     case ROOK:
730       strcat(mStr, "R");
731       break;
732     case CARDINAL:
733       strcat(mStr, "A");
734       break;
735     case MARSHALL:
736     case CAPTAIN:
737       strcat(mStr, "C");
738       break;
739     case MAN:
740       strcat(mStr, "M");
741       break;
742     case QUEEN:
743       strcat(mStr, "Q");
744       break;
745     case FERZ2:
746       strcat(mStr, "F");
747       break;
748     case WARLORD:
749     case WOODY:
750       strcat(mStr, "W");
751       break;
752     case SELEPHANT:
753     case EMPRESS:
754       strcat(mStr, "E");
755       break;
756     case CENTAUR:
757       strcat(mStr, "V");
758       break;
759     case PRINCESS:
760       strcat(mStr, "S");
761       break;
762     case SQUIRREL:
763       strcat(mStr, "O");
764       break;
765     case MASTODON:
766     case GENERAL:
767     case GOLD: // [HGM] Shogi promotions: avoid use of '+'
768       strcat(mStr, "G");
769       break;
770     case HAWK:
771     case DRAGONHORSE:
772       strcat(mStr, "H");
773       break;
774     case DRAGONKING:
775       strcat(mStr, "D");
776       break;
777     case LIEUTENANT:
778       strcat(mStr, "L");
779       break;
780     default:
781       break;
782     }
783   }
784 check:;
785   fakeMove = *gs;
786   execute_move(&fakeMove, mt, 0);
787   fakeMove.onMove = CToggle(fakeMove.onMove);
788   if (in_check(&fakeMove)) {
789     strcat(mStr, "+");
790   }
791   return mStr;
792 }