bruno/chess-games
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
abaff964ca2c089656d6ff0492b169436ba875d9
chess-games/pgn-extract/grammar.c
Bruno Raoult abaff964ca add pgn-extract 22.11
2024-01-22 07:30:05 +01:00

1427 lines
46 KiB
C
Raw Blame History

/*
* This file is part of pgn-extract: a Portable Game Notation (PGN) extractor.
* Copyright (C) 1994-2022 David J. Barnes
*
* pgn-extract is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* pgn-extract is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with pgn-extract. If not, see <http://www.gnu.org/licenses/>.
*
* David J. Barnes may be contacted as d.j.barnes@kent.ac.uk
* https://www.cs.kent.ac.uk/people/staff/djb/
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "bool.h"
#include "mymalloc.h"
#include "defs.h"
#include "typedef.h"
#include "tokens.h"
#include "taglist.h"
#include "lex.h"
#include "moves.h"
#include "map.h"
#include "lists.h"
#include "apply.h"
#include "output.h"
#include "eco.h"
#include "end.h"
#include "grammar.h"
#include "hashing.h"
static TokenType current_symbol = NO_TOKEN;
/* Keep track of which RAV level we are at.
* This is used to check whether a TERMINATING_RESULT is the final one
* and whether NULL_MOVEs are allowed.
*/
static unsigned RAV_level = 0;
/* How often to report processing rate. */
static unsigned PROGRESS_RATE = 1000;
/* Retain details of the header of a game.
* This comprises the Tags and any comment prefixing the
* moves of the game.
*/
static struct {
/* The tag values. */
char **Tags;
unsigned header_tags_length;
CommentList *prefix_comment;
} GameHeader;
static void parse_opt_game_list(SourceFileType file_type);
static Boolean parse_game(Move **returned_move_list, unsigned long *start_line, unsigned long *end_line);
Boolean parse_opt_tag_list(void);
Boolean parse_tag(void);
static Move *parse_move_list(void);
static Move *parse_move_and_variants(void);
static Move *parse_move(void);
static Move *parse_move_unit(void);
static CommentList *parse_opt_comment_list(void);
Boolean parse_opt_move_number(void);
static void parse_opt_NAG_list(Move *move_details);
static Variation *parse_opt_variant_list(void);
static Variation *parse_variant(void);
static char *parse_result(void);
static void setup_for_new_game(void);
static CommentList *append_comment(CommentList *item, CommentList *list);
static void check_result(char **Tags, const char *terminating_result);
static Boolean chess960_setup(Board *board);
static void deal_with_ECO_line(Move *move_list);
static void deal_with_game(Move *move_list, unsigned long start_line, unsigned long end_line);
static Boolean finished_processing(void);
static void free_tags(void);
static CommentList *merge_comment_lists(CommentList *prefix, CommentList *suffix);
static void output_game(Game *game,FILE *outputfile);
static void split_variants(Game *game, FILE *outputfile, unsigned depth);
/* Initialise the game header structure to contain
* space for the default number of tags.
* The space will have to be increased if new tags are
* identified in the program source.
*/
void
init_game_header(void)
{
unsigned i;
GameHeader.header_tags_length = ORIGINAL_NUMBER_OF_TAGS;
GameHeader.Tags = (char **) malloc_or_die(GameHeader.header_tags_length *
sizeof (*GameHeader.Tags));
for (i = 0; i < GameHeader.header_tags_length; i++) {
GameHeader.Tags[i] = (char *) NULL;
}
GameHeader.prefix_comment = (CommentList *) NULL;
}
void
increase_game_header_tags_length(unsigned new_length)
{
unsigned i;
if (new_length <= GameHeader.header_tags_length) {
fprintf(GlobalState.logfile,
"Internal error: inappropriate length %d ", new_length);
fprintf(GlobalState.logfile,
" passed to increase_game_header_tags().\n");
exit(1);
}
GameHeader.Tags = (char **) realloc_or_die((void *) GameHeader.Tags,
new_length * sizeof (*GameHeader.Tags));
for (i = GameHeader.header_tags_length; i < new_length; i++) {
GameHeader.Tags[i] = NULL;
}
GameHeader.header_tags_length = new_length;
}
/* Try to open the given file. Error and exit on failure. */
FILE *
must_open_file(const char *filename, const char *mode)
{
FILE *fp;
fp = fopen(filename, mode);
if (fp == NULL) {
fprintf(GlobalState.logfile, "Unable to open the file: \"%s\"\n",
filename);
exit(1);
}
return fp;
}
/* Print out on outfp the current details and
* terminate with a newline.
*/
void
report_details(FILE *outfp)
{
if (GameHeader.Tags[WHITE_TAG] != NULL) {
fprintf(outfp, "%s - ", GameHeader.Tags[WHITE_TAG]);
}
if (GameHeader.Tags[BLACK_TAG] != NULL) {
fprintf(outfp, "%s ", GameHeader.Tags[BLACK_TAG]);
}
if (GameHeader.Tags[EVENT_TAG] != NULL) {
fprintf(outfp, "%s ", GameHeader.Tags[EVENT_TAG]);
}
if (GameHeader.Tags[SITE_TAG] != NULL) {
fprintf(outfp, "%s ", GameHeader.Tags[SITE_TAG]);
}
if (GameHeader.Tags[DATE_TAG] != NULL) {
fprintf(outfp, "%s ", GameHeader.Tags[DATE_TAG]);
}
putc('\n', outfp);
fflush(outfp);
}
/* Check that terminating_result is consistent with
* Tags[RESULT_TAG].
* If the latter is missing, fill it in from terminating_result.
* If Tags[RESULT_TAG] is the short form "1/2" then replace it
* with the long form.
*/
static void
check_result(char **Tags, const char *terminating_result)
{
char *result_tag = Tags[RESULT_TAG];
if(result_tag != NULL && strcmp(result_tag, "1/2") == 0) {
/* Inappropriate short form. */
(void) free(result_tag);
result_tag = Tags[RESULT_TAG] = copy_string("1/2-1/2");
}
if (terminating_result != NULL) {
if ((result_tag == NULL) || (*result_tag == '\0') ||
(strcmp(result_tag, "?") == 0)) {
/* Use a copy of terminating result. */
result_tag = copy_string(terminating_result);
Tags[RESULT_TAG] = result_tag;
}
else {
/* Consistency checks done later. */
}
}
}
/* Select which file to write to based upon the game state.
* This will depend upon:
* Whether the number of games per file is limited.
* Whether ECO_level > DONT_DIVIDE.
*/
/* A length for filenames. */
#define FILENAME_LENGTH (250)
static FILE *
select_output_file(StateInfo *GameState, const char *eco)
{
if (GameState->games_per_file > 0) {
if (GameState->games_per_file == 1 ||
(GameState->num_games_matched % GameState->games_per_file) == 1) {
/* Time to open the next one. */
char filename[FILENAME_LENGTH];
if (GameState->outputfile != NULL) {
if (GlobalState.json_format && GameState->num_games_matched != 1) {
/* Terminate the output of the previous file. */
fputs("\n]\n", GlobalState.outputfile);
}
(void) fclose(GameState->outputfile);
}
sprintf(filename, "%u%s",
GameState->next_file_number,
output_file_suffix(GameState->output_format));
GameState->outputfile = must_open_file(filename, "w");
GameState->next_file_number++;
if (GlobalState.json_format) {
fputs("[\n", GlobalState.outputfile);
}
}
}
else {
if (GameState->ECO_level > DONT_DIVIDE) {
/* Open a file of the appropriate name. */
if (GameState->outputfile != NULL) {
/* @@@ In practice, this might need refinement.
* Repeated opening and closing may prove inefficient.
*/
(void) fclose(GameState->outputfile);
GameState->outputfile = open_eco_output_file(
GameState->ECO_level,
eco);
}
}
else if (GlobalState.json_format && GameState->num_games_matched == 1) {
fputs("[\n", GlobalState.outputfile);
}
else {
}
}
return GameState->outputfile;
}
/*
* Conditions for finishing processing, other than all the input
* having been processed.
*/
static Boolean finished_processing(void)
{
return (GlobalState.matching_game_numbers != NULL &&
GlobalState.next_game_number_to_output == NULL) ||
(GlobalState.maximum_matches > 0 &&
GlobalState.num_games_matched == GlobalState.maximum_matches) ||
GlobalState.num_games_processed >= GlobalState.game_limit;
}
/*
* Is the given game number within the range to be matched?
*/
static Boolean in_game_number_range(unsigned long number,
game_number *range)
{
return range != NULL && range->min <= number && number <= range->max;
}
static void
parse_opt_game_list(SourceFileType file_type)
{
Move *move_list = NULL;
unsigned long start_line, end_line;
while (parse_game(&move_list, &start_line, &end_line) && !finished_processing()) {
if (file_type == NORMALFILE) {
deal_with_game(move_list, start_line, end_line);
}
else if (file_type == CHECKFILE) {
deal_with_game(move_list, start_line, end_line);
}
else if (file_type == ECOFILE) {
if (move_list != NULL) {
deal_with_ECO_line(move_list);
}
else {
fprintf(GlobalState.logfile, "ECO line with zero moves.\n");
report_details(GlobalState.logfile);
}
}
else {
/* Unknown type. */
free_tags();
free_move_list(move_list);
}
move_list = NULL;
setup_for_new_game();
}
if(move_list != NULL) {
free_move_list(move_list);
}
}
/* Parse a game and return a pointer to any valid list of moves
* in returned_move_list.
*/
static Boolean
parse_game(Move **returned_move_list, unsigned long *start_line, unsigned long *end_line)
{ /* Boolean something_found = FALSE; */
CommentList *prefix_comment;
Move *move_list = NULL;
char *result;
/* There shouldn't be a hanging comment before the result,
* but there sometimes is.
*/
CommentList *hanging_comment;
/* Assume that we won't return anything. */
*returned_move_list = NULL;
/* Skip over any junk between games. */
current_symbol = skip_to_next_game(current_symbol);
prefix_comment = parse_opt_comment_list();
if (prefix_comment != NULL) {
/* Free this here, as it is hard to
* know whether it belongs to the game or the file.
* It is better to put game comments after the tags.
*/
/* something_found = TRUE; */
free_comment_list(prefix_comment);
prefix_comment = NULL;
}
*start_line = get_line_number();
if (parse_opt_tag_list()) {
/* something_found = TRUE; */
}
/* Some games have an initial NAG as a print-board indication.
* This is not legal PGN.
* Silently delete it/them.
*/
while (current_symbol == NAG) {
current_symbol = next_token();
}
/* @@@ Beware of comments and/or tags without moves. */
move_list = parse_move_list();
/* @@@ Look for a comment with no move text before the result. */
hanging_comment = parse_opt_comment_list();
/* Append this to the final move, if there is one. */
/* Look for a result, even if there were no moves. */
result = parse_result();
*end_line = get_line_number();
if (move_list != NULL) {
/* Find the last move. */
Move *last_move = move_list;
while (last_move->next != NULL) {
last_move = last_move->next;
}
if (hanging_comment != NULL) {
last_move->comment_list = append_comment(hanging_comment, last_move->comment_list);
}
if (result != NULL) {
/* Append it to the last move. */
last_move->terminating_result = result;
check_result(GameHeader.Tags, result);
*returned_move_list = move_list;
}
else {
fprintf(GlobalState.logfile, "Missing result.\n");
report_details(GlobalState.logfile);
}
/* something_found = TRUE; */
}
else {
/* @@@ Nothing to attach the comment to. */
(void) free((void *) hanging_comment);
hanging_comment = NULL;
/*
* Workaround for games with zero moves.
* Check the result for consistency with the tags, but then
* there is no move to attach it to.
* When outputting a game, the missing result in this case
* will have to be supplied from the tags.
*/
check_result(GameHeader.Tags, result);
if (result != NULL) {
(void) free((void *) result);
}
*returned_move_list = NULL;
}
return current_symbol != EOF_TOKEN;
}
Boolean
parse_opt_tag_list(void)
{
Boolean something_found = FALSE;
CommentList *prefix_comment;
while (parse_tag()) {
something_found = TRUE;
}
prefix_comment = parse_opt_comment_list();
if (prefix_comment != NULL) {
GameHeader.prefix_comment = prefix_comment;
something_found = TRUE;
}
return something_found;
}
/* Return TRUE if it looks like board contains an initial
* Chess 960 setup position. FALSE otherwise.
* Assessment requires that:
* + The move number be 1.
* + All castling rights are intact.
* + The two home ranks are full.
* + Identical pieces are opposite each other on the back rank.
* + At least one piece is out of its standard position.
*/
static Boolean
chess960_setup(Board *board)
{
if(board->move_number == 1 &&
board->WKingRank == '1' &&
board->BKingRank == '8' &&
board->WKingCol == board->BKingCol &&
(board->WKingCastle != '\0' &&
board->WQueenCastle != '\0' &&
board->BKingCastle != '\0' &&
board->BQueenCastle != '\0')) {
/* Check for a full set of pawns. */
Boolean probable = TRUE;
int white_r = RankConvert('2');
int black_r = RankConvert('7');
Piece white_pawn = MAKE_COLOURED_PIECE(WHITE, PAWN);
Piece black_pawn = MAKE_COLOURED_PIECE(BLACK, PAWN);
for(int c = ColConvert('a'); c <= ColConvert('h') && probable; c++) {
probable = board->board[white_r][c] == white_pawn &&
board->board[black_r][c] == black_pawn;
/* Make sure the back rank is full and identical pieces
* are opposite each other.
*/
if(probable) {
probable =
board->board[white_r-1][c] != EMPTY &&
EXTRACT_PIECE(board->board[white_r-1][c]) ==
EXTRACT_PIECE(board->board[black_r+1][c]);
}
}
if(probable) {
/* Check for at least one piece type being out of position. */
/* Only need to check one colour because we already know the
* pieces are identically paired.
*/
white_r = RankConvert('1');
probable =
board->board[white_r][ColConvert('a')] != W(ROOK) ||
board->board[white_r][ColConvert('b')] != W(KNIGHT) ||
board->board[white_r][ColConvert('c')] != W(BISHOP) ||
board->board[white_r][ColConvert('d')] != W(QUEEN) ||
board->board[white_r][ColConvert('e')] != W(KING) ||
board->board[white_r][ColConvert('f')] != W(BISHOP) ||
board->board[white_r][ColConvert('g')] != W(KNIGHT) ||
board->board[white_r][ColConvert('h')] != W(ROOK);
}
return probable;
}
else {
return FALSE;
}
}
Boolean
parse_tag(void)
{
Boolean TagFound = TRUE;
if (current_symbol == TAG) {
TagName tag_index = yylval.tag_index;
current_symbol = next_token();
if (current_symbol == STRING) {
char *tag_string = yylval.token_string;
if (tag_index < GameHeader.header_tags_length) {
GameHeader.Tags[tag_index] = tag_string;
}
else {
print_error_context(GlobalState.logfile);
fprintf(GlobalState.logfile,
"Internal error: Illegal tag index %d for %s\n",
tag_index, tag_string);
exit(1);
}
current_symbol = next_token();
}
else {
print_error_context(GlobalState.logfile);
fprintf(GlobalState.logfile, "Missing tag string.\n");
}
}
else if (current_symbol == STRING) {
print_error_context(GlobalState.logfile);
fprintf(GlobalState.logfile, "Missing tag for %s.\n", yylval.token_string);
(void) free((void *) yylval.token_string);
current_symbol = next_token();
}
else {
TagFound = FALSE;
}
return TagFound;
}
static Move *
parse_move_list(void)
{
Move *head = NULL, *tail = NULL;
head = parse_move_and_variants();
if (head != NULL) {
Move *next_move;
tail = head;
while ((next_move = parse_move_and_variants()) != NULL) {
tail->next = next_move;
tail = next_move;
}
}
return head;
}
static Move *
parse_move_and_variants(void)
{
Move *move_details;
move_details = parse_move();
if (move_details != NULL) {
CommentList *comment;
move_details->Variants = parse_opt_variant_list();
comment = parse_opt_comment_list();
if (comment != NULL) {
move_details->comment_list = append_comment(comment, move_details->comment_list);
}
}
return move_details;
}
static Move *
parse_move(void)
{
Move *move_details = NULL;
if (parse_opt_move_number()) {
}
/* @@@ Watch out for finding just the number. */
move_details = parse_move_unit();
if (move_details != NULL) {
parse_opt_NAG_list(move_details);
/* Any trailing comments will have been picked up
* and attached to the NAGs.
*/
}
return move_details;
}
static Move *
parse_move_unit(void)
{
Move *move_details = NULL;
if (current_symbol == MOVE) {
move_details = yylval.move_details;
if (move_details->class == NULL_MOVE && RAV_level == 0) {
if(!GlobalState.allow_null_moves) {
print_error_context(GlobalState.logfile);
fprintf(GlobalState.logfile, "Null moves (--) only allowed in variations.\n");
}
}
current_symbol = next_token();
if (current_symbol == CHECK_SYMBOL) {
strcat((char *) move_details->move, "+");
current_symbol = next_token();
/* Sometimes + is followed by #, so cover this case. */
if (current_symbol == CHECK_SYMBOL) {
current_symbol = next_token();
}
}
move_details->comment_list = parse_opt_comment_list();
}
return move_details;
}
static CommentList *
parse_opt_comment_list(void)
{
CommentList *head = NULL, *tail = NULL;
while (current_symbol == COMMENT) {
if (head == NULL) {
head = tail = yylval.comment;
}
else {
tail->next = yylval.comment;
tail = tail->next;
}
current_symbol = next_token();
}
return head;
}
Boolean
parse_opt_move_number(void)
{
Boolean something_found = FALSE;
if (current_symbol == MOVE_NUMBER) {
current_symbol = next_token();
something_found = TRUE;
}
return something_found;
}
/**
* Parse 0 or more NAGs, optionally followed by 0 or more comments.
* @param move_details
*/
static void
parse_opt_NAG_list(Move *move_details)
{
while (current_symbol == NAG) {
Nag *details = (Nag *) malloc_or_die(sizeof(*details));
details->text = NULL;
details->comments = NULL;
details->next = NULL;
do {
details->text = save_string_list_item(details->text, yylval.token_string);
current_symbol = next_token();
} while(current_symbol == NAG);
details->comments = parse_opt_comment_list();
if(move_details->NAGs == NULL) {
move_details->NAGs = details;
}
else {
Nag *nextNAG = move_details->NAGs;
while(nextNAG->next != NULL) {
nextNAG = nextNAG->next;
}
nextNAG->next = details;
}
}
}
static Variation *
parse_opt_variant_list(void)
{
Variation *head = NULL, *tail = NULL,
*variation;
while ((variation = parse_variant()) != NULL) {
if (head == NULL) {
head = tail = variation;
}
else {
tail->next = variation;
tail = variation;
}
}
return head;
}
static Variation *
parse_variant(void)
{
Variation *variation = NULL;
if (current_symbol == RAV_START) {
CommentList *prefix_comment;
CommentList *suffix_comment;
char *result = NULL;
Move *moves;
RAV_level++;
variation = (Variation *) malloc_or_die(sizeof (Variation));
current_symbol = next_token();
prefix_comment = parse_opt_comment_list();
moves = parse_move_list();
if (moves == NULL) {
print_error_context(GlobalState.logfile);
fprintf(GlobalState.logfile, "Missing move list in variation.\n");
}
else if(GlobalState.lichess_comment_fix && prefix_comment != NULL) {
/* lichess study deletes the prefix comment, so
* move it after the first move of the variation.
*/
moves->comment_list = merge_comment_lists(prefix_comment, moves->comment_list);
prefix_comment = NULL;
}
result = parse_result();
if ((result != NULL) && (moves != NULL)) {
/* Find the last move, to which to append the terminating
* result.
*/
Move *last_move = moves;
CommentList *trailing_comment;
while (last_move->next != NULL) {
last_move = last_move->next;
}
last_move->terminating_result = result;
/* Accept a comment after the result, but it will
* be printed out preceding the result.
*/
trailing_comment = parse_opt_comment_list();
if (trailing_comment != NULL) {
last_move->comment_list = append_comment(trailing_comment, last_move->comment_list);
}
}
else {
/* Ok. */
}
if (current_symbol == RAV_END) {
RAV_level--;
current_symbol = next_token();
}
else {
fprintf(GlobalState.logfile, "Missing ')' to close variation.\n");
print_error_context(GlobalState.logfile);
}
suffix_comment = parse_opt_comment_list();
variation->prefix_comment = prefix_comment;
variation->suffix_comment = suffix_comment;
variation->moves = moves;
variation->next = NULL;
}
return variation;
}
static char *
parse_result(void)
{
char *result = NULL;
if (current_symbol == TERMINATING_RESULT) {
result = yylval.token_string;
if (RAV_level == 0) {
/* In the interests of skipping any intervening material
* between games, set the lookahead to a dummy token.
*/
current_symbol = NO_TOKEN;
}
else {
current_symbol = next_token();
}
}
return result;
}
static void
setup_for_new_game(void)
{
restart_lex_for_new_game();
RAV_level = 0;
}
/* Discard any data held in the GameHeader.Tags structure. */
static void
free_tags(void)
{
unsigned tag;
for (tag = 0; tag < GameHeader.header_tags_length; tag++) {
if (GameHeader.Tags[tag] != NULL) {
free(GameHeader.Tags[tag]);
GameHeader.Tags[tag] = NULL;
}
}
}
/* Discard data from a gathered game. */
void
free_string_list(StringList *list)
{
StringList *next;
while (list != NULL) {
next = list;
list = list->next;
if (next->str != NULL) {
(void) free((void *) next->str);
}
(void) free((void *) next);
}
}
void
free_comment_list(CommentList *comment_list)
{
while (comment_list != NULL) {
CommentList *this_comment = comment_list;
if (comment_list->comment != NULL) {
free_string_list(comment_list->comment);
}
comment_list = comment_list->next;
(void) free((void *) this_comment);
}
}
static void
free_variation(Variation *variation)
{
Variation *next;
while (variation != NULL) {
next = variation;
variation = variation->next;
if (next->prefix_comment != NULL) {
free_comment_list(next->prefix_comment);
}
if (next->suffix_comment != NULL) {
free_comment_list(next->suffix_comment);
}
if (next->moves != NULL) {
(void) free_move_list(next->moves);
}
(void) free((void *) next);
}
}
static void free_NAG_list(Nag *nag_list)
{
while(nag_list != NULL) {
Nag *nextNAG = nag_list->next;
free_string_list(nag_list->text);
free_comment_list(nag_list->comments);
(void) free((void *) nag_list);
nag_list = nextNAG;
}
}
void
free_move_list(Move *move_list)
{
Move *nextMove;
while (move_list != NULL) {
nextMove = move_list;
move_list = move_list->next;
free_NAG_list(nextMove->NAGs);
free_comment_list(nextMove->comment_list);
free_variation(nextMove->Variants);
if (nextMove->epd != NULL) {
(void) free((void *) nextMove->epd);
}
if(nextMove->fen_suffix != NULL) {
(void) free((void *) nextMove->fen_suffix);
nextMove->fen_suffix = NULL;
}
if (nextMove->terminating_result != NULL) {
(void) free((void *) nextMove->terminating_result);
}
(void) free((void *) nextMove);
}
}
/* Add str onto the tail of list and
* return the head of the resulting list.
*/
StringList *
save_string_list_item(StringList *list, const char *str)
{
if (str != NULL && *str != '\0') {
StringList *new_item;
new_item = (StringList *) malloc_or_die(sizeof (*new_item));
new_item->str = str;
new_item->next = NULL;
if (list == NULL) {
list = new_item;
}
else {
StringList *tail = list;
while (tail->next != NULL) {
tail = tail->next;
}
tail->next = new_item;
}
}
#if 1
/* This is almost certainly correct to avoid losing
* two bytes with malloc'd empty strings.
* No problems with valgrind but just being
* cautious.
*/
else if(str != NULL) {
(void) free((void *) str);
}
#endif
return list;
}
/* Append any comments in Comment onto the end of
* any associated with move.
*/
void
append_comments_to_move(Move *move, CommentList *comment)
{
if (comment != NULL) {
move->comment_list = append_comment(comment, move->comment_list);
}
}
/* Add item to the end of list.
* If list is empty, return item.
*/
static CommentList *append_comment(CommentList *item, CommentList *list)
{
if (list == NULL) {
return item;
}
else {
CommentList *tail = list;
while (tail->next != NULL) {
tail = tail->next;
}
tail->next = item;
return list;
}
}
/* Add the suffix list (if any) to the end of the prefix list.
*/
static CommentList *merge_comment_lists(CommentList *prefix, CommentList *suffix)
{
if(prefix == NULL) {
return suffix;
}
else if(suffix != NULL) {
CommentList *tail = prefix;
while(tail->next != NULL) {
tail = tail->next;
}
tail->next = suffix;
}
return prefix;
}
/* Check for consistency of any FEN-related tags. */
static Boolean consistent_FEN_tags(Game *current_game)
{
Boolean consistent = TRUE;
if ((current_game->tags[SETUP_TAG] != NULL) &&
(strcmp(current_game->tags[SETUP_TAG], "1") == 0)) {
/* There must be a FEN_TAG to go with it. */
if (current_game->tags[FEN_TAG] == NULL) {
consistent = FALSE;
report_details(GlobalState.logfile);
fprintf(GlobalState.logfile,
"Missing %s Tag to accompany %s Tag.\n",
tag_header_string(FEN_TAG),
tag_header_string(SETUP_TAG));
print_error_context(GlobalState.logfile);
}
}
if(current_game->tags[FEN_TAG] != NULL) {
Board *board = new_fen_board(current_game->tags[FEN_TAG]);
if(board != NULL) {
/* There must be a SETUP_TAG to go with it. */
if(current_game->tags[SETUP_TAG] == NULL) {
// This is such a common problem that it makes
// more sense just to silently correct it.
#if 0
report_details(GlobalState.logfile);
fprintf(GlobalState.logfile,
"Missing %s Tag to accompany %s Tag.\n",
tag_header_string(SETUP_TAG),
tag_header_string(FEN_TAG));
print_error_context(GlobalState.logfile);
#endif
/* Fix the inconsistency. */
current_game->tags[SETUP_TAG] = copy_string("1");
}
Boolean chess960 = chess960_setup(board);
if(current_game->tags[VARIANT_TAG] == NULL) {
/* See if there should be a Variant tag. */
/* Look for an initial position found in Chess 960. */
if(chess960) {
const char *missing_value = "chess 960";
report_details(GlobalState.logfile);
fprintf(GlobalState.logfile,
"Missing %s Tag for non-standard setup; adding %s.\n",
tag_header_string(VARIANT_TAG),
missing_value);
/* Fix the inconsistency. */
current_game->tags[VARIANT_TAG] = copy_string(missing_value);
}
else if(GlobalState.add_fen_castling) {
/* If add_fen_castling is TRUE and castling permissions are absent
* then liberally assume them based on the King and Rook positions.
*/
if(!board->WKingCastle && !board->WQueenCastle &&
!board->BKingCastle && !board->BQueenCastle) {
add_fen_castling(current_game, board);
}
}
}
else if(chess960) {
/* @@@ Should really make sure the Variant tag is appropriate. */
}
free_board(board);
}
else {
consistent = FALSE;
}
}
return consistent;
}
static void
deal_with_game(Move *move_list, unsigned long start_line, unsigned long end_line)
{
Game current_game;
/* We need a dummy argument for apply_move_list. */
unsigned plycount;
/* Whether the game matches, as long as it is not in a CHECKFILE. */
Boolean game_matches = FALSE;
/* Whether to output the game. */
Boolean output_the_game = FALSE;
if (GlobalState.current_file_type != CHECKFILE) {
/* Update the count of how many games handled. */
GlobalState.num_games_processed++;
}
/* Fill in the information currently known. */
current_game.tags = GameHeader.Tags;
current_game.tags_length = GameHeader.header_tags_length;
current_game.prefix_comment = GameHeader.prefix_comment;
current_game.moves = move_list;
current_game.moves_checked = FALSE;
current_game.moves_ok = FALSE;
current_game.error_ply = 0;
current_game.position_counts = NULL;
current_game.start_line = start_line;
current_game.end_line = end_line;
/* Determine whether or not this game is wanted, on the
* basis of the various selection criteria available.
*/
/*
* apply_move_list checks out the moves.
* If it returns TRUE as a match, it will also fill in the
* current_game.final_hash_value and
* current_game.cumulative_hash_value
* fields of current_game so that these can be used in the
* previous_occurrence function.
*
* If there are any tag criteria, it will be easy to quickly
* eliminate most games without going through the lengthy
* process of game matching.
*
* If ECO adding is done, the order of checking may cause
* a conflict here since it won't be possible to reject a game
* based on its ECO code unless it already has one.
* Therefore, check for the ECO tag only after everything else has
* been checked.
*/
if (consistent_FEN_tags(&current_game) &&
check_tag_details_not_ECO(current_game.tags, current_game.tags_length) &&
check_setup_tag(current_game.tags) &&
check_duplicate_setup(&current_game) &&
apply_move_list(&current_game, &plycount, GlobalState.depth_of_positional_search) &&
check_move_bounds(plycount) &&
check_textual_variations(&current_game) &&
check_for_material_match(&current_game) &&
check_for_only_checkmate(&current_game) &&
check_for_only_repetition(current_game.position_counts) &&
check_ECO_tag(current_game.tags)) {
/* If there is no original filename then the game is not a
* duplicate.
*/
const char *original_filename = previous_occurance(current_game, plycount);
if ((original_filename == NULL) && GlobalState.suppress_originals) {
/* Don't output first occurrences. */
}
else if ((original_filename == NULL) || !GlobalState.suppress_duplicates) {
if (GlobalState.current_file_type == CHECKFILE) {
/* We are only checking, so don't count this as a matched game. */
}
else if(GlobalState.num_games_processed >= GlobalState.first_game_number) {
game_matches = TRUE;
GlobalState.num_games_matched++;
if (GlobalState.matching_game_numbers != NULL &&
!in_game_number_range(GlobalState.num_games_matched, GlobalState.next_game_number_to_output)) {
/* This is not the right matching game to be output. */
}
else if (GlobalState.skip_game_numbers != NULL &&
in_game_number_range(GlobalState.num_games_matched, GlobalState.next_game_number_to_skip)) {
/* Skip this matching game. */
if(GlobalState.num_games_matched == GlobalState.next_game_number_to_skip->max) {
GlobalState.next_game_number_to_skip = GlobalState.next_game_number_to_skip->next;
}
}
else if (GlobalState.check_only) {
/* We are only checking. */
if (GlobalState.verbosity > 1) {
/* Report progress on logfile. */
report_details(GlobalState.logfile);
}
}
else {
output_the_game = TRUE;
}
}
else {
/* Not wanted. */
}
if(output_the_game) {
/* This game is to be kept and output. */
FILE *outputfile = select_output_file(&GlobalState,
current_game.tags[ECO_TAG]);
/* See if we wish to separate out duplicates. */
if ((original_filename != NULL) &&
(GlobalState.duplicate_file != NULL)) {
static const char *last_input_file = NULL;
outputfile = GlobalState.duplicate_file;
if ((last_input_file != GlobalState.current_input_file) &&
(GlobalState.current_input_file != NULL)) {
if(GlobalState.keep_comments) {
/* Record which file this and succeeding
* duplicates come from.
*/
print_str(outputfile, "{ From: ");
print_str(outputfile,
GlobalState.current_input_file);
print_str(outputfile, " }");
terminate_line(outputfile);
}
last_input_file = GlobalState.current_input_file;
}
if(GlobalState.keep_comments) {
print_str(outputfile, "{ First found in: ");
print_str(outputfile, original_filename);
print_str(outputfile, " }");
terminate_line(outputfile);
}
}
/* Now output what we have. */
output_game(&current_game, outputfile);
if (GlobalState.verbosity > 1) {
/* Report progress on logfile. */
report_details(GlobalState.logfile);
}
}
}
}
if (!game_matches && (GlobalState.non_matching_file != NULL) &&
GlobalState.current_file_type != CHECKFILE) {
/* The user wants to keep everything else. */
if (!current_game.moves_checked) {
/* Make sure that the move text is in a reasonable state.
* Force checking of the whole game.
*/
(void) apply_move_list(&current_game, &plycount, 0);
}
if (current_game.moves_ok || GlobalState.keep_broken_games) {
output_game(&current_game, GlobalState.non_matching_file);
}
}
if (game_matches && GlobalState.matching_game_numbers != NULL &&
in_game_number_range(GlobalState.num_games_matched,
GlobalState.next_game_number_to_output)) {
if(GlobalState.num_games_matched == GlobalState.next_game_number_to_output->max) {
GlobalState.next_game_number_to_output = GlobalState.next_game_number_to_output->next;
}
}
/* Game is finished with, so free everything. */
if (GameHeader.prefix_comment != NULL) {
free_comment_list(GameHeader.prefix_comment);
}
/* Ensure that the GameHeader's prefix comment is NULL for
* the next game.
*/
GameHeader.prefix_comment = NULL;
free_tags();
free_move_list(current_game.moves);
if (current_game.position_counts != NULL) {
free_position_count_list(current_game.position_counts);
current_game.position_counts = NULL;
}
if (GlobalState.verbosity != 0 && (GlobalState.num_games_processed % PROGRESS_RATE) == 0) {
fprintf(stderr, "Games: %lu\r", GlobalState.num_games_processed);
}
}
/*
* Output the given game to the output file.
* If GlobalState.split_variants then this will involve outputting
* each variation separately.
*/
static void
output_game(Game *game, FILE *outputfile)
{
if(GlobalState.split_variants && GlobalState.keep_variations) {
split_variants(game, outputfile, 0);
}
else {
format_game(game, outputfile);
}
}
/*
* Output each variation separately, to the required depth.
* NB: This involves the removal of all variations from the game.
* This is done recursively and depth (>=0) defines the current
* level of recursion.
*/
static void
split_variants(Game *game, FILE *outputfile, unsigned depth)
{
/* Gather all the suffix comments at this level. */
Move *move = game->moves;
while(move != NULL) {
Variation *variants = move->Variants;
while (variants != NULL) {
if(variants->suffix_comment != NULL) {
move->comment_list = append_comment(variants->suffix_comment, move->comment_list);
variants->suffix_comment = NULL;
}
variants = variants->next;
}
move = move->next;
}
/* Format the main line at this level. */
format_game(game, outputfile);
if(GlobalState.split_depth_limit == 0 ||
GlobalState.split_depth_limit > depth) {
/* Now all the variations. */
char *result_tag = game->tags[RESULT_TAG];
game->tags[RESULT_TAG] = copy_string("*");
move = game->moves;
Move *prev = NULL;
while(move != NULL) {
Variation *variants = move->Variants;
while (variants != NULL) {
Variation *next_variant = variants->next;
Move *variant_moves = variants->moves;
if(variant_moves != NULL) {
/* Supply a result if it is missing. */
Move *last_move = variant_moves;
while(last_move->next != NULL) {
last_move = last_move->next;
}
if(last_move->terminating_result == NULL) {
last_move->terminating_result = copy_string("*");
}
/* Replace the main line with the variants. */
if(prev != NULL) {
prev->next = variant_moves;
}
else {
game->moves = variant_moves;
}
/* Detach following variations. */
variants->next = NULL;
CommentList *prefix_comment = variants->prefix_comment;
if(prefix_comment != NULL) {
if(prev != NULL) {
prev->comment_list = append_comment(prefix_comment, prev->comment_list);
}
else {
game->prefix_comment = append_comment(prefix_comment,
game->prefix_comment);
}
}
split_variants(game, outputfile, depth+1);
if(prefix_comment != NULL) {
/* Remove the appended comments. */
CommentList *list;
if(prev != NULL) {
list = prev->comment_list;
}
else {
list = game->prefix_comment;
}
if(list == prefix_comment) {
if(prev != NULL) {
prev->comment_list = NULL;
}
else {
game->prefix_comment = NULL;
}
}
else {
while(list->next != prefix_comment && list->next != NULL) {
list = list->next;
}
list->next = NULL;
}
}
variants->next = next_variant;
}
variants = next_variant;
}
if(move->Variants != NULL) {
/* The variation can now be disposed of. */
free_variation(move->Variants);
move->Variants = NULL;
/* Restore the move replaced by its variants. */
if(prev != NULL) {
prev->next = move;
}
else {
game->moves = move;
}
}
prev = move;
move = move->next;
}
/* Put everything back as it was. */
(void) free((void *) game->tags[RESULT_TAG]);
game->tags[RESULT_TAG] = result_tag;
}
}
static void
deal_with_ECO_line(Move *move_list)
{
Game current_game;
/* We need to know the length of a game to store with the
* hash information as a sanity check.
*/
unsigned number_of_half_moves;
/* Fill in the information currently known. */
current_game.tags = GameHeader.Tags;
current_game.tags_length = GameHeader.header_tags_length;
current_game.prefix_comment = GameHeader.prefix_comment;
current_game.moves = move_list;
current_game.moves_checked = FALSE;
current_game.moves_ok = FALSE;
current_game.error_ply = 0;
/* apply_eco_move_list checks out the moves.
* It will also fill in the
* current_game.final_hash_value and
* current_game.cumulative_hash_value
* fields of current_game.
*/
Board *final_position = apply_eco_move_list(&current_game, &number_of_half_moves);
if(final_position != NULL) {
/* Store the ECO code in the appropriate hash location. */
save_eco_details(&current_game, final_position, number_of_half_moves);
}
/* Game is finished with, so free everything. */
if (GameHeader.prefix_comment != NULL) {
free_comment_list(GameHeader.prefix_comment);
}
/* Ensure that the GameHeader's prefix comment is NULL for
* the next game.
*/
GameHeader.prefix_comment = NULL;
free_tags();
free_move_list(current_game.moves);
}
/* If file_type == ECOFILE we are dealing with a file of ECO
* input rather than a normal game file.
*/
int
yyparse(SourceFileType file_type)
{
setup_for_new_game();
current_symbol = skip_to_next_game(NO_TOKEN);
parse_opt_game_list(file_type);
if (current_symbol == EOF_TOKEN) {
/* Ok -- EOF. */
return 0;
}
else if (finished_processing()) {
/* Ok -- done all we need to. */
return 0;
}
else {
fprintf(GlobalState.logfile, "End of input reached before end of file.\n");
return 1;
}
}
Reference in New Issue View Git Blame Copy Permalink