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";
 
  const 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;
  const 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))
            {
              input_stream.unget();
              close_token_scanning(buffer, start_addr, end_addr);
              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_;
  }
};
 
#define ah_parse_error()                                                                           \
  Aleph::ExceptionBuilder<Aleph::ParseError>(),                                                    \
    std::ostringstream() << "(" << __FILE__ << ":" << __LINE__ << ") | "
 
#define ah_parse_error_if(C)                                                                       \
  if (C) [[unlikely]]                                                                              \
  Aleph::ExceptionBuilder<Aleph::ParseError>(),                                                    \
    std::ostringstream() << "(" << __FILE__ << ":" << __LINE__ << ") | "
 
#define ah_parse_error_unless(C)                                                                   \
  if (not (C)) [[unlikely]]                                                                        \
  Aleph::ExceptionBuilder<Aleph::ParseError>(),                                                    \
    std::ostringstream() << "(" << __FILE__ << ":" << __LINE__ << ") | "
 
// ============================================================================
// 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;
        }
    }
 
  ah_parse_error() << "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);
        }
    }
 
  ah_parse_error_unless(has_digits) << "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);
        }
 
      ah_parse_error_unless(std::isdigit(c)) << "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 (only if it is a real character, not EOF)
  if (c != EOF)
    {
      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'
  ah_parse_error_unless(c == '0') << "Hexadecimal number must start with 0x";
 
  c = read_char_from_stream(input_stream);
  ah_parse_error_unless(c == 'x' or c == 'X') << "Hexadecimal number must start with 0x";
 
  c = read_char_from_stream(input_stream);
 
  ah_parse_error_unless(std::isxdigit(c)) << "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);
 
  ah_parse_error_unless(c == '0') << "Octal number must start with 0";
 
  c = read_char_from_stream(input_stream);
 
  // Check it's not hex (0x)
  ah_parse_error_if(c == 'x' or c == 'X') << "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;
  const char *end = buffer + Buffer_Size;
 
  init_token_scanning();
  skip_white_spaces(input_stream);
 
  int c = read_char_from_stream(input_stream);
 
  ah_parse_error_unless(c == '0') << "Binary number must start with 0b";
 
  c = read_char_from_stream(input_stream);
  ah_parse_error_unless(c == 'b' or c == 'B') << "Binary number must start with 0b";
 
  c = read_char_from_stream(input_stream);
 
  ah_parse_error_unless(c == '0' or c == '1') << "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;
  const 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
  ah_parse_error_unless(std::isalpha(c) or c == '_')
    << "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);
  const int c = read_char_from_stream(input_stream);
  ah_parse_error_unless(c == expected)
    << "Expected '" << expected << "' but found '" << static_cast<char>(c) << "'";
}
 
inline void expect(std::ifstream &input_stream, const std::string &expected)
{
  skip_white_spaces(input_stream);
  init_token_scanning();
 
  for (const char ch : expected)
    {
      const int c = read_char_from_stream(input_stream);
      ah_parse_error_unless(c == ch) << "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);
 
  ah_parse_error_unless(c == '"') << "Expected '\"' to start string";
 
  while (true)
    {
      c = read_char_from_stream(input_stream);
 
      ah_parse_error_if(c == EOF) << "Unterminated string literal";
 
      if (c == '"')
        break;
 
      if (c == '\\')
        {
          c = read_char_from_stream(input_stream);
          ah_parse_error_if(c == EOF) << "Unterminated escape sequence";
          c = static_cast<unsigned char>(process_escape(c));
        }
 
      put_char_in_buffer(ptr, end, c);
    }
 
  const size_t len = ptr - buffer;
  close_token_scanning(buffer, ptr, end);
  return std::string(buffer, len);
}
 
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);
 
  ah_parse_error_unless(c == '\'') << "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);
  ah_parse_error_unless(c == '\'') << "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);
  ah_runtime_error_unless(file.is_open()) << "Cannot open file: " << filename;
 
  std::ostringstream ss;
  ss << file.rdbuf();
  return ss.str();
}
 
inline DynList<std::string> load_file_lines(const std::string &filename)
{
  std::ifstream file(filename);
  ah_runtime_error_unless(file.is_open()) << "Cannot open file: " << filename;
 
  DynList<std::string> lines;
  std::string line;
 
  while (std::getline(file, line))
    lines.append(line);
 
  return lines;
}
 
inline DynList<std::string> split_string(const std::string &str, char delimiter)
{
  DynList<std::string> result;
  std::istringstream iss(str);
  std::string token;
 
  while (std::getline(iss, token, delimiter))
    result.append(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_col_number;
using Aleph::current_line_number;
using Aleph::previous_col_number;
using Aleph::previous_line_number;
using Aleph::token_instance;
 
// Core functions
using Aleph::close_token_scanning;
using Aleph::command_line_to_string;
using Aleph::init_token_scanning;
using Aleph::load_number;
using Aleph::load_string;
using Aleph::print_parse_error_and_exit;
using Aleph::print_parse_warning;
using Aleph::put_char_in_buffer;
using Aleph::read_char_from_stream;
using Aleph::reset_parse_state;
using Aleph::skip_white_spaces;
 
// Source location and errors
using Aleph::ParseError;
using Aleph::SourceLocation;
 
// Lookahead and backtracking
using Aleph::mark_position;
using Aleph::peek_char;
using Aleph::restore_position;
using Aleph::StreamPosition;
 
// Comments
using Aleph::skip_block_comment;
using Aleph::skip_line_comment;
using Aleph::skip_whitespace_and_comments;
 
// Extended numeric parsing
using Aleph::load_binary_number;
using Aleph::load_double;
using Aleph::load_hex_number;
using Aleph::load_octal_number;
 
// Identifiers and keywords
using Aleph::is_keyword;
using Aleph::load_identifier;
 
// Expectations
using Aleph::expect;
using Aleph::expect_char;
using Aleph::try_char;
 
// Extended string parsing
using Aleph::load_char_literal;
using Aleph::load_escaped_string;
using Aleph::process_escape;
 
// Tokens
using Aleph::Token;
using Aleph::token_type_to_string;
using Aleph::TokenType;
 
// 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(...)                                                                           \
  ((std::cout << input_file_name << "(" << Aleph::previous_line_number << ","                      \
              << Aleph::previous_col_number << "): " << '\n'),                                     \
   (std::cout << "Last token: " << Aleph::token_instance << '\n'), AH_ERROR(__VA_ARGS__))
 
#endif  // PARSE_UTILS_H