Update sr.po translation
[xboard.git] / gamelist.c
1 /*
2  * gamelist.c -- Functions to manage a gamelist
3  *
4  * Copyright 1995, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Free
5  * Software Foundation, Inc.
6  *
7  * Enhancements Copyright 2005 Alessandro Scotti
8  *
9  * ------------------------------------------------------------------------
10  *
11  * GNU XBoard is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or (at
14  * your option) any later version.
15  *
16  * GNU XBoard is distributed in the hope that it will be useful, but
17  * WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see http://www.gnu.org/licenses/.
23  *
24  *------------------------------------------------------------------------
25  ** See the file ChangeLog for a revision history.  */
26
27 #include "config.h"
28
29 #include <stdio.h>
30 #include <errno.h>
31 #if STDC_HEADERS
32 # include <stdlib.h>
33 # include <string.h>
34 #else /* not STDC_HEADERS */
35 # if HAVE_STRING_H
36 #  include <string.h>
37 # else /* not HAVE_STRING_H */
38 #  include <strings.h>
39 # endif /* not HAVE_STRING_H */
40 #endif /* not STDC_HEADERS */
41
42 #include "common.h"
43 #include "frontend.h"
44 #include "backend.h"
45 #include "parser.h"
46 #include "moves.h"
47 #include "gettext.h"
48
49 #ifdef ENABLE_NLS
50 # define  _(s) gettext (s)
51 # define N_(s) gettext_noop (s)
52 #else
53 # define  _(s) (s)
54 # define N_(s)  s
55 #endif
56
57
58 /* Variables
59  */
60 List gameList;
61 extern Board initialPosition;
62 extern int quickFlag;
63 extern int movePtr;
64
65 /* Local function prototypes
66  */
67 static void GameListDeleteGame P((ListGame *));
68 static ListGame *GameListCreate P((void));
69 static void GameListFree P((List *));
70 static int GameListNewGame P((ListGame **));
71
72 /* [AS] Wildcard pattern matching */
73 Boolean
74 HasPattern (const char * text, const char * pattern)
75 {
76     while( *pattern != '\0' ) {
77         if( *pattern == '*' ) {
78             while( *pattern == '*' ) {
79                 pattern++;
80             }
81
82             if( *pattern == '\0' ) {
83                 return TRUE;
84             }
85
86             while( *text != '\0' ) {
87                 if( HasPattern( text, pattern ) ) {
88                     return TRUE;
89                 }
90                 text++;
91             }
92         }
93         else if( (*pattern == *text) || ((*pattern == '?') && (*text != '\0')) ) {
94             pattern++;
95             text++;
96             continue;
97         }
98
99         return FALSE;
100     }
101
102     return TRUE;
103 }
104
105 Boolean
106 SearchPattern (const char * text, const char * pattern)
107 {
108     Boolean result = TRUE;
109
110     if( pattern != NULL && *pattern != '\0' ) {
111         if( *pattern == '*' ) {
112             result = HasPattern( text, pattern );
113         }
114         else {
115             result = FALSE;
116
117             while( *text != '\0' ) {
118                 if( HasPattern( text, pattern ) ) {
119                     result = TRUE;
120                     break;
121                 }
122                 text++;
123             }
124         }
125     }
126
127     return result;
128 }
129
130 /* Delete a ListGame; implies removint it from a list.
131  */
132 static void
133 GameListDeleteGame (ListGame *listGame)
134 {
135     if (listGame) {
136         if (listGame->gameInfo.event) free(listGame->gameInfo.event);
137         if (listGame->gameInfo.site) free(listGame->gameInfo.site);
138         if (listGame->gameInfo.date) free(listGame->gameInfo.date);
139         if (listGame->gameInfo.round) free(listGame->gameInfo.round);
140         if (listGame->gameInfo.white) free(listGame->gameInfo.white);
141         if (listGame->gameInfo.black) free(listGame->gameInfo.black);
142         if (listGame->gameInfo.fen) free(listGame->gameInfo.fen);
143         if (listGame->gameInfo.resultDetails) free(listGame->gameInfo.resultDetails);
144         if (listGame->gameInfo.timeControl) free(listGame->gameInfo.timeControl);
145         if (listGame->gameInfo.extraTags) free(listGame->gameInfo.extraTags);
146         if (listGame->gameInfo.outOfBook) free(listGame->gameInfo.outOfBook);
147         ListNodeFree((ListNode *) listGame);
148     }
149 }
150
151
152 /* Free the previous list of games.
153  */
154 static void
155 GameListFree (List *gameList)
156 {
157   while (!ListEmpty(gameList))
158     {
159         GameListDeleteGame((ListGame *) gameList->head);
160     }
161 }
162
163
164
165 /* Initialize a new GameInfo structure.
166  */
167 void
168 GameListInitGameInfo (GameInfo *gameInfo)
169 {
170     gameInfo->event = NULL;
171     gameInfo->site = NULL;
172     gameInfo->date = NULL;
173     gameInfo->round = NULL;
174     gameInfo->white = NULL;
175     gameInfo->black = NULL;
176     gameInfo->result = GameUnfinished;
177     gameInfo->fen = NULL;
178     gameInfo->resultDetails = NULL;
179     gameInfo->timeControl = NULL;
180     gameInfo->extraTags = NULL;
181     gameInfo->whiteRating = -1; /* unknown */
182     gameInfo->blackRating = -1; /* unknown */
183     gameInfo->variant = VariantNormal;
184     gameInfo->variantName = NULL;
185     gameInfo->outOfBook = NULL;
186     gameInfo->resultDetails = NULL;
187 }
188
189
190 /* Create empty ListGame; returns ListGame or NULL, if out of memory.
191  *
192  * Note, that the ListGame is *not* added to any list
193  */
194 static ListGame *
195 GameListCreate ()
196 {
197     ListGame *listGame;
198
199     if ((listGame = (ListGame *) ListNodeCreate(sizeof(*listGame)))) {
200         GameListInitGameInfo(&listGame->gameInfo);
201     }
202     return(listGame);
203 }
204
205
206 /* Creates a new game for the gamelist.
207  */
208 static int
209 GameListNewGame (ListGame **listGamePtr)
210 {
211     if (!(*listGamePtr = (ListGame *) GameListCreate())) {
212         GameListFree(&gameList);
213         return(ENOMEM);
214     }
215     ListAddTail(&gameList, (ListNode *) *listGamePtr);
216     return(0);
217 }
218
219
220 /* Build the list of games in the open file f.
221  * Returns 0 for success or error number.
222  */
223 int
224 GameListBuild (FILE *f)
225 {
226     ChessMove cm, lastStart;
227     int gameNumber;
228     ListGame *currentListGame = NULL;
229     int error, scratch=100, plyNr=0, fromX, fromY, toX, toY;
230     int offset;
231     char lastComment[MSG_SIZ], buf[MSG_SIZ];
232     TimeMark t, t2;
233
234     GetTimeMark(&t);
235     GameListFree(&gameList);
236     yynewfile(f);
237     gameNumber = 0;
238     movePtr = 0;
239
240     lastStart = (ChessMove) 0;
241     yyskipmoves = FALSE;
242     do {
243         yyboardindex = scratch;
244         offset = yyoffset();
245         quickFlag = plyNr + 1;
246         cm = (ChessMove) Myylex();
247         switch (cm) {
248           case GNUChessGame:
249             if ((error = GameListNewGame(&currentListGame))) {
250                 rewind(f);
251                 yyskipmoves = FALSE;
252                 return(error);
253             }
254             currentListGame->number = ++gameNumber;
255             currentListGame->offset = offset;
256             if(1) { CopyBoard(boards[scratch], initialPosition); plyNr = 0; currentListGame->moves = PackGame(boards[scratch]); }
257             if (currentListGame->gameInfo.event != NULL) {
258                 free(currentListGame->gameInfo.event);
259             }
260             currentListGame->gameInfo.event = StrSave(yy_text);
261             lastStart = cm;
262             break;
263           case XBoardGame:
264             lastStart = cm;
265             break;
266           case MoveNumberOne:
267             switch (lastStart) {
268               case GNUChessGame:
269                 break;          /*  ignore  */
270               case PGNTag:
271                 lastStart = cm;
272                 break;          /*  Already started */
273               case (ChessMove) 0:
274               case MoveNumberOne:
275               case XBoardGame:
276                 if ((error = GameListNewGame(&currentListGame))) {
277                     rewind(f);
278                     yyskipmoves = FALSE;
279                     return(error);
280                 }
281                 currentListGame->number = ++gameNumber;
282                 currentListGame->offset = offset;
283                 if(1) { CopyBoard(boards[scratch], initialPosition); plyNr = 0; currentListGame->moves = PackGame(boards[scratch]); }
284                 lastStart = cm;
285                 break;
286               default:
287                 break;          /*  impossible  */
288             }
289             break;
290           case PGNTag:
291             lastStart = cm;
292             if ((error = GameListNewGame(&currentListGame))) {
293                 rewind(f);
294                 yyskipmoves = FALSE;
295                 return(error);
296             }
297             currentListGame->number = ++gameNumber;
298             currentListGame->offset = offset;
299             ParsePGNTag(yy_text, &currentListGame->gameInfo);
300             do {
301                 yyboardindex = 1;
302                 offset = yyoffset();
303                 cm = (ChessMove) Myylex();
304                 if (cm == PGNTag) {
305                     ParsePGNTag(yy_text, &currentListGame->gameInfo);
306                 }
307             } while (cm == PGNTag || cm == Comment);
308             if(1) {
309                 int btm=0;
310                 if(currentListGame->gameInfo.fen) ParseFEN(boards[scratch], &btm, currentListGame->gameInfo.fen, FALSE);
311                 else CopyBoard(boards[scratch], initialPosition);
312                 plyNr = (btm != 0);
313                 currentListGame->moves = PackGame(boards[scratch]);
314             }
315             if(cm != NormalMove) break;
316           case IllegalMove:
317                 if(appData.testLegality) break;
318           case NormalMove:
319             /* Allow the first game to start with an unnumbered move */
320             yyskipmoves = FALSE;
321             if (lastStart == (ChessMove) 0) {
322               if ((error = GameListNewGame(&currentListGame))) {
323                 rewind(f);
324                 yyskipmoves = FALSE;
325                 return(error);
326               }
327               currentListGame->number = ++gameNumber;
328               currentListGame->offset = offset;
329               if(1) { CopyBoard(boards[scratch], initialPosition); plyNr = 0; currentListGame->moves = PackGame(boards[scratch]); }
330               lastStart = MoveNumberOne;
331             }
332           case WhiteCapturesEnPassant:
333           case BlackCapturesEnPassant:
334           case WhitePromotion:
335           case BlackPromotion:
336           case WhiteNonPromotion:
337           case BlackNonPromotion:
338           case WhiteKingSideCastle:
339           case WhiteQueenSideCastle:
340           case BlackKingSideCastle:
341           case BlackQueenSideCastle:
342           case WhiteKingSideCastleWild:
343           case WhiteQueenSideCastleWild:
344           case BlackKingSideCastleWild:
345           case BlackQueenSideCastleWild:
346           case WhiteHSideCastleFR:
347           case WhiteASideCastleFR:
348           case BlackHSideCastleFR:
349           case BlackASideCastleFR:
350                 fromX = currentMoveString[0] - AAA;
351                 fromY = currentMoveString[1] - ONE;
352                 toX = currentMoveString[2] - AAA;
353                 toY = currentMoveString[3] - ONE;
354                 plyNr++;
355                 ApplyMove(fromX, fromY, toX, toY, currentMoveString[4], boards[scratch]);
356                 if(currentListGame && currentListGame->moves) PackMove(fromX, fromY, toX, toY, boards[scratch][toY][toX]);
357             break;
358         case WhiteWins: // [HGM] rescom: save last comment as result details
359         case BlackWins:
360         case GameIsDrawn:
361         case GameUnfinished:
362             if(!currentListGame) break;
363             if(currentListGame->gameInfo.result == GameUnfinished)
364                 currentListGame->gameInfo.result = cm; // correct result tag with actual result
365             if (currentListGame->gameInfo.resultDetails != NULL) {
366                 free(currentListGame->gameInfo.resultDetails);
367             }
368             if(yy_text[0] == '{') {
369                 char *p;
370                 safeStrCpy(lastComment, yy_text+1, sizeof(lastComment)/sizeof(lastComment[0]));
371                 if((p = strchr(lastComment, '}'))) *p = 0;
372                 currentListGame->gameInfo.resultDetails = StrSave(lastComment);
373             }
374             break;
375           default:
376             break;
377         }
378         if(gameNumber % 1000 == 0) {
379             snprintf(buf, MSG_SIZ, _("Reading game file (%d)"), gameNumber);
380             DisplayTitle(buf); DoEvents();
381         }
382     }
383     while (cm != (ChessMove) 0);
384
385  if(currentListGame) {
386     if(!currentListGame->moves) DisplayError("Game cache overflowed\nPosition-searching might not work properly", 0);
387
388     if (appData.debugMode) {
389         for (currentListGame = (ListGame *) gameList.head;
390              currentListGame->node.succ;
391              currentListGame = (ListGame *) currentListGame->node.succ) {
392
393             fprintf(debugFP, "Parsed game number %d, offset %ld:\n",
394                     currentListGame->number, currentListGame->offset);
395             PrintPGNTags(debugFP, &currentListGame->gameInfo);
396         }
397     }
398   }
399     if(appData.debugMode) { GetTimeMark(&t2);printf("GameListBuild %ld msec\n", SubtractTimeMarks(&t2,&t)); }
400     quickFlag = 0;
401     PackGame(boards[scratch]); // for appending end-of-game marker.
402     DisplayTitle("WinBoard");
403     rewind(f);
404     yyskipmoves = FALSE;
405     return 0;
406 }
407
408
409 /* Clear an existing GameInfo structure.
410  */
411 void
412 ClearGameInfo (GameInfo *gameInfo)
413 {
414     if (gameInfo->event != NULL) {
415         free(gameInfo->event);
416     }
417     if (gameInfo->site != NULL) {
418         free(gameInfo->site);
419     }
420     if (gameInfo->date != NULL) {
421         free(gameInfo->date);
422     }
423     if (gameInfo->round != NULL) {
424         free(gameInfo->round);
425     }
426     if (gameInfo->white != NULL) {
427         free(gameInfo->white);
428     }
429     if (gameInfo->black != NULL) {
430         free(gameInfo->black);
431     }
432     if (gameInfo->resultDetails != NULL) {
433         free(gameInfo->resultDetails);
434     }
435     if (gameInfo->fen != NULL) {
436         free(gameInfo->fen);
437     }
438     if (gameInfo->timeControl != NULL) {
439         free(gameInfo->timeControl);
440     }
441     if (gameInfo->extraTags != NULL) {
442         free(gameInfo->extraTags);
443     }
444     if (gameInfo->variantName != NULL) {
445         free(gameInfo->variantName);
446     }
447     if (gameInfo->outOfBook != NULL) {
448         free(gameInfo->outOfBook);
449     }
450     GameListInitGameInfo(gameInfo);
451 }
452
453 /* [AS] Replaced by "dynamic" tag selection below */
454 char *
455 GameListLineOld (int number, GameInfo *gameInfo)
456 {
457     char *event = (gameInfo->event && strcmp(gameInfo->event, "?") != 0) ?
458                      gameInfo->event : gameInfo->site ? gameInfo->site : "?";
459     char *white = gameInfo->white ? gameInfo->white : "?";
460     char *black = gameInfo->black ? gameInfo->black : "?";
461     char *date = gameInfo->date ? gameInfo->date : "?";
462     int len = 10 + strlen(event) + 2 + strlen(white) + 1 +
463       strlen(black) + 11 + strlen(date) + 1;
464     char *ret = (char *) malloc(len);
465     sprintf(ret, "%d. %s, %s-%s, %s, %s",
466             number, event, white, black, PGNResult(gameInfo->result), date);
467     return ret;
468 }
469
470 #define MAX_FIELD_LEN   80  /* To avoid overflowing the buffer */
471
472 char *
473 GameListLine (int number, GameInfo * gameInfo)
474 {
475     char buffer[2*MSG_SIZ];
476     char * buf = buffer;
477     char * glt = appData.gameListTags;
478
479     buf += sprintf( buffer, "%d.", number );
480
481     while( *glt != '\0' ) {
482         *buf++ = ' ';
483
484         switch( *glt ) {
485         case GLT_EVENT:
486             strncpy( buf, gameInfo->event ? gameInfo->event : "?", MAX_FIELD_LEN );
487             break;
488         case GLT_SITE:
489             strncpy( buf, gameInfo->site ? gameInfo->site : "?", MAX_FIELD_LEN );
490             break;
491         case GLT_DATE:
492             strncpy( buf, gameInfo->date ? gameInfo->date : "?", MAX_FIELD_LEN );
493             break;
494         case GLT_ROUND:
495             strncpy( buf, gameInfo->round ? gameInfo->round : "?", MAX_FIELD_LEN );
496             break;
497         case GLT_PLAYERS:
498             strncpy( buf, gameInfo->white ? gameInfo->white : "?", MAX_FIELD_LEN );
499             buf[ MAX_FIELD_LEN-1 ] = '\0';
500             buf += strlen( buf );
501             *buf++ = '-';
502             strncpy( buf, gameInfo->black ? gameInfo->black : "?", MAX_FIELD_LEN );
503             break;
504         case GLT_RESULT:
505             safeStrCpy( buf, PGNResult(gameInfo->result), 2*MSG_SIZ );
506             break;
507         case GLT_WHITE_ELO:
508             if( gameInfo->whiteRating > 0 )
509               sprintf( buf,  "%d", gameInfo->whiteRating );
510             else
511               safeStrCpy( buf, "?" , 2*MSG_SIZ);
512             break;
513         case GLT_BLACK_ELO:
514             if( gameInfo->blackRating > 0 )
515                 sprintf( buf, "%d", gameInfo->blackRating );
516             else
517               safeStrCpy( buf, "?" , 2*MSG_SIZ);
518             break;
519         case GLT_TIME_CONTROL:
520             strncpy( buf, gameInfo->timeControl ? gameInfo->timeControl : "?", MAX_FIELD_LEN );
521             break;
522         case GLT_VARIANT:
523             strncpy( buf, gameInfo->variantName ? gameInfo->variantName : VariantName(gameInfo->variant), MAX_FIELD_LEN );
524 //            strncpy( buf, VariantName(gameInfo->variant), MAX_FIELD_LEN );
525             break;
526         case GLT_OUT_OF_BOOK:
527             strncpy( buf, gameInfo->outOfBook ? gameInfo->outOfBook : "?", MAX_FIELD_LEN );
528             break;
529         case GLT_RESULT_COMMENT:
530             strncpy( buf, gameInfo->resultDetails ? gameInfo->resultDetails : "res?", MAX_FIELD_LEN );
531             break;
532         default:
533             break;
534         }
535
536         buf[MAX_FIELD_LEN-1] = '\0';
537
538         buf += strlen( buf );
539
540         glt++;
541
542         if( *glt != '\0' ) {
543             *buf++ = ',';
544         }
545     }
546
547     *buf = '\0';
548
549     return strdup( buffer );
550 }
551
552 char *
553 GameListLineFull (int number, GameInfo * gameInfo)
554 {
555     char * event = gameInfo->event ? gameInfo->event : "?";
556     char * site = gameInfo->site ? gameInfo->site : "?";
557     char * white = gameInfo->white ? gameInfo->white : "?";
558     char * black = gameInfo->black ? gameInfo->black : "?";
559     char * round = gameInfo->round ? gameInfo->round : "?";
560     char * date = gameInfo->date ? gameInfo->date : "?";
561     char * oob = gameInfo->outOfBook ? gameInfo->outOfBook : "";
562     char * reason = gameInfo->resultDetails ? gameInfo->resultDetails : "";
563
564     int len = 64 + strlen(event) + strlen(site) + strlen(white) + strlen(black) + strlen(date) + strlen(oob) + strlen(reason);
565
566     char *ret = (char *) malloc(len);
567
568     sprintf(ret, "%d, \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\"",
569         number, event, site, round, white, black, PGNResult(gameInfo->result), reason, date, oob );
570
571     return ret;
572 }
573 // --------------------------------------- Game-List options dialog --------------------------------------
574
575 // back-end
576 typedef struct {
577     char id;
578     char * name;
579 } GLT_Item;
580
581 // back-end: translation table tag id-char <-> full tag name
582 static GLT_Item GLT_ItemInfo[] = {
583     { GLT_EVENT,      "Event" },
584     { GLT_SITE,       "Site" },
585     { GLT_DATE,       "Date" },
586     { GLT_ROUND,      "Round" },
587     { GLT_PLAYERS,    "Players" },
588     { GLT_RESULT,     "Result" },
589     { GLT_WHITE_ELO,  "White Rating" },
590     { GLT_BLACK_ELO,  "Black Rating" },
591     { GLT_TIME_CONTROL,"Time Control" },
592     { GLT_VARIANT,    "Variant" },
593     { GLT_OUT_OF_BOOK,PGN_OUT_OF_BOOK },
594     { GLT_RESULT_COMMENT, "Result Comment" }, // [HGM] rescom
595     { 0, 0 }
596 };
597
598 char lpUserGLT[LPUSERGLT_SIZE];
599
600 // back-end: convert the tag id-char to a full tag name
601 char *
602 GLT_FindItem (char id)
603 {
604     char * result = 0;
605
606     GLT_Item * list = GLT_ItemInfo;
607
608     while( list->id != 0 ) {
609         if( list->id == id ) {
610             result = list->name;
611             break;
612         }
613
614         list++;
615     }
616
617     return result;
618 }
619
620 // back-end: build the list of tag names
621 void
622 GLT_TagsToList (char *tags)
623 {
624     char * pc = tags;
625
626     GLT_ClearList();
627
628     while( *pc ) {
629         GLT_AddToList( GLT_FindItem(*pc) );
630         pc++;
631     }
632
633     GLT_AddToList( "     --- Hidden tags ---     " );
634
635     pc = GLT_ALL_TAGS;
636
637     while( *pc ) {
638         if( strchr( tags, *pc ) == 0 ) {
639             GLT_AddToList( GLT_FindItem(*pc) );
640         }
641         pc++;
642     }
643
644     GLT_DeSelectList();
645 }
646
647 // back-end: retrieve item from dialog and translate to id-char
648 char
649 GLT_ListItemToTag (int index)
650 {
651     char result = '\0';
652     char name[MSG_SIZ];
653
654     GLT_Item * list = GLT_ItemInfo;
655
656     if( GLT_GetFromList(index, name) ) {
657         while( list->id != 0 ) {
658             if( strcmp( list->name, name ) == 0 ) {
659                 result = list->id;
660                 break;
661             }
662
663             list++;
664         }
665     }
666
667     return result;
668 }
669
670 // back-end: add items id-chars one-by-one to temp tags string
671 void
672 GLT_ParseList ()
673 {
674     char * pc = lpUserGLT;
675     int idx = 0;
676     char id;
677
678     do {
679         id = GLT_ListItemToTag( idx );
680         *pc++ = id;
681         idx++;
682     } while( id != '\0' );
683 }