parser.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "gsl/pointers"
 
#include "porytiles/utilities/c_parser/array_declaration.hpp"
#include "porytiles/utilities/c_parser/define_statement.hpp"
#include "porytiles/utilities/c_parser/enum_declaration.hpp"
#include "porytiles/utilities/c_parser/function_definition.hpp"
#include "porytiles/utilities/c_parser/incbin_declaration.hpp"
#include "porytiles/utilities/c_parser/indexed_array_declaration.hpp"
#include "porytiles/utilities/c_parser/source_position.hpp"
#include "porytiles/utilities/c_parser/struct_definition.hpp"
#include "porytiles/utilities/c_parser/struct_initializer_declaration.hpp"
#include "porytiles/utilities/c_parser/struct_variable_declaration.hpp"
#include "porytiles/utilities/c_parser/token.hpp"
#include "porytiles/utilities/c_parser/tolerant_scan.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
 
namespace porytiles {
 
class CParserContext;
 
class Parser {
  public:
    Parser(gsl::not_null<const TextFormatter *> format, std::vector<Token> tokens)
        : format_{format}, tokens_{std::move(tokens)}
    {
    }
 
    Parser(gsl::not_null<const TextFormatter *> format, std::vector<Token> tokens, const CParserContext *context)
        : format_{format}, tokens_{std::move(tokens)}, context_{context}
    {
    }
 
    [[nodiscard]] ChainableResult<std::vector<DefineStatement>> parse_defines();
 
    [[nodiscard]] ChainableResult<std::vector<EnumDeclaration>> parse_enums();
 
    [[nodiscard]] ChainableResult<std::vector<ArrayDeclaration>> parse_pointer_arrays();
 
    [[nodiscard]] ChainableResult<std::vector<FunctionDefinition>> parse_functions();
 
    [[nodiscard]] ChainableResult<std::vector<StructVariableDeclaration>> parse_struct_variables();
 
    [[nodiscard]] ChainableResult<std::vector<StructInitializerDeclaration>> parse_struct_initializers();
 
    [[nodiscard]] ChainableResult<std::vector<StructDefinition>> parse_struct_definitions();
 
    [[nodiscard]] ChainableResult<std::vector<IncbinDeclaration>> parse_incbin_arrays();
 
    [[nodiscard]] ChainableResult<std::vector<IndexedArrayDeclaration>> parse_indexed_arrays();
 
    [[nodiscard]] TolerantDefineScan parse_defines_tolerant();
 
    [[nodiscard]] TolerantEnumScan parse_enums_tolerant();
 
    [[nodiscard]] const std::vector<std::string> &scan_warnings() const
    {
        return scan_warnings_;
    }
 
    [[nodiscard]] const std::unordered_set<std::string> &ambiguous_defines() const
    {
        return ambiguous_defines_;
    }
 
    [[nodiscard]] const std::unordered_set<std::string> &defined_names() const
    {
        return defined_names_;
    }
 
    void seed_symbols(const std::unordered_map<std::string, std::int64_t> &symbols)
    {
        for (const auto &[name, value] : symbols) {
            defined_values_[name] = value;
            defined_names_.insert(name);
        }
    }
 
    void seed_values(const std::unordered_map<std::string, std::int64_t> &symbols)
    {
        for (const auto &[name, value] : symbols) {
            defined_values_[name] = value;
        }
    }
 
  private:
    enum class CondState : std::uint8_t { active, skipping, both };
 
    struct ConditionalFrame {
        CondState state;
        bool decidable;
        bool branch_taken;
    };
 
    [[nodiscard]] const Token &peek() const;
    [[nodiscard]] const Token &peek_next() const;
    const Token &advance();
    [[nodiscard]] bool is_at_end() const;
    [[nodiscard]] bool check(TokenType type) const;
    bool match(TokenType type);
 
    void skip_to_next_line();
    [[nodiscard]] bool is_at_line_end() const;
 
    // Preprocessor conditional handling. try_handle_conditional consumes a conditional directive (returning true) or
    // reports that the directive at the current '#' is not conditional (returning false). effective_cond_state folds
    // the frame stack into a single state that gates whether scanned constructs are recorded.
    [[nodiscard]] CondState effective_cond_state() const;
    bool try_handle_conditional();
    [[nodiscard]] std::pair<CondState, bool> classify_ifdef(bool negated);
    [[nodiscard]] std::pair<CondState, bool> classify_if_expression();
    [[nodiscard]] std::optional<std::vector<Token>> substitute_defined_operators(const std::vector<Token> &expr) const;
 
    [[nodiscard]] ChainableResult<DefineStatement> parse_define();
    void record_define(DefineStatement statement, std::vector<DefineStatement> &out);
    [[nodiscard]] ChainableResult<EnumDeclaration> parse_enum();
    [[nodiscard]] ChainableResult<EnumMember> parse_enum_member(std::int64_t &counter);
 
    // Tolerant variants used by the tolerant scans. The outcome carries either a resolved statement or a skip record;
    // both leave the parser positioned at the start of the next line.
    struct DefineParseOutcome {
        std::optional<DefineStatement> statement;
        std::optional<SkippedConstruct> skipped;
    };
    [[nodiscard]] DefineParseOutcome parse_define_tolerant();
    [[nodiscard]] std::optional<TolerantEnum> parse_enum_tolerant();
    [[nodiscard]] TolerantEnumMember parse_enum_member_tolerant(std::int64_t &counter, bool &counter_valid);
    [[nodiscard]] std::vector<IndexedArrayEntry> parse_indexed_entries(const std::vector<Token> &brace_contents);
    [[nodiscard]] std::vector<Token> collect_expression_tokens();
    [[nodiscard]] std::vector<Token> collect_enum_value_tokens();
    [[nodiscard]] ChainableResult<std::int64_t> evaluate_expression(const std::vector<Token> &expr_tokens);
 
    // Shunting Yard algorithm helpers
    [[nodiscard]] std::vector<Token> to_postfix(const std::vector<Token> &expr_tokens);
    [[nodiscard]] ChainableResult<std::int64_t> evaluate_postfix(const std::vector<Token> &postfix);
    [[nodiscard]] int operator_precedence(TokenType type) const;
    [[nodiscard]] bool is_left_associative(TokenType type) const;
    [[nodiscard]] bool is_operator(TokenType type) const;
    [[nodiscard]] bool is_unary_operator(TokenType type) const;
 
    [[nodiscard]] FormattableError make_error(SourcePosition pos, std::string message) const;
 
    const TextFormatter *format_;
    std::vector<Token> tokens_;
    std::size_t current_{0};
    std::unordered_map<std::string, std::int64_t> defined_values_{{"UCHAR_MAX", 255}}; // Symbol table for macro values
    std::unordered_set<std::string> defined_names_;                                    // All names seen as defined
    std::vector<ConditionalFrame> cond_stack_; // Active preprocessor conditionals
    std::vector<std::string> scan_warnings_;   // Recoverable scan diagnostics
    std::unordered_set<std::string> ambiguous_defines_;
    const CParserContext *context_{nullptr};
};
 
} // namespace porytiles