pgnparser.h

Go to the documentation of this file.

// Hoover Chess Utilities / PGN reader
// Copyright (C) 2022-2025  Sami Kiminki
//
// This program 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.
//
// This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef HOOVER_CHESS_UTILS__PGN_READER__PGNPARSER_H_INCLUDED
#define HOOVER_CHESS_UTILS__PGN_READER__PGNPARSER_H_INCLUDED
 
 
#include "chessboard.h"
#include "pgnreader-types.h"
#include "pgnscanner.h"
#include "stringbuilder.h"
 
#include <array>
#include <bit>
#include <cstring>
#include <format>
#include <iterator>
#include <memory>
#include <string>
#include <vector>
 
namespace hoover_chess_utils::pgn_reader
{
 
 
class PgnParser_NullActions
{
public:
 
    void gameStart() { }
 
 
    void pgnTag(const std::string_view &key, const std::string_view &value)
    {
        static_cast<void>(key);
        static_cast<void>(value);
    }
 
    void moveTextSection() { }
 
 
    void comment(const std::string_view &str)
    {
        static_cast<void>(str);
    }
 
    void nag(std::uint8_t nagNum)
    {
        static_cast<void>(nagNum);
    }
 
    void moveNum(std::uint32_t moveNum)
    {
        static_cast<void>(moveNum);
    }
 
    void movePawn(SquareSet srcMask, Square dst)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
    }
 
    void movePawnCapture(SquareSet srcMask, Square dst)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
    }
 
    void movePawnPromo(SquareSet srcMask, Square dst, Piece promo)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
        static_cast<void>(promo);
    }
 
    void movePawnPromoCapture(SquareSet srcMask, Square dst, Piece promo)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
        static_cast<void>(promo);
    }
 
    void moveKnight(SquareSet srcMask, Square dst, bool capture)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
        static_cast<void>(capture);
    }
 
    void moveBishop(SquareSet srcMask, Square dst, bool capture)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
        static_cast<void>(capture);
    }
 
    void moveRook(SquareSet srcMask, Square dst, bool capture)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
        static_cast<void>(capture);
    }
 
    void moveQueen(SquareSet srcMask, Square dst, bool capture)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
        static_cast<void>(capture);
    }
 
    void moveKing(SquareSet srcMask, Square dst, bool capture)
    {
        static_cast<void>(srcMask);
        static_cast<void>(dst);
        static_cast<void>(capture);
    }
 
    void moveShortCastle()
    {
    }
 
    void moveLongCastle()
    {
    }
 
    void variationStart()
    {
    }
 
    void variationEnd()
    {
    }
 
    void gameTerminated(PgnResult result)
    {
        static_cast<void>(result);
    }
 
    void endOfPGN() { }
};
 
template <typename T_ActionHandler>
class PgnParser
{
private:
    PgnScanner &m_scanner;
    T_ActionHandler &m_actionHandler;
    StringBuilder m_strBuilder { };
    StringBuilder m_strBuilder2 { };
 
    bool m_inMoveTextSection { };
    std::vector<std::string> m_pendingComments { };
 
    void unexpectedTokenError(
        PgnErrorCode errorCode,
        std::uint32_t expectedTokenMask,
        PgnScannerToken token)
    {
        std::string expectedTokens { };
 
        while (expectedTokenMask != 0U)
        {
            if (!expectedTokens.empty())
                expectedTokens += " | ";
 
            expectedTokens += PgnScanner::scannerTokenToString(PgnScannerToken { static_cast<std::uint8_t>(std::countr_zero(expectedTokenMask)) });
            expectedTokenMask = expectedTokenMask & (expectedTokenMask - 1U);
        }
 
        throw PgnError(
            errorCode,
            std::format(
                "Expected token {} but got: {} ({})",
                expectedTokens, PgnScanner::scannerTokenToString(token), static_cast<std::uint8_t>(token)));
    }
 
    void parseTagPair()
    {
        m_strBuilder.clear();
        m_strBuilder2.clear();
        PgnScannerToken token { m_scanner.nextToken() };
        if (token != PgnScannerToken::TAG_KEY) [[unlikely]]
            unexpectedTokenError(
                PgnErrorCode::BAD_PGN_TAG,
                pgnScannerTokenToMaskBit(PgnScannerToken::TAG_KEY),
                token);
 
        m_strBuilder.appendString(m_scanner.YYText(), m_scanner.YYLeng());
 
        token = m_scanner.nextToken();
        if (token != PgnScannerToken::TAG_VALUE) [[unlikely]]
            unexpectedTokenError(
                PgnErrorCode::BAD_PGN_TAG,
                pgnScannerTokenToMaskBit(PgnScannerToken::TAG_VALUE),
                token);
 
        // TAG value string has format "...", so we'll crop the first and the
        // last chars away. In addition, we need to parse escapes
        bool escape = false;
        for (const char c : std::string_view { m_scanner.YYText() + 1, static_cast<std::size_t>(m_scanner.YYLeng() - 2) })
        {
            if (escape)
            {
                m_strBuilder2.pushBack(c);
                escape = false;
            }
            else if (c != '\\')
            {
                m_strBuilder2.pushBack(c);
            }
            else
                escape = true;
        }
 
        m_actionHandler.pgnTag(
            m_strBuilder.getStringView(),
            m_strBuilder2.getStringView());
 
        token = m_scanner.nextToken();
        if (token != PgnScannerToken::TAG_END) [[unlikely]]
            unexpectedTokenError(
                PgnErrorCode::BAD_PGN_TAG,
                pgnScannerTokenToMaskBit(PgnScannerToken::TAG_END),
                token);
    }
 
    PgnScannerToken parseLine(PgnScannerToken token)
    {
        bool variationAllowed { };
 
        while (true)
        {
            switch (token)
            {
                case PgnScannerToken::MOVENUM:
                    handleMoveNum(m_scanner.getTokenInfo().moveNum);
                    token = m_scanner.nextToken();
                    break;
 
                case PgnScannerToken::COMMENT_START:
                    parseCommentBlock();
                    token = m_scanner.nextToken();
                    break;
 
                case PgnScannerToken::COMMENT_TEXT:
                    parseSingleLineComment();
                    token = m_scanner.nextToken();
                    break;
 
                case PgnScannerToken::MOVE_PAWN:
                    handleMovePawn(m_scanner.getTokenInfo().pawnMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PAWN_CAPTURE:
                    handleMovePawnCapture(m_scanner.getTokenInfo().pawnMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PAWN_PROMO:
                    handleMovePawnPromo(m_scanner.getTokenInfo().pawnMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PAWN_PROMO_CAPTURE:
                    handleMovePawnPromoCapture(m_scanner.getTokenInfo().pawnMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PIECE_KNIGHT:
                    handleMoveKnight(m_scanner.getTokenInfo().pieceMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PIECE_BISHOP:
                    handleMoveBishop(m_scanner.getTokenInfo().pieceMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PIECE_ROOK:
                    handleMoveRook(m_scanner.getTokenInfo().pieceMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PIECE_QUEEN:
                    handleMoveQueen(m_scanner.getTokenInfo().pieceMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_PIECE_KING:
                    handleMoveKing(m_scanner.getTokenInfo().pieceMove);
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_SHORT_CASTLE:
                    handleMoveShortCastle();
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::MOVE_LONG_CASTLE:
                    handleMoveLongCastle();
                    token = parseNagsAfterMove();
                    variationAllowed = true;
                    break;
 
                case PgnScannerToken::VARIATION_START:
                    if (variationAllowed) [[likely]]
                    {
                        token = parseVariation();
                        break;
                    }
                    else [[unlikely]]
                    {
                        throw PgnError(
                            PgnErrorCode::UNEXPECTED_TOKEN,
                            std::format(
                                "VARIATION_START not allowed in a line before move"));
                    }
 
                default:
                    return token;
            }
        }
    }
 
    PgnScannerToken parseVariation()
    {
        m_actionHandler.variationStart();
 
        PgnScannerToken token { m_scanner.nextToken() };
        token = parseLine(token);
 
        if (token != PgnScannerToken::VARIATION_END) [[unlikely]]
        {
            unexpectedTokenError(
                PgnErrorCode::UNEXPECTED_TOKEN,
                pgnScannerTokenToMaskBit(PgnScannerToken::VARIATION_END),
                token);
        }
 
        m_actionHandler.variationEnd();
 
        return m_scanner.nextToken();
    }
 
    inline void handleMovePawn(const PgnScannerTokenInfo_PAWN_MOVE &move) const
    {
        m_actionHandler.movePawn(
            move.srcMask,
            move.dstSq);
    }
 
    inline void handleMovePawnCapture(const PgnScannerTokenInfo_PAWN_MOVE &move) const
    {
        m_actionHandler.movePawnCapture(
            move.srcMask,
            move.dstSq);
    }
 
    inline void handleMovePawnPromo(const PgnScannerTokenInfo_PAWN_MOVE &move) const
    {
        m_actionHandler.movePawnPromo(
            move.srcMask,
            move.dstSq,
            move.promoPiece);
    }
 
    inline void handleMovePawnPromoCapture(const PgnScannerTokenInfo_PAWN_MOVE &move) const
    {
        m_actionHandler.movePawnPromoCapture(
            move.srcMask,
            move.dstSq,
            move.promoPiece);
    }
 
    inline void handleMoveKnight(const PgnScannerTokenInfo_PIECE_MOVE &move) const
    {
        m_actionHandler.moveKnight(move.srcMask, move.dstSq, move.capture);
    }
 
    inline void handleMoveBishop(const PgnScannerTokenInfo_PIECE_MOVE &move) const
    {
        m_actionHandler.moveBishop(move.srcMask, move.dstSq, move.capture);
    }
 
    inline void handleMoveRook(const PgnScannerTokenInfo_PIECE_MOVE &move) const
    {
        m_actionHandler.moveRook(move.srcMask, move.dstSq, move.capture);
    }
 
    inline void handleMoveQueen(const PgnScannerTokenInfo_PIECE_MOVE &move) const
    {
        m_actionHandler.moveQueen(move.srcMask, move.dstSq, move.capture);
    }
 
    inline void handleMoveKing(const PgnScannerTokenInfo_PIECE_MOVE &move) const
    {
        m_actionHandler.moveKing(move.srcMask, move.dstSq, move.capture);
    }
 
    inline void handleMoveShortCastle() const
    {
        m_actionHandler.moveShortCastle();
    }
 
    inline void handleMoveLongCastle() const
    {
        m_actionHandler.moveLongCastle();
    }
 
    void handleMoveNum(const PgnScannerTokenInfo_MOVENUM &moveNum) const
    {
        m_actionHandler.moveNum(moveNum.num);
    }
 
    PgnScannerToken parseNagsAfterMove()
    {
        PgnScannerToken token { m_scanner.nextToken() };
 
        while (token == PgnScannerToken::NAG)
        {
            m_actionHandler.nag(m_scanner.getTokenInfo().nag.nag);
            token = m_scanner.nextToken();
        }
 
        return token;
    }
 
    PgnScannerToken parseComments(PgnScannerToken token)
    {
        while (true)
        {
            switch (token)
            {
                case PgnScannerToken::COMMENT_START:
                    parseCommentBlock();
                    token = m_scanner.nextToken();
                    break;
 
                case PgnScannerToken::COMMENT_TEXT:
                    parseSingleLineComment();
                    token = m_scanner.nextToken();
                    break;
 
                default:
                    return token;
            }
        }
    }
 
    void parseCommentBlock()
    {
        m_strBuilder.clear();
 
        std::size_t pendingNewlines { };
 
        while (true)
        {
            const PgnScannerToken token { m_scanner.nextToken() };
            switch (token)
            {
                case PgnScannerToken::COMMENT_TEXT:
                    if (!m_strBuilder.isEmpty())
                    {
                        while (pendingNewlines > 0U)
                        {
                            m_strBuilder.pushBack('\n');
                            --pendingNewlines;
                        }
                    }
                    pendingNewlines = 0U;
                    m_strBuilder.appendString(m_scanner.YYText(), m_scanner.YYLeng());
                    break;
                case PgnScannerToken::COMMENT_NEWLINE:
                    ++pendingNewlines;
                    break;
                case PgnScannerToken::COMMENT_END:
                    if (m_inMoveTextSection)
                        m_actionHandler.comment(m_strBuilder.getStringView());
                    else
                        m_pendingComments.push_back(std::string { m_strBuilder.getStringView() });
 
                    return;
 
                default: [[unlikely]]
                    unexpectedTokenError(
                        PgnErrorCode::UNEXPECTED_TOKEN,
                        pgnScannerTokenToMaskBit(PgnScannerToken::COMMENT_TEXT) |
                        pgnScannerTokenToMaskBit(PgnScannerToken::COMMENT_NEWLINE) |
                        pgnScannerTokenToMaskBit(PgnScannerToken::COMMENT_END),
                        token);
            }
        }
    }
 
    void parseSingleLineComment()
    {
        const char *commentStart { m_scanner.YYText() };
        const char *commentEnd { commentStart + static_cast<std::size_t>(m_scanner.YYLeng()) };
 
        ++commentStart; // eat the ';'
 
        // eat the white spaces from the beginning
        while (commentStart != commentEnd)
        {
            switch (*commentStart)
            {
                case ' ':
                case '\t':
                case '\v':
                    ++commentStart;
                    continue;
 
                default:
                    break;
            }
            break;
        }
 
        // eat the white spaces from the end
        while (commentStart != commentEnd)
        {
            switch (*(commentEnd - 1U))
            {
                case ' ':
                case '\t':
                case '\v':
                    --commentEnd;
                    continue;
 
                default:
                    break;
            }
            break;
        }
 
        if (commentStart != commentEnd)
        {
            if (m_inMoveTextSection)
                m_actionHandler.comment(std::string_view { commentStart, commentEnd });
            else
                m_pendingComments.push_back(std::string { commentStart, commentEnd });
        }
    }
 
    void flushPendingComments()
    {
        for (const auto &str : m_pendingComments)
            m_actionHandler.comment(str);
 
        m_pendingComments.clear();
    }
 
public:
    PgnParser(PgnScanner &scanner, T_ActionHandler &actionHandler) :
        m_scanner { scanner },
        m_actionHandler { actionHandler }
    {
    }
 
    PgnParser(const PgnParser &) = delete;
    PgnParser(PgnParser &&) = delete;
    PgnParser &operator = (const PgnParser &) & = delete;
    PgnParser &operator = (PgnParser &&) & = delete;
 
    void parse()
    {
        try
        {
            // every full iteration parses a game
            while (true)
            {
                PgnScannerToken token { m_scanner.nextToken() };
 
                // PGN ==> GAME* COMMENT* <end_of_file>
                while (true)
                {
                    if (token == PgnScannerToken::END_OF_FILE)
                    {
                        flushPendingComments();
                        m_actionHandler.endOfPGN();
                        return;
                    }
                    else if (token == PgnScannerToken::COMMENT_START)
                        parseCommentBlock();
                    else if (token == PgnScannerToken::COMMENT_TEXT)
                        parseSingleLineComment();
                    else
                        break;
 
                    token = m_scanner.nextToken();
                }
 
                // GAME = TAGPAIRS MOVETEXT
                m_actionHandler.gameStart();
 
                // TAGPAIRS = (COMMENT | TAGPAIR)*
                while (true)
                {
                    if (token == PgnScannerToken::TAG_START)
                    {
                        flushPendingComments();
                        parseTagPair();
                    }
                    else if (token == PgnScannerToken::COMMENT_START)
                        parseCommentBlock();
                    else if (token == PgnScannerToken::COMMENT_TEXT)
                        parseSingleLineComment();
                    else
                        break;
 
                    token = m_scanner.nextToken();
                }
 
                // MOVETEXT
                m_actionHandler.moveTextSection();
                flushPendingComments();
                m_inMoveTextSection = true;
 
                token = parseLine(token);
 
                if (token != PgnScannerToken::RESULT) [[unlikely]]
                    unexpectedTokenError(
                        PgnErrorCode::UNEXPECTED_TOKEN,
                        pgnScannerTokenToMaskBit(PgnScannerToken::RESULT),
                        token);
 
                m_actionHandler.gameTerminated(m_scanner.getTokenInfo().result.result);
                m_inMoveTextSection = false;
            }
        }
        catch (const PgnError &ex)
        {
            // add position info in the exception
            throw PgnError(m_scanner, ex);
        }
    }
};
 
 
}
 
#endif