Subversion Repositories Games.Chess Giants

Rev

Rev 69 | Rev 72 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. // pgnfile.cpp
  2.  
  3. #include "common.h"
  4.  
  5.  
  6. // handy definitions
  7. #define COPY_TIL_LAST_QUOTEMARK(dest,source) \
  8. { \
  9.    mbstowcs_s (&converted_count, (dest), WCHAR_SIZEOF (dest), (source), WCHAR_SIZEOF (dest)); \
  10.    for (char_index = wcslen (dest) - 1; char_index >= 0; char_index--) \
  11.       if ((dest)[char_index] == L'"') \
  12.       { \
  13.          (dest)[char_index] = 0; \
  14.          break; \
  15.       } \
  16. }
  17.  
  18.  
  19. // global variables used in this module only
  20. static char *pgnfile_data = NULL; // mallocated
  21. static size_t pgnfile_size = 0;
  22.  
  23.  
  24. // prototypes of local functions
  25. static void PGNFile_GameList_Init (int entry_count);
  26. static void PGNFile_GameList_Shutdown (void);
  27. static wchar_t *PGNFile_NAGTextFromCode (int nag_code);
  28. static char *sgets (char *destination_line, int max_length, char *source_buffer);
  29.  
  30.  
  31. bool PGNFile_Load (const wchar_t *pgnfile_pathname)
  32. {
  33.    // this function loads a PGN file and builds the game databases of the games described in this file
  34.  
  35.    char line_buffer[256]; // PGN files have 256 chars max per line by design
  36.    char *buffer;
  37.    char *ptr;
  38.    int file_index;
  39.    int char_index;
  40.    int entry_count;
  41.    FILE *fp;
  42.    size_t converted_count; // used by the STRING_TO_CHAR macro
  43.  
  44.    // try to open file for reading in BINARY mode so as NOT to convert end of lines
  45.    _wfopen_s (&fp, pgnfile_pathname, L"rb");
  46.    if (fp == NULL)
  47.       return (false); // on error, cancel
  48.  
  49.    // get file length
  50.    fseek (fp, 0, SEEK_END);
  51.    pgnfile_size = ftell (fp);
  52.    fseek (fp, 0, SEEK_SET);
  53.  
  54.    // mallocate space for it and read it all at once
  55.    pgnfile_data = (char *) SAFE_realloc (pgnfile_data, 0, pgnfile_size, sizeof (char), false);
  56.    fread (pgnfile_data, pgnfile_size, 1, fp);
  57.    fclose (fp); // we no longer need the file, so close it
  58.  
  59.    // now the file is fully loaded in memory
  60.  
  61.    // read line per line and count the number of games
  62.    buffer = pgnfile_data;
  63.    entry_count = 0;
  64.    while ((buffer = sgets (line_buffer, sizeof (line_buffer), buffer)) != NULL)
  65.       if (strncmp (line_buffer, "[Event \"", 8) == 0)
  66.          entry_count++; // we know now one game more
  67.  
  68.    // now prepare the games database for "entry_count" games
  69.    PGNFile_GameList_Init (entry_count);
  70.  
  71.    // read line per line
  72.    buffer = pgnfile_data;
  73.    entry_count = 0;
  74.    file_index = 0;
  75.    while ((buffer = sgets (line_buffer, sizeof (line_buffer), buffer)) != NULL)
  76.    {
  77.       // is it a new game ?
  78.       if (strncmp (line_buffer, "[Event \"", 8) == 0)
  79.       {
  80.          COPY_TIL_LAST_QUOTEMARK (games[entry_count].event_str, &line_buffer[8]); // copy event
  81.  
  82.          // assume a default "standard chess" start position unless told otherwise later
  83.          wcscpy_s (games[entry_count].fen_str, WCHAR_SIZEOF (games[entry_count].fen_str), FENSTARTUP_STANDARDCHESS);
  84.  
  85.          games[entry_count].gamedata_start = 0; // reset gamedata so far
  86.          entry_count++; // we know now one game more
  87.       }
  88.  
  89.       // else have we found a game already ?
  90.       else if (entry_count > 0)
  91.       {
  92.          // is it a tag ? (i.e: line BEGINS with a opening bracket and the first closing bracket ENDS it)
  93.          if ((line_buffer[0] == '[') && (ptr = strchr (line_buffer, ']')) && ((ptr[1] == '\r') || (ptr[1] == 0)))
  94.          {
  95.             if (strncmp (&line_buffer[1], "Site \"", 6) == 0)
  96.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].site_str, &line_buffer[7]) // copy site
  97.             else if (strncmp (&line_buffer[1], "Date \"", 6) == 0)
  98.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].date_str, &line_buffer[7]) // copy date
  99.             else if (strncmp (&line_buffer[1], "Round \"", 7) == 0)
  100.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].round_str, &line_buffer[8]) // copy round
  101.             else if (strncmp (&line_buffer[1], "White \"", 7) == 0)
  102.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].white_str, &line_buffer[8]) // copy white
  103.             else if (strncmp (&line_buffer[1], "Black \"", 7) == 0)
  104.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].black_str, &line_buffer[8]) // copy black
  105.             else if (strncmp (&line_buffer[1], "Result \"", 8) == 0)
  106.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].result_str, &line_buffer[9]) // copy results
  107.             else if (strncmp (&line_buffer[1], "ECO \"", 5) == 0)
  108.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].eco_str, &line_buffer[6]) // copy ECO code
  109.             else if (strncmp (&line_buffer[1], "FEN \"", 5) == 0)
  110.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].fen_str, &line_buffer[6]) // copy FEN string
  111.          }
  112.  
  113.          // else is it the beginning of a game ?
  114.          else if (strncmp (line_buffer, "1.", 2) == 0)
  115.             games[entry_count - 1].gamedata_start = file_index; // remember where this game starts
  116.       }
  117.  
  118.       file_index = buffer - pgnfile_data; // save current file pointer index
  119.    }
  120.  
  121.    return (true); // finished, return TRUE
  122. }
  123.  
  124.  
  125. bool PGNFile_LoadGame (board_t *board, const wchar_t *pgnfile_pathname, pgngame_t *game)
  126. {
  127.    // this function loads and parses a game data in a PGN file. If the selected game is NULL, it means that
  128.    // the user didn't want to chose any game at all, so just free the games list and return a success value.
  129.  
  130.    static wchar_t pgn_comment[65536]; // declared static so as not to reallocate it
  131.  
  132.    boardmove_t new_move;
  133.    int nag_code;
  134.    int length;
  135.    int char_index;
  136.    int fieldstart;
  137.    int fieldstop;
  138.    int variation_depth;
  139.    char movenumber_string[8];
  140.  
  141.    // did we chose NO game ?
  142.    if (game == NULL)
  143.    {
  144.       PGNFile_GameList_Shutdown (); // free the games list
  145.       SAFE_free ((void **) &pgnfile_data); // free the file data space
  146.       return (true); // return success as there's nothing to load
  147.    }
  148.  
  149.    // reset the board (but NOT the players, just their view angles)
  150.    Board_Reset (board, game->fen_str);
  151.    animation_endtime = current_time + 2.0f; // HACK: this sorta prevents the "load file" dialog box trailing clicks to be misinterpreted
  152.  
  153.    // while we've not parsed til the end of game...
  154.    char_index = game->gamedata_start;
  155.    new_move.source[0] = -1;
  156.    new_move.source[1] = -1;
  157.    new_move.target[0] = -1;
  158.    new_move.target[1] = -1;
  159.    new_move.promotion_type = 0;
  160.    pgn_comment[0] = 0;
  161.    for (;;)
  162.    {
  163.       // build the move number string
  164.       sprintf_s (movenumber_string, sizeof (movenumber_string), "%d.", 1 + board->move_count / 2);
  165.  
  166.       // is it a space ?
  167.       if (isspace (pgnfile_data[char_index]))
  168.       {
  169.          char_index++; // if so, skip it
  170.          continue; // and proceed to the next data
  171.       }
  172.  
  173.       // else is what we're reading a move number ?
  174.       else if (strncmp (&pgnfile_data[char_index], movenumber_string, strlen (movenumber_string)) == 0)
  175.       {
  176.          char_index += strlen (movenumber_string); // if so, skip it
  177.          continue; // and proceed to the next data
  178.       }
  179.  
  180.       // else is it a dot ?
  181.       else if (pgnfile_data[char_index] == '.')
  182.       {
  183.          char_index++; // if so, skip it
  184.          continue; // and proceed to the next data
  185.       }
  186.  
  187.       // else is it an en passant notification ?
  188.       else if (strncmp (&pgnfile_data[char_index], "e.p.", 4) == 0)
  189.       {
  190.          char_index += 4; // this notification is superfluous, skip it
  191.          continue; // and proceed to the next data
  192.       }
  193.  
  194.       // else is it a comment ?
  195.       else if (pgnfile_data[char_index] == '{')
  196.       {
  197.          fieldstart = char_index + 1; // skip the leading brace
  198.  
  199.          while ((fieldstart < (int) pgnfile_size) && isspace (pgnfile_data[fieldstart]))
  200.             fieldstart++; // skip any leading spaces
  201.  
  202.          // move through all the other characters...
  203.          for (fieldstop = fieldstart; fieldstop < (int) pgnfile_size; fieldstop++)
  204.             if (pgnfile_data[fieldstop] == '}')
  205.                break; // and stop at the first closing brace we find
  206.  
  207.          char_index = fieldstop + 1; // remember where to continue reading (that is, after the closing brace)
  208.  
  209.          while ((fieldstop > 0) && isspace (pgnfile_data[fieldstop]))
  210.             fieldstop--; // chop off any trailing spaces
  211.  
  212.          pgnfile_data[fieldstop] = 0; // break the string at this location
  213.  
  214.          // now copy out the commentary by appending it to the one we know already
  215.          if (pgn_comment[0] != 0)
  216.             wcscat_s (pgn_comment, WCHAR_SIZEOF (pgn_comment), L" ");
  217.          length = wcslen (pgn_comment);
  218.          ConvertToWideChar (&pgn_comment[length], WCHAR_SIZEOF (pgn_comment) - length, &pgnfile_data[fieldstart]);
  219.          ConvertCRLFsToSingleSpaces (pgn_comment); // linearize string
  220.  
  221.          continue; // and proceed to the next data
  222.       }
  223.  
  224.       // else is it a numeric annotation glyph ?
  225.       else if (pgnfile_data[char_index] == '$')
  226.       {
  227.          nag_code = atoi (&pgnfile_data[char_index + 1]); // read it
  228.  
  229.          // now copy out as a comment
  230.          if (pgn_comment[0] != 0)
  231.             wcscat_s (pgn_comment, WCHAR_SIZEOF (pgn_comment), L" ");
  232.          length = wcslen (pgn_comment);
  233.          swprintf_s (&pgn_comment[length], WCHAR_SIZEOF (pgn_comment) - length, L"[NAG: %s]", PGNFile_NAGTextFromCode (nag_code));
  234.  
  235.          while ((char_index < (int) pgnfile_size) && !isspace (pgnfile_data[char_index]))
  236.             char_index++; // figure out where it stops
  237.          while ((char_index < (int) pgnfile_size) && isspace (pgnfile_data[char_index]))
  238.             char_index++; // figure out where the next word starts
  239.  
  240.          continue; // and proceed to the next data
  241.       }
  242.  
  243.       // else is it a variation ? if so, just ignore it (FIXME: better support this)
  244.       else if (pgnfile_data[char_index] == '(')
  245.       {
  246.          variation_depth = 1;
  247.          while ((char_index < (int) pgnfile_size) && (variation_depth != 0))
  248.          {
  249.             char_index++; // move through file data and cope with nested variations
  250.             if      (pgnfile_data[char_index] == '(') variation_depth++;
  251.             else if (pgnfile_data[char_index] == ')') variation_depth--;
  252.          }
  253.          char_index++; // skip the closing parenthese
  254.          while ((char_index < (int) pgnfile_size) && isspace (pgnfile_data[char_index]))
  255.             char_index++; // figure out where the next word starts
  256.  
  257.          continue; // and proceed to the next data
  258.       }
  259.  
  260.       // else is it a game result ?
  261.       else if ((strncmp (&pgnfile_data[char_index], "1/2-1/2", 7) == 0)
  262.                || (strncmp (&pgnfile_data[char_index], "1-0", 3) == 0)
  263.                || (strncmp (&pgnfile_data[char_index], "0-1", 3) == 0)
  264.                || (pgnfile_data[char_index] == '*'))
  265.       {
  266.          // if there's a move pending, validate it
  267.          if ((new_move.source[0] != -1) && (new_move.source[1] != -1) && (new_move.target[0] != -1) && (new_move.target[1] != -1))
  268.          {
  269.             Board_AppendMove (board, new_move.source[0], new_move.source[1], new_move.target[0], new_move.target[1], new_move.promotion_type, pgn_comment); // save move
  270.             board->has_playerchanged = true; // switch players
  271.             new_move.part = PART_NONE;
  272.             new_move.source[0] = -1;
  273.             new_move.source[1] = -1;
  274.             new_move.target[0] = -1;
  275.             new_move.target[1] = -1;
  276.             new_move.promotion_type = 0;
  277.             pgn_comment[0] = 0; // reset comment
  278.          }
  279.  
  280.          break; // we've finished reading the game
  281.       }
  282.  
  283.       // else it must be a move data
  284.       else
  285.       {
  286.          // if there's a move pending, validate it
  287.          if ((new_move.source[0] != -1) && (new_move.source[1] != -1) && (new_move.target[0] != -1) && (new_move.target[1] != -1))
  288.          {
  289.             Board_AppendMove (board, new_move.source[0], new_move.source[1], new_move.target[0], new_move.target[1], new_move.promotion_type, pgn_comment); // save move
  290.             board->has_playerchanged = true; // switch players
  291.             new_move.part = PART_NONE;
  292.             new_move.source[0] = -1;
  293.             new_move.source[1] = -1;
  294.             new_move.target[0] = -1;
  295.             new_move.target[1] = -1;
  296.             new_move.promotion_type = 0;
  297.             pgn_comment[0] = 0; // reset comment
  298.          }
  299.  
  300.          // convert the move string data to wide char
  301.          ConvertToWideChar (new_move.pgntext, WCHAR_SIZEOF (new_move.pgntext), &pgnfile_data[char_index]);
  302.  
  303.          // evaluate the string in Standard Algebraic Notation and find the source, destination, part type and promotion
  304.          if (!Move_SetupFromSAN (&board->moves[board->move_count - 1], &new_move, Board_ColorToMove (board)))
  305.          {
  306.             PGNFile_GameList_Shutdown (); // free the games list
  307.             SAFE_free ((void **) &pgnfile_data); // free the file data space
  308.             return (false); // on error, cancel
  309.          }
  310.  
  311.          // find where it stops
  312.          while ((char_index < (int) pgnfile_size) && !isspace (pgnfile_data[char_index]))
  313.             char_index++; // reach the next space
  314.  
  315.          char_index++; // remember where to continue reading (that is, after the next space)
  316.          continue; // and proceed to the next data
  317.       }
  318.    }
  319.  
  320.    // save the players' names
  321.    wcscpy_s (board->players[COLOR_WHITE].name, WCHAR_SIZEOF (board->players[COLOR_WHITE].name), game->white_str);
  322.    wcscpy_s (board->players[COLOR_BLACK].name, WCHAR_SIZEOF (board->players[COLOR_BLACK].name), game->black_str);
  323.  
  324.    // we loaded the game we want, we no longer need the games array
  325.    PGNFile_GameList_Shutdown ();
  326.  
  327.    // we no longer need the file data space, so free it
  328.    SAFE_free ((void **) &pgnfile_data);
  329.  
  330.    return (true); // game loaded successfully, return TRUE
  331. }
  332.  
  333.  
  334. bool PGNFile_Save (board_t *board, const wchar_t *pgnfile_pathname)
  335. {
  336.    // this function writes a PGN file in the standard, international Chess format
  337.  
  338.    FILE *fp;
  339.    wchar_t machine_name[256];
  340.    unsigned long buffer_size;
  341.    wchar_t result_string[16];
  342.    time_t rawtime;
  343.    struct tm timeinfo;
  344.    boardmove_t *move;
  345.    int move_index;
  346.    int char_index;
  347.    int length;
  348.    int count;
  349.    int consecutive_count;
  350.    bool needs_newline;
  351.  
  352.    // try to open file for writing
  353.    _wfopen_s (&fp, pgnfile_pathname, L"w");
  354.    if (fp == NULL)
  355.       return (false); // on error, cancel
  356.  
  357.    // get the machine name as an ASCII string
  358.    buffer_size = WCHAR_SIZEOF (machine_name);
  359.    GetComputerName (machine_name, &buffer_size);
  360.  
  361.    // get the current date and time
  362.    time (&rawtime);
  363.    localtime_s (&timeinfo, &rawtime);
  364.  
  365.    // build the result string
  366.    if ((board->game_state == STATE_WHITEWIN_CHECKMATE) || (board->game_state == STATE_WHITEWIN_RESIGNORFORFEIT))
  367.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"1-0"); // white won
  368.    else if ((board->game_state == STATE_BLACKWIN_CHECKMATE) || (board->game_state == STATE_BLACKWIN_RESIGNORFORFEIT))
  369.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"0-1"); // black won
  370.    else if ((board->game_state == STATE_DRAW_STALEMATE) || (board->game_state == STATE_DRAW_AGREEMENT) || (board->game_state == STATE_DRAW_OTHER))
  371.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"1/2-1/2"); // game is a draw
  372.    else
  373.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"*"); // game still in progress
  374.  
  375.    // write the mandatory header parts
  376.    fwprintf (fp, L"[Event \"Chess Giants game\"]\n");
  377.    fwprintf (fp, L"[Site \"%s\"]\n", machine_name);
  378.    fwprintf (fp, L"[Date \"%d.%02d.%02d\"]\n", 1900 + timeinfo.tm_year, 1 + timeinfo.tm_mon, timeinfo.tm_mday);
  379.    fwprintf (fp, L"[Round \"1\"]\n");
  380.    fwprintf (fp, L"[White \"%s\"]\n", board->players[COLOR_WHITE].name);
  381.    fwprintf (fp, L"[Black \"%s\"]\n", board->players[COLOR_BLACK].name);
  382.    fwprintf (fp, L"[Result \"%s\"]\n", result_string);
  383.    fwprintf (fp, L"[FEN \"%s\"]\n", board->moves[0].fen_string);
  384.    fwprintf (fp, L"\n");
  385.  
  386.    // now write the game
  387.    consecutive_count = 0;
  388.    for (move_index = 1; move_index < board->move_count; move_index++)
  389.    {
  390.       // every seven move pairs, drop a carriage return
  391.       if (consecutive_count == 14)
  392.       {
  393.          fwprintf (fp, L"\n"); // one blank line
  394.          consecutive_count = 0;
  395.       }
  396.  
  397.       move = &board->moves[move_index]; // quick access to move
  398.  
  399.       // white to move ?
  400.       if (move->color == COLOR_WHITE)
  401.          fwprintf (fp, L"%d.", (move_index + 1) / 2); // if so, display double-move number
  402.  
  403.       // dump move data
  404.       fwprintf (fp, L"%s ", move->pgntext);
  405.       consecutive_count++;
  406.  
  407.       // is there a comment for this move ?
  408.       if ((move->comment != NULL) && (move->comment[0] != 0))
  409.       {
  410.          fwprintf (fp, L"\n{\n"); // dump an open brace
  411.          length = wcslen (move->comment); // get comment length
  412.  
  413.          // for each character in comment text...
  414.          needs_newline = false;
  415.          count = 0;
  416.          for (char_index = 0; char_index < length; char_index++)
  417.          {
  418.             // is it a space and do we need a newline ?
  419.             if (iswspace (move->comment[char_index]) && needs_newline)
  420.             {
  421.                fputwc (L'\n', fp); // dump a newline
  422.                needs_newline = false; // we no longer need a newline
  423.                count = 0; // reset the number of characters written
  424.             }
  425.  
  426.             // else it's a character
  427.             else
  428.             {
  429.                fputwc (move->comment[char_index], fp); // dump it
  430.                count++; // we dumped one character more on this line
  431.                if (count > 80)
  432.                   needs_newline = true; // if we need a newline, remember it
  433.             }
  434.          }
  435.  
  436.          fwprintf (fp, L"\n}\n"); // dump an open brace
  437.          consecutive_count = 0;
  438.       }
  439.  
  440.       // if it's the last move, dump the game results
  441.       if (move_index == board->move_count - 1)
  442.          fwprintf (fp, result_string);
  443.    }
  444.  
  445.    fclose (fp); // finished, close the file
  446.  
  447.    return (true); // file saved successfully, return TRUE
  448. }
  449.  
  450.  
  451. static void PGNFile_GameList_Init (int entry_count)
  452. {
  453.    // helper function to initialize the game lists array pointer and the games count
  454.  
  455.    // allocate space for all the games in a row (it's faster than reallocating)
  456.    games = (pgngame_t *) SAFE_malloc (entry_count, sizeof (pgngame_t), true);
  457.    game_count = entry_count;
  458.  
  459.    return; // finished
  460. }
  461.  
  462.  
  463. static void PGNFile_GameList_Shutdown (void)
  464. {
  465.    // helper function to free the game lists array and reset the games count
  466.  
  467.    SAFE_free ((void **) &games); // free the PGN games array
  468.    game_count = 0;
  469.  
  470.    return; // finished
  471. }
  472.  
  473.  
  474. static wchar_t *PGNFile_NAGTextFromCode (int nag_code)
  475. {
  476.    // helper function that returns the NAG (numeric annotation glyph) text that corresponds to a particular code
  477.  
  478.    typedef struct nag_s
  479.    {
  480.       int code;
  481.       wchar_t *text;
  482.    } nag_t;
  483.    nag_t nag_codes[] =
  484.    {
  485.       { 1, L"good move" },
  486.       { 2, L"poor move or mistake" },
  487.       { 3, L"very good or brilliant move" },
  488.       { 4, L"very poor move or blunder" },
  489.       { 5, L"speculative or interesting move" },
  490.       { 6, L"questionable or dubious move" },
  491.       { 7, L"forced move (all others lose quickly) or only move" },
  492.       { 8, L"singular move (no reasonable alternatives)" },
  493.       { 9, L"worst move" },
  494.       { 10, L"drawish position or even" },
  495.       { 11, L"equal chances, quiet position" },
  496.       { 12, L"equal chances, active position" },
  497.       { 13, L"unclear position" },
  498.       { 14, L"White has a slight advantage" },
  499.       { 15, L"Black has a slight advantage" },
  500.       { 16, L"White has a moderate advantage" },
  501.       { 17, L"Black has a moderate advantage" },
  502.       { 18, L"White has a decisive advantage" },
  503.       { 19, L"Black has a decisive advantage" },
  504.       { 20, L"White has a crushing advantage (Black should resign)" },
  505.       { 21, L"Black has a crushing advantage (White should resign)" },
  506.       { 22, L"White is in zugzwang" },
  507.       { 23, L"Black is in zugzwang" },
  508.       { 24, L"White has a slight space advantage" },
  509.       { 25, L"Black has a slight space advantage" },
  510.       { 26, L"White has a moderate space advantage" },
  511.       { 27, L"Black has a moderate space advantage" },
  512.       { 28, L"White has a decisive space advantage" },
  513.       { 29, L"Black has a decisive space advantage" },
  514.       { 30, L"White has a slight time (development) advantage" },
  515.       { 31, L"Black has a slight time (development) advantage" },
  516.       { 32, L"White has a moderate time (development) advantage" },
  517.       { 33, L"Black has a moderate time (development) advantage" },
  518.       { 34, L"White has a decisive time (development) advantage" },
  519.       { 35, L"Black has a decisive time (development) advantage" },
  520.       { 36, L"White has the initiative" },
  521.       { 37, L"Black has the initiative" },
  522.       { 38, L"White has a lasting initiative" },
  523.       { 39, L"Black has a lasting initiative" },
  524.       { 40, L"White has the attack" },
  525.       { 41, L"Black has the attack" },
  526.       { 42, L"White has insufficient compensation for material deficit" },
  527.       { 43, L"Black has insufficient compensation for material deficit" },
  528.       { 44, L"White has sufficient compensation for material deficit" },
  529.       { 45, L"Black has sufficient compensation for material deficit" },
  530.       { 46, L"White has more than adequate compensation for material deficit" },
  531.       { 47, L"Black has more than adequate compensation for material deficit" },
  532.       { 48, L"White has a slight center control advantage" },
  533.       { 49, L"Black has a slight center control advantage" },
  534.       { 50, L"White has a moderate center control advantage" },
  535.       { 51, L"Black has a moderate center control advantage" },
  536.       { 52, L"White has a decisive center control advantage" },
  537.       { 53, L"Black has a decisive center control advantage" },
  538.       { 54, L"White has a slight kingside control advantage" },
  539.       { 55, L"Black has a slight kingside control advantage" },
  540.       { 56, L"White has a moderate kingside control advantage" },
  541.       { 57, L"Black has a moderate kingside control advantage" },
  542.       { 58, L"White has a decisive kingside control advantage" },
  543.       { 59, L"Black has a decisive kingside control advantage" },
  544.       { 60, L"White has a slight queenside control advantage" },
  545.       { 61, L"Black has a slight queenside control advantage" },
  546.       { 62, L"White has a moderate queenside control advantage" },
  547.       { 63, L"Black has a moderate queenside control advantage" },
  548.       { 64, L"White has a decisive queenside control advantage" },
  549.       { 65, L"Black has a decisive queenside control advantage" },
  550.       { 66, L"White has a vulnerable first rank" },
  551.       { 67, L"Black has a vulnerable first rank" },
  552.       { 68, L"White has a well protected first rank" },
  553.       { 69, L"Black has a well protected first rank" },
  554.       { 70, L"White has a poorly protected king" },
  555.       { 71, L"Black has a poorly protected king" },
  556.       { 72, L"White has a well protected king" },
  557.       { 73, L"Black has a well protected king" },
  558.       { 74, L"White has a poorly placed king" },
  559.       { 75, L"Black has a poorly placed king" },
  560.       { 76, L"White has a well placed king" },
  561.       { 77, L"Black has a well placed king" },
  562.       { 78, L"White has a very weak pawn structure" },
  563.       { 79, L"Black has a very weak pawn structure" },
  564.       { 80, L"White has a moderately weak pawn structure" },
  565.       { 81, L"Black has a moderately weak pawn structure" },
  566.       { 82, L"White has a moderately strong pawn structure" },
  567.       { 83, L"Black has a moderately strong pawn structure" },
  568.       { 84, L"White has a very strong pawn structure" },
  569.       { 85, L"Black has a very strong pawn structure" },
  570.       { 86, L"White has poor knight placement" },
  571.       { 87, L"Black has poor knight placement" },
  572.       { 88, L"White has good knight placement" },
  573.       { 89, L"Black has good knight placement" },
  574.       { 90, L"White has poor bishop placement" },
  575.       { 91, L"Black has poor bishop placement" },
  576.       { 92, L"White has good bishop placement" },
  577.       { 93, L"Black has good bishop placement" },
  578.       { 94, L"White has poor rook placement" },
  579.       { 95, L"Black has poor rook placement" },
  580.       { 96, L"White has good rook placement" },
  581.       { 97, L"Black has good rook placement" },
  582.       { 98, L"White has poor queen placement" },
  583.       { 99, L"Black has poor queen placement" },
  584.       { 100, L"White has good queen placement" },
  585.       { 101, L"Black has good queen placement" },
  586.       { 102, L"White has poor piece coordination" },
  587.       { 103, L"Black has poor piece coordination" },
  588.       { 104, L"White has good piece coordination" },
  589.       { 105, L"Black has good piece coordination" },
  590.       { 106, L"White has played the opening very poorly" },
  591.       { 107, L"Black has played the opening very poorly" },
  592.       { 108, L"White has played the opening poorly" },
  593.       { 109, L"Black has played the opening poorly" },
  594.       { 110, L"White has played the opening well" },
  595.       { 111, L"Black has played the opening well" },
  596.       { 112, L"White has played the opening very well" },
  597.       { 113, L"Black has played the opening very well" },
  598.       { 114, L"White has played the middlegame very poorly" },
  599.       { 115, L"Black has played the middlegame very poorly" },
  600.       { 116, L"White has played the middlegame poorly" },
  601.       { 117, L"Black has played the middlegame poorly" },
  602.       { 118, L"White has played the middlegame well" },
  603.       { 119, L"Black has played the middlegame well" },
  604.       { 120, L"White has played the middlegame very well" },
  605.       { 121, L"Black has played the middlegame very well" },
  606.       { 122, L"White has played the ending very poorly" },
  607.       { 123, L"Black has played the ending very poorly" },
  608.       { 124, L"White has played the ending poorly" },
  609.       { 125, L"Black has played the ending poorly" },
  610.       { 126, L"White has played the ending well" },
  611.       { 127, L"Black has played the ending well" },
  612.       { 128, L"White has played the ending very well" },
  613.       { 129, L"Black has played the ending very well" },
  614.       { 130, L"White has slight counterplay" },
  615.       { 131, L"Black has slight counterplay" },
  616.       { 132, L"White has moderate counterplay" },
  617.       { 133, L"Black has moderate counterplay" },
  618.       { 134, L"White has decisive counterplay" },
  619.       { 135, L"Black has decisive counterplay" },
  620.       { 136, L"White has moderate time control pressure" },
  621.       { 137, L"Black has moderate time control pressure" },
  622.       { 138, L"White has severe time control pressure" },
  623.       { 139, L"Black has severe time control pressure" }
  624.    };
  625.    int nag_index;
  626.  
  627.    // cycle through all known NAGs and return the text that corresponds to the requested code
  628.    for (nag_index = 0; nag_index < sizeof (nag_codes) / sizeof (nag_t); nag_index++)
  629.       if (nag_codes[nag_index].code == nag_code)
  630.          return (nag_codes[nag_index].text); // return the text as soon as we find it
  631.  
  632.    return (L"undocumented code"); // not found, return a placeholder string
  633. }
  634.  
  635.  
  636. static char *sgets (char *destination_line, int max_length, char *source_buffer)
  637. {
  638.    // copy a line from a given string. Kinda like fgets() when you're reading from a string.
  639.    // use it like:
  640.    // while (blah = sgets (dest, sizeof (dest), blah)) != NULL)
  641.  
  642.    char *pointer;
  643.    int char_index;
  644.  
  645.    if (source_buffer[0] == 0)
  646.    {
  647.       destination_line[0] = 0;
  648.       return (NULL); // if EOS return a NULL pointer
  649.    }
  650.  
  651.    pointer = strchr (source_buffer, '\n'); // get to the first carriage return we can find
  652.  
  653.    // found none ?
  654.    if (pointer == NULL)
  655.    {
  656.       // if so, copy the line we found
  657.       for (char_index = 0; char_index < max_length; char_index++)
  658.       {
  659.          destination_line[char_index] = source_buffer[char_index]; // copy the line we found
  660.          if (source_buffer[char_index] == 0)
  661.             break; // don't copy beyond the end of source
  662.       }
  663.  
  664.       if (char_index == max_length)
  665.          destination_line[max_length - 1] = 0; // ensure string is terminated
  666.  
  667.       return (&source_buffer[strlen (source_buffer)]); // and return a pointer to the end of the string
  668.    }
  669.  
  670.    *pointer = 0; // temporarily turn the carriage return to an end of string
  671.  
  672.    for (char_index = 0; char_index < max_length; char_index++)
  673.    {
  674.       destination_line[char_index] = source_buffer[char_index]; // copy the line we found
  675.       if (source_buffer[char_index] == 0)
  676.          break; // don't copy beyond the end of source
  677.    }
  678.  
  679.    destination_line[max_length - 1] = 0; // terminate string
  680.    *pointer = '\n'; // put the carriage return back
  681.  
  682.    return (&pointer[1]); // and return next line's source buffer pointer
  683. }
  684.