header_parser.hpp

Go to the documentation of this file.

/*
   This file is part of PLYwoot, a header-only PLY parser.
 
   Copyright (C) 2023-2025, Ton van den Heuvel
 
   PLYwoot 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 <http://www.gnu.org/licenses/>.
*/
 
#ifndef PLYWOOT_HEADER_PARSER_HPP
#define PLYWOOT_HEADER_PARSER_HPP
 
 
#include "exceptions.hpp"
#include "header_scanner.hpp"
#include "header_scanner_ios.hpp"
#include "std.hpp"
#include "types.hpp"
 
#include <cassert>
#include <cstdint>
#include <istream>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
 
namespace plywoot {
 
struct HeaderParserException : Exception
{
  HeaderParserException(const std::string &message) : Exception("parser error: " + message) {}
};
 
struct InvalidFormat : HeaderParserException
{
  InvalidFormat(const std::string &format) : HeaderParserException("invalid format found: " + format) {}
};
 
struct UnexpectedToken : HeaderParserException
{
  UnexpectedToken(
      detail::HeaderScanner::Token expected,
      detail::HeaderScanner::Token found,
      const std::string &tokenString)
      : UnexpectedToken(std::vector{expected}, found, tokenString)
  {
  }
 
  UnexpectedToken(
      std::vector<detail::HeaderScanner::Token> expected,
      detail::HeaderScanner::Token found,
      const std::string &tokenString)
      : HeaderParserException(
            "unexpected token '" + detail::to_string(found) + "' found, expected a token in the set {" +
            std::accumulate(
                std::next(expected.begin()),
                expected.end(),
                expected.empty() ? std::string() : detail::to_string(expected.front()),
                [](auto &&x, auto &&y) {
                  return x + ", " + detail::to_string(std::forward<decltype(y)>(y));
                }) +
            "} instead"),
        expected_{std::move(expected)},
        found_{found}
  {
  }
 
  const std::vector<detail::HeaderScanner::Token> &expected() const { return expected_; }
  detail::HeaderScanner::Token found() const { return found_; }
 
private:
  std::vector<detail::HeaderScanner::Token> expected_;
  detail::HeaderScanner::Token found_;
};
 
}
 
namespace plywoot::detail {
 
class HeaderParser
{
  using Token = detail::HeaderScanner::Token;
 
public:
  HeaderParser(std::istream &is) : scanner_{is}
  {
    accept(Token::MagicNumber);
 
    // Parse the format section.
    accept(Token::Format);
    switch (scanner_.nextToken())
    {
      case Token::Ascii:
        format_ = PlyFormat::Ascii;
        break;
      case Token::BinaryLittleEndian:
        format_ = PlyFormat::BinaryLittleEndian;
        break;
      case Token::BinaryBigEndian:
        format_ = PlyFormat::BinaryBigEndian;
        break;
      default:
        throw InvalidFormat(scanner_.tokenString());
    }
    scanner_.nextToken();  // ignore the format version
 
    // Ignore comment section for now.
    while (scanner_.nextToken() == Token::Comment) { comments_.push_back(scanner_.comment()); }
 
    // Parse elements.
    do {
      switch (scanner_.token())
      {
        case Token::EndHeader:
          break;
        case Token::Element:
          elements_.push_back(parseElement());
          break;
        case Token::Comment:
          comments_.push_back(scanner_.comment());
          scanner_.nextToken();
          break;
        default:
          throw UnexpectedToken(
              {Token::EndHeader, Token::Element, Token::Comment}, scanner_.token(), scanner_.tokenString());
          break;
      }
    } while (scanner_.token() != Token::EndHeader);
  }
 
  const std::vector<Comment> &comments() const { return comments_; }
  const std::vector<PlyElement> &elements() const { return elements_; }
 
  PlyFormat format() const { return format_; }
 
private:
  void accept(Token expected)
  {
    if (scanner_.nextToken() != expected)
    {
      // In case an identifier token is expected, all reserved keywords are
      // acceptable as well.
      if (!(expected == Token::Identifier && scanner_.isKeyword(scanner_.token())))
      {
        throw UnexpectedToken(expected, scanner_.token(), scanner_.tokenString());
      }
    }
  }
 
  PlyDataType tokenToDataType(Token t) const
  {
    switch (t)
    {
      case Token::Char:
        return PlyDataType::Char;
      case Token::UChar:
        return PlyDataType::UChar;
      case Token::Short:
        return PlyDataType::Short;
      case Token::UShort:
        return PlyDataType::UShort;
      case Token::Int:
        return PlyDataType::Int;
      case Token::UInt:
        return PlyDataType::UInt;
      case Token::Float:
        return PlyDataType::Float;
      case Token::Double:
        return PlyDataType::Double;
      default:
        throw UnexpectedToken(
            {Token::Char, Token::UChar, Token::Short, Token::UShort, Token::Int, Token::UInt, Token::Float,
             Token::Double},
            t, scanner_.tokenString());
    }
  }
 
  PlyElement parseElement()
  {
    accept(Token::Identifier);  // name of the elements
    std::string name{scanner_.tokenString()};
 
    accept(Token::Number);
    std::size_t size{scanner_.tokenNumber()};
 
    PlyElement result{std::move(name), size};
 
    // Parse properties.
    while (scanner_.nextToken() == Token::Property || scanner_.token() == Token::Comment)
    {
      if (scanner_.token() == Token::Property)
      {
        PlyDataType type;
        PlyDataType sizeType;
 
        // TODO(ton): probably reserved keywords may be used as names as well,
        // just accept every token here, even numbers?
        switch (scanner_.nextToken())
        {
          case Token::List:
            sizeType = tokenToDataType(scanner_.nextToken());
            type = tokenToDataType(scanner_.nextToken());
            accept(Token::Identifier);
            result.addProperty(scanner_.tokenString(), type, sizeType);
            break;
          default:
            type = tokenToDataType(scanner_.token());
            accept(Token::Identifier);
            result.addProperty(scanner_.tokenString(), type);
            break;
        }
      }
      else
      {
        assert(scanner_.token() == Token::Comment);
        comments_.push_back(scanner_.comment());
      }
    }
 
    return result;
  }
 
  std::vector<Comment> comments_;
  PlyFormat format_;
  std::vector<PlyElement> elements_;
  detail::HeaderScanner scanner_;
};
 
}
 
#endif