parse_utils.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
#ifndef PARSE_UTILS_H
#define PARSE_UTILS_H
 
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <utility>
#include <vector>
#include <stdexcept>
#include <algorithm>
#include <aleph.H>
#include <ah-errors.H>
# include <ah-string-utils.H>
 
namespace Aleph
{
  // ============================================================================
  // Global State (inline for header-only)
  // ============================================================================
 
  inline constexpr size_t Buffer_Size = 512;
 
  inline int current_line_number = 1;
 
  inline int current_col_number = 1;
 
  inline int previous_line_number = 1;
 
  inline int previous_col_number = 1;
 
  inline std::string token_instance;
 
 
  // ============================================================================
  // Buffer Management
  // ============================================================================
 
  inline void put_char_in_buffer(char *& start_addr, const char *end_addr, int c)
  {
    if (start_addr >= end_addr)
      AH_ERROR("String too long (buffer overflow in parse_utils)");
 
    *start_addr++ = static_cast<char>(c);
  }
 
  // ============================================================================
  // Token Scanning
  // ============================================================================
 
  inline void init_token_scanning()
  {
    previous_line_number = current_line_number;
    previous_col_number = current_col_number;
  }
 
  inline void close_token_scanning(const char *buffer, char *& start_addr, const char *end_addr)
  {
    put_char_in_buffer(start_addr, end_addr, '\0');
    token_instance = buffer;
  }
 
  // ============================================================================
  // Stream Reading
  // ============================================================================
 
  inline int read_char_from_stream(std::ifstream & input_stream)
  {
    ah_out_of_range_error_if(input_stream.eof())
    << "end of file has been reached";
 
    int c = input_stream.get();
 
    if (c == '\n')
      {
        current_line_number++;
        current_col_number = 0;
      }
    else
      current_col_number++;
 
    return c;
  }
 
  inline void skip_white_spaces(std::ifstream & input_stream)
  {
    while (std::isspace(read_char_from_stream(input_stream))) {} // Skip whitespace
    input_stream.unget();
  }
 
  // ============================================================================
  // Token Loading
  // ============================================================================
 
  inline long load_number(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *start_addr = buffer;
    char *end_addr = buffer + Buffer_Size;
 
    init_token_scanning();
 
    try
      {
        skip_white_spaces(input_stream);
        int c = read_char_from_stream(input_stream);
 
        // Handle optional minus sign
        if (c == '-')
          {
            put_char_in_buffer(start_addr, end_addr, c);
            c = read_char_from_stream(input_stream);
 
            if (not std::isdigit(c))
              return std::strtol(buffer, nullptr, 10);
          }
 
        while (true)
          {
            // Read digits
            while (std::isdigit(c))
              {
                put_char_in_buffer(start_addr, end_addr, c);
                c = read_char_from_stream(input_stream);
              }
 
            // Number ends at whitespace
            if (std::isspace(c))
              {
                close_token_scanning(buffer, start_addr, end_addr);
                return std::strtol(buffer, nullptr, 10);
              }
 
            ah_domain_error_if(true) << "Invalid number format";
          }
      }
    catch (const std::out_of_range &)
      {
        // EOF reached - return what we have
        close_token_scanning(buffer, start_addr, end_addr);
        return std::strtol(buffer, nullptr, 10);
      }
  }
 
  inline std::string load_string(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *start_addr = buffer;
    const char *end_addr = buffer + Buffer_Size;
 
    bool quoted = false;
 
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    if (c == '\"')
      quoted = true;
    else
      put_char_in_buffer(start_addr, end_addr, c);
 
    while (true)
      {
        c = read_char_from_stream(input_stream);
 
        // End of quoted string
        if (c == '\"' and quoted)
          break;
 
        // End of unquoted string
        if (not quoted and (std::isblank(c) or c == '\n' or c == EOF))
          break;
 
        put_char_in_buffer(start_addr, end_addr, c);
      }
 
    close_token_scanning(buffer, start_addr, end_addr);
    return {buffer};
  }
 
  // ============================================================================
  // Error Reporting
  // ============================================================================
 
  [[noreturn]]
  inline void print_parse_error_and_exit(const std::string & str)
  {
    std::cout << "Parse error "
        << previous_line_number << ":" << previous_col_number << " "
        << str << std::endl
        << "Last token seen is: " << token_instance << std::endl;
    std::exit(1);
  }
 
  inline void print_parse_warning(const std::string & str)
  {
    std::cout << "Parse warning "
        << previous_line_number << ":" << previous_col_number << " "
        << str << std::endl
        << "Last token seen is: " << token_instance << std::endl;
  }
 
  // ============================================================================
  // Utility Functions
  // ============================================================================
 
  inline std::string command_line_to_string(int argc, char *argv[])
  {
    std::string command_line;
 
    for (int i = 0; i < argc; ++i)
      {
        command_line += " ";
        command_line += argv[i];
      }
 
    return command_line;
  }
 
  inline void reset_parse_state()
  {
    current_line_number = 1;
    current_col_number = 1;
    previous_line_number = 1;
    previous_col_number = 1;
    token_instance.clear();
  }
 
  // ============================================================================
  // Source Location and Parse Errors
  // ============================================================================
 
  struct SourceLocation
  {
    std::string filename; 
    int line = 1; 
    int column = 1; 
 
    SourceLocation() = default;
 
    SourceLocation(std::string file, const int ln, const int col)
      : filename(std::move(file)), line(ln), column(col) {}
 
    static SourceLocation current(const std::string & file = "")
    {
      return {file, current_line_number, current_col_number};
    }
 
    static SourceLocation previous(const std::string & file = "")
    {
      return {file, previous_line_number, previous_col_number};
    }
 
    [[nodiscard]] std::string to_string() const
    {
      std::ostringstream oss;
      if (not filename.empty())
        oss << filename << ":";
      oss << line << ":" << column;
      return oss.str();
    }
  };
 
  class ParseError : public std::runtime_error
  {
    SourceLocation loc;
 
  public:
    ParseError(const std::string & message, const SourceLocation & location)
      : std::runtime_error(location.to_string() + ": " + message)
        , loc(location)
    {}
 
    explicit ParseError(const std::string & message)
      : std::runtime_error(std::to_string(previous_line_number) + ":" +
                           std::to_string(previous_col_number) + ": " + message)
        , loc("", previous_line_number, previous_col_number)
    {}
 
    [[nodiscard]] const SourceLocation &location() const { return loc; }
  };
 
  // ============================================================================
  // Lookahead and Backtracking
  // ============================================================================
 
  struct StreamPosition
  {
    std::streampos pos; 
    int line{}; 
    int column{}; 
  };
 
  inline int peek_char(std::ifstream & input_stream)
  {
    return input_stream.peek();
  }
 
  inline StreamPosition mark_position(std::ifstream & input_stream)
  {
    StreamPosition sp;
    sp.pos = input_stream.tellg();
    sp.line = current_line_number;
    sp.column = current_col_number;
    return sp;
  }
 
  inline void restore_position(std::ifstream & input_stream, const StreamPosition & pos)
  {
    input_stream.seekg(pos.pos);
    current_line_number = pos.line;
    current_col_number = pos.column;
  }
 
  // ============================================================================
  // Comment Handling
  // ============================================================================
 
  inline void skip_line_comment(std::ifstream & input_stream)
  {
    while (not input_stream.eof())
      {
        if (const int c = input_stream.get(); c == '\n')
          {
            current_line_number++;
            current_col_number = 0;
            return;
          }
        current_col_number++;
      }
  }
 
  inline void skip_block_comment(std::ifstream & input_stream,
                                 const std::string & open = "/" "*",
                                 const std::string & close = "*" "/")
  {
    (void) open; // Documented for clarity; opening sequence already consumed.
    size_t match_pos = 0;
 
    while (not input_stream.eof())
      {
        if (const int c = input_stream.get(); c == '\n')
          {
            current_line_number++;
            current_col_number = 0;
            match_pos = 0;
          }
        else
          {
            current_col_number++;
 
            if (c == close[match_pos])
              {
                match_pos++;
                if (match_pos == close.size())
                  return; // Found closing sequence
              }
            else
              match_pos = (c == close[0]) ? 1 : 0;
          }
      }
 
    throw ParseError("Unterminated block comment");
  }
 
  inline void skip_whitespace_and_comments(std::ifstream & input_stream)
  {
    while (not input_stream.eof())
      {
        if (const int c = peek_char(input_stream); std::isspace(c))
          read_char_from_stream(input_stream);
        else if (c == '/')
          {
            // Peek ahead for // or /* ... */
            input_stream.get();
            current_col_number++;
            if (const int next = peek_char(input_stream); next == '/')
              {
                input_stream.get();
                current_col_number++;
                skip_line_comment(input_stream);
              }
            else if (next == '*')
              {
                input_stream.get();
                current_col_number++;
                skip_block_comment(input_stream);
              }
            else
              {
                // Not a comment, put back the '/'
                input_stream.unget();
                current_col_number--;
                return;
              }
          }
        else if (c == '#')
          {
            // Shell/Python style line comment
            read_char_from_stream(input_stream);
            skip_line_comment(input_stream);
          }
        else
          return; // Non-whitespace, non-comment found
      }
  }
 
  // ============================================================================
  // Numeric Parsing (Extended)
  // ============================================================================
 
  inline double load_double(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *ptr = buffer;
    char *end = buffer + Buffer_Size;
 
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    // Optional sign
    if (c == '-' or c == '+')
      {
        put_char_in_buffer(ptr, end, c);
        c = read_char_from_stream(input_stream);
      }
 
    bool has_digits = false;
 
    // Integer part
    while (std::isdigit(c))
      {
        has_digits = true;
        put_char_in_buffer(ptr, end, c);
        c = read_char_from_stream(input_stream);
      }
 
    // Decimal part
    if (c == '.')
      {
        put_char_in_buffer(ptr, end, c);
        c = read_char_from_stream(input_stream);
 
        while (std::isdigit(c))
          {
            has_digits = true;
            put_char_in_buffer(ptr, end, c);
            c = read_char_from_stream(input_stream);
          }
      }
 
    if (not has_digits)
      throw ParseError("Invalid floating-point number: no digits");
 
    // Exponent part
    if (c == 'e' or c == 'E')
      {
        put_char_in_buffer(ptr, end, c);
        c = read_char_from_stream(input_stream);
 
        if (c == '+' or c == '-')
          {
            put_char_in_buffer(ptr, end, c);
            c = read_char_from_stream(input_stream);
          }
 
        if (not std::isdigit(c))
          throw ParseError("Invalid exponent in floating-point number");
 
        while (std::isdigit(c))
          {
            put_char_in_buffer(ptr, end, c);
            c = read_char_from_stream(input_stream);
          }
      }
 
    // Put back the terminating character
    input_stream.unget();
    if (c != '\n')
      current_col_number--;
 
    close_token_scanning(buffer, ptr, end);
    return std::strtod(buffer, nullptr);
  }
 
  inline long load_hex_number(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *ptr = buffer;
    char *end = buffer + Buffer_Size;
 
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    // Expect '0'
    if (c != '0')
      throw ParseError("Hexadecimal number must start with 0x");
 
    c = read_char_from_stream(input_stream);
    if (c != 'x' and c != 'X')
      throw ParseError("Hexadecimal number must start with 0x");
 
    c = read_char_from_stream(input_stream);
 
    if (not std::isxdigit(c))
      throw ParseError("Invalid hexadecimal number");
 
    while (std::isxdigit(c))
      {
        put_char_in_buffer(ptr, end, c);
        c = read_char_from_stream(input_stream);
      }
 
    input_stream.unget();
    if (c != '\n')
      current_col_number--;
 
    close_token_scanning(buffer, ptr, end);
    return std::strtol(buffer, nullptr, 16);
  }
 
  inline long load_octal_number(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *ptr = buffer;
    char *end = buffer + Buffer_Size;
 
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    if (c != '0')
      throw ParseError("Octal number must start with 0");
 
    c = read_char_from_stream(input_stream);
 
    // Check it's not hex (0x)
    if (c == 'x' or c == 'X')
      throw ParseError("Expected octal number, got hexadecimal");
 
    while (c >= '0' and c <= '7')
      {
        put_char_in_buffer(ptr, end, c);
        c = read_char_from_stream(input_stream);
      }
 
    input_stream.unget();
    if (c != '\n')
      current_col_number--;
 
    close_token_scanning(buffer, ptr, end);
 
    if (ptr == buffer)
      return 0; // Just "0"
 
    return std::strtol(buffer, nullptr, 8);
  }
 
  inline long load_binary_number(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *ptr = buffer;
    char *end = buffer + Buffer_Size;
 
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    if (c != '0')
      throw ParseError("Binary number must start with 0b");
 
    c = read_char_from_stream(input_stream);
    if (c != 'b' and c != 'B')
      throw ParseError("Binary number must start with 0b");
 
    c = read_char_from_stream(input_stream);
 
    if (c != '0' and c != '1')
      throw ParseError("Invalid binary number");
 
    while (c == '0' or c == '1')
      {
        put_char_in_buffer(ptr, end, c);
        c = read_char_from_stream(input_stream);
      }
 
    input_stream.unget();
    if (c != '\n')
      current_col_number--;
 
    close_token_scanning(buffer, ptr, end);
    return std::strtol(buffer, nullptr, 2);
  }
 
  // ============================================================================
  // Identifier and Keyword Parsing
  // ============================================================================
 
  inline std::string load_identifier(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *ptr = buffer;
    char *end = buffer + Buffer_Size;
 
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    // Must start with a letter or underscore
    if (not std::isalpha(c) and c != '_')
      throw ParseError("Identifier must start with letter or underscore");
 
    put_char_in_buffer(ptr, end, c);
 
    while (true)
      {
        c = read_char_from_stream(input_stream);
 
        if (std::isalnum(c) or c == '_')
          put_char_in_buffer(ptr, end, c);
        else
          break;
      }
 
    input_stream.unget();
    if (c != '\n')
      current_col_number--;
 
    close_token_scanning(buffer, ptr, end);
    return {buffer};
  }
 
  inline bool is_keyword(const std::string & s, const std::vector<std::string> & keywords)
  {
    return std::find(keywords.begin(), keywords.end(), s) != keywords.end();
  }
 
  // ============================================================================
  // Expectation Functions
  // ============================================================================
 
  inline void expect_char(std::ifstream & input_stream, char expected)
  {
    skip_white_spaces(input_stream);
    if (const int c = read_char_from_stream(input_stream); c != expected)
      {
        std::string msg = "Expected '";
        msg += expected;
        msg += "' but found '";
        msg += static_cast<char>(c);
        msg += "'";
        throw ParseError(msg);
      }
  }
 
  inline void expect(std::ifstream & input_stream, const std::string & expected)
  {
    skip_white_spaces(input_stream);
    init_token_scanning();
 
    for (const char ch: expected)
      if (const int c = read_char_from_stream(input_stream); c != ch)
        throw ParseError("Expected '" + expected + "'");
 
    token_instance = expected;
  }
 
  inline bool try_char(std::ifstream & input_stream, char ch)
  {
    StreamPosition pos = mark_position(input_stream);
    skip_white_spaces(input_stream);
 
    if (const int c = read_char_from_stream(input_stream); c == ch)
      return true;
 
    restore_position(input_stream, pos);
    return false;
  }
 
  // ============================================================================
  // String Parsing (Extended)
  // ============================================================================
 
  inline char process_escape(const int c)
  {
    switch (c)
      {
      case 'n': return '\n';
      case 't': return '\t';
      case 'r': return '\r';
      case '\\': return '\\';
      case '"': return '"';
      case '\'': return '\'';
      case '0': return '\0';
      case 'a': return '\a';
      case 'b': return '\b';
      case 'f': return '\f';
      case 'v': return '\v';
      default: return static_cast<char>(c); // Unknown escape, keep as-is
      }
  }
 
  inline std::string load_escaped_string(std::ifstream & input_stream)
  {
    char buffer[Buffer_Size];
    char *ptr = buffer;
    const char *end = buffer + Buffer_Size;
 
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    if (c != '"')
      throw ParseError("Expected '\"' to start string");
 
    while (true)
      {
        c = read_char_from_stream(input_stream);
 
        if (c == EOF)
          throw ParseError("Unterminated string literal");
 
        if (c == '"')
          break;
 
        if (c == '\\')
          {
            c = read_char_from_stream(input_stream);
            if (c == EOF)
              throw ParseError("Unterminated escape sequence");
            c = static_cast<unsigned char>(process_escape(c));
          }
 
        put_char_in_buffer(ptr, end, c);
      }
 
    close_token_scanning(buffer, ptr, end);
    return {buffer};
  }
 
  inline char load_char_literal(std::ifstream & input_stream)
  {
    init_token_scanning();
    skip_white_spaces(input_stream);
 
    int c = read_char_from_stream(input_stream);
 
    if (c != '\'')
      throw ParseError("Expected single quote to start character literal");
 
    c = read_char_from_stream(input_stream);
 
    if (c == '\\')
      {
        c = read_char_from_stream(input_stream);
        c = static_cast<unsigned char>(process_escape(c));
      }
 
    char result = static_cast<char>(c);
 
    c = read_char_from_stream(input_stream);
    if (c != '\'')
      throw ParseError("Expected single quote to end character literal");
 
    token_instance = "'";
    token_instance += result;
    token_instance += "'";
 
    return result;
  }
 
  // ============================================================================
  // Token Types (for lexer support)
  // ============================================================================
 
  enum class TokenType
  {
    END_OF_FILE, 
    IDENTIFIER, 
    INTEGER, 
    FLOAT, 
    STRING, 
    CHAR, 
    OPERATOR, 
    PUNCTUATION, 
    KEYWORD, 
    COMMENT, 
    UNKNOWN 
  };
 
  inline std::string token_type_to_string(TokenType type)
  {
    switch (type)
      {
      case TokenType::END_OF_FILE: return "EOF";
      case TokenType::IDENTIFIER: return "IDENTIFIER";
      case TokenType::INTEGER: return "INTEGER";
      case TokenType::FLOAT: return "FLOAT";
      case TokenType::STRING: return "STRING";
      case TokenType::CHAR: return "CHAR";
      case TokenType::OPERATOR: return "OPERATOR";
      case TokenType::PUNCTUATION: return "PUNCTUATION";
      case TokenType::KEYWORD: return "KEYWORD";
      case TokenType::COMMENT: return "COMMENT";
      case TokenType::UNKNOWN: return "UNKNOWN";
      default: return "???";
      }
  }
 
  struct Token
  {
    TokenType type = TokenType::UNKNOWN; 
    std::string value; 
    SourceLocation location; 
 
    Token() = default;
 
    Token(TokenType t, std::string  v, SourceLocation  loc)
      : type(t), value(std::move(v)), location(std::move(loc)) {}
 
    [[nodiscard]] bool is_eof() const { return type == TokenType::END_OF_FILE; }
 
    [[nodiscard]] std::string to_string() const
    {
      return token_type_to_string(type) + "(\"" + value + "\") at " +
             location.to_string();
    }
  };
 
  // ============================================================================
  // File Utilities
  // ============================================================================
 
  inline std::string load_file_contents(const std::string & filename)
  {
    std::ifstream file(filename);
    if (! file.is_open())
      throw std::runtime_error("Cannot open file: " + filename);
 
    std::ostringstream ss;
    ss << file.rdbuf();
    return ss.str();
  }
 
  inline std::vector<std::string> load_file_lines(const std::string & filename)
  {
    std::ifstream file(filename);
    if (not file.is_open())
      throw std::runtime_error("Cannot open file: " + filename);
 
    std::vector<std::string> lines;
    std::string line;
 
    while (std::getline(file, line))
      lines.push_back(line);
 
    return lines;
  }
 
  inline std::vector<std::string> split_string(const std::string & str, char delimiter)
  {
    std::vector<std::string> result;
    std::istringstream iss(str);
    std::string token;
 
    while (std::getline(iss, token, delimiter))
      result.push_back(token);
 
    return result;
  }
} // namespace Aleph
 
// ============================================================================
// Global namespace compatibility (for existing code)
// ============================================================================
 
// Note: input_file_name is NOT exported to global namespace because
// many applications define their own variable with this name.
// Use Aleph::input_file_name if needed.
 
// Global state
using Aleph::Buffer_Size;
using Aleph::current_line_number;
using Aleph::current_col_number;
using Aleph::previous_line_number;
using Aleph::previous_col_number;
using Aleph::token_instance;
 
// Core functions
using Aleph::put_char_in_buffer;
using Aleph::init_token_scanning;
using Aleph::close_token_scanning;
using Aleph::read_char_from_stream;
using Aleph::skip_white_spaces;
using Aleph::load_number;
using Aleph::load_string;
using Aleph::print_parse_error_and_exit;
using Aleph::print_parse_warning;
using Aleph::command_line_to_string;
using Aleph::reset_parse_state;
 
// Source location and errors
using Aleph::SourceLocation;
using Aleph::ParseError;
 
// Lookahead and backtracking
using Aleph::StreamPosition;
using Aleph::peek_char;
using Aleph::mark_position;
using Aleph::restore_position;
 
// Comments
using Aleph::skip_line_comment;
using Aleph::skip_block_comment;
using Aleph::skip_whitespace_and_comments;
 
// Extended numeric parsing
using Aleph::load_double;
using Aleph::load_hex_number;
using Aleph::load_octal_number;
using Aleph::load_binary_number;
 
// Identifiers and keywords
using Aleph::load_identifier;
using Aleph::is_keyword;
 
// Expectations
using Aleph::expect_char;
using Aleph::expect;
using Aleph::try_char;
 
// Extended string parsing
using Aleph::process_escape;
using Aleph::load_escaped_string;
using Aleph::load_char_literal;
 
// Tokens
using Aleph::TokenType;
using Aleph::token_type_to_string;
using Aleph::Token;
 
// File utilities
using Aleph::load_file_contents;
using Aleph::load_file_lines;
using Aleph::split_string;
using Aleph::trim;
 
// ============================================================================
// Legacy Macro (preserved for backward compatibility)
// ============================================================================
 
#define PRINT_ERROR(str, args...) (                                          \
  (std::cout << input_file_name << "("                                       \
             << Aleph::previous_line_number << ","                           \
             << Aleph::previous_col_number << "): " << '\n'),                \
  (std::cout << "Last token: " << Aleph::token_instance << '\n'),            \
  AH_ERROR(str, ##args))
 
#endif // PARSE_UTILS_H