aboutsummaryrefslogtreecommitdiff
path: root/src/openvic-dataloader/detail/LexyReportError.hpp
blob: 213090bc0749c608e8f837fd54147272374f4d36 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#pragma once

#include <cstddef>
#include <sstream>
#include <utility>
#include <vector>

#include <openvic-dataloader/ParseData.hpp>
#include <openvic-dataloader/ParseError.hpp>
#include <openvic-dataloader/detail/Concepts.hpp>

#include <lexy/input_location.hpp>
#include <lexy/visualize.hpp>

#include <lexy_ext/report_error.hpp>

namespace ovdl::detail {
   template<typename OutputIterator>
   struct _ReportError {
      OutputIterator _iter;
      lexy::visualization_options _opts;
      const char* _path;

      struct _sink {
         OutputIterator _iter;
         lexy::visualization_options _opts;
         const char* _path;
         std::size_t _count;
         std::vector<ParseError> _errors;

         using return_type = std::vector<ParseError>;

         template<typename Input, typename Reader, typename Tag>
         void operator()(const lexy::error_context<Input>& context, const lexy::error<Reader, Tag>& error) {
            _iter = lexy_ext::_detail::write_error(_iter, context, error, _opts, _path);
            ++_count;

            // Convert the context location and error location into line/column information.
            auto context_location = lexy::get_input_location(context.input(), context.position());
            auto location = lexy::get_input_location(context.input(), error.position(), context_location.anchor());

            std::basic_stringstream<typename Reader::encoding::char_type> message;

            // Write the main annotation.
            if constexpr (std::is_same_v<Tag, lexy::expected_literal>) {
               auto string = lexy::_detail::make_literal_lexeme<typename Reader::encoding>(error.string(), error.length());

               message << "expected '" << string.data() << '\'';
            } else if constexpr (std::is_same_v<Tag, lexy::expected_keyword>) {
               auto string = lexy::_detail::make_literal_lexeme<typename Reader::encoding>(error.string(), error.length());

               message << "expected keyword '" << string.data() << '\'';
            } else if constexpr (std::is_same_v<Tag, lexy::expected_char_class>) {
               message << "expected " << error.name();
            } else {
               message << error.message();
            }

            _errors.push_back(
               ParseError {
                  ParseError::Type::Fatal, // TODO: distinguish recoverable errors from fatal errors
                  std::move(message.str()),
                  0, // TODO: implement proper error codes
                  ParseData {
                     context.production(),
                     context_location.line_nr(),
                     context_location.column_nr(),
                  },
                  location.line_nr(),
                  location.column_nr(),
               });
         }

         return_type finish() && {
            if (_count != 0)
               *_iter++ = '\n';
            return _errors;
         }
      };
      constexpr auto sink() const {
         return _sink { _iter, _opts, _path, 0 };
      }

      /// Specifies a path that will be printed alongside the diagnostic.
      constexpr _ReportError path(const char* path) const {
         return { _iter, _opts, path };
      }

      constexpr _ReportError path(const detail::Has_c_str auto& path_object) const {
         return path(path_object.c_str());
      }

      /// Specifies an output iterator where the errors are written to.
      template<typename OI>
      constexpr _ReportError<OI> to(OI out) const {
         return { out, _opts, _path };
      }

      /// Overrides visualization options.
      constexpr _ReportError opts(lexy::visualization_options opts) const {
         return { _iter, opts, _path };
      }
   };

   constexpr auto ReporError = _ReportError<lexy::stderr_output_iterator> {};
}