ArkScript
A small, fast, functional and scripting language for video games
Exceptions.cpp
Go to the documentation of this file.
1#include <Ark/Exceptions.hpp>
2
3#include <cassert>
4#include <sstream>
5#include <algorithm>
6#include <fmt/core.h>
7#include <fmt/color.h>
8#include <fmt/ostream.h>
9
10#include <Ark/Constants.hpp>
11#include <Ark/Utils.hpp>
12#include <Ark/Files.hpp>
13#include <Ark/Literals.hpp>
15
16namespace Ark::Diagnostics
17{
24
25 inline bool isPairableChar(const char c)
26 {
27 return c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || c == '}';
28 }
29
30 void colorizeLine(const std::string& line, LineColorContextCounts& line_color_context_counts, std::ostream& ss)
31 {
32 // clang-format off
33 constexpr std::array pairing_color {
34 fmt::color::light_blue,
35 fmt::color::light_green,
36 fmt::color::light_salmon,
37 fmt::color::light_yellow,
38 fmt::color::light_cyan,
39 fmt::color::light_coral
40 };
41 // clang-format on
42 constexpr std::size_t pairing_color_size = pairing_color.size();
43
44 for (const char& c : line)
45 {
46 if (isPairableChar(c))
47 {
48 std::size_t pairing_color_index = 0;
49
50 switch (c)
51 {
52 case '(':
53 pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_parentheses)) % pairing_color_size;
54 line_color_context_counts.open_parentheses++;
55 break;
56 case ')':
57 line_color_context_counts.open_parentheses--;
58 pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_parentheses)) % pairing_color_size;
59 break;
60 case '[':
61 pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_square_braces)) % pairing_color_size;
62 line_color_context_counts.open_square_braces++;
63 break;
64 case ']':
65 line_color_context_counts.open_square_braces--;
66 pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_square_braces)) % pairing_color_size;
67 break;
68 case '{':
69 pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_curly_braces)) % pairing_color_size;
70 line_color_context_counts.open_curly_braces++;
71 break;
72 case '}':
73 line_color_context_counts.open_curly_braces--;
74 pairing_color_index = static_cast<std::size_t>(std::abs(line_color_context_counts.open_curly_braces)) % pairing_color_size;
75 break;
76 default:
77 break;
78 }
79
80 fmt::print(ss, "{}", fmt::styled(c, fmt::fg(pairing_color[pairing_color_index])));
81 }
82 else
83 fmt::print(ss, "{}", c);
84 }
85 }
86
88 std::ostream& os,
89 const std::string& filename,
90 const std::optional<std::string>& expr,
91 const std::size_t sym_size,
92 const std::size_t target_line,
93 const std::size_t col_start,
94 const std::optional<CodeErrorContext>& maybe_context, // can not be populated at runtime, only compile time
95 const bool whole_line,
96 const bool colorize)
97 {
98 assert(!(maybe_context && whole_line) && "Can not create error context when a context is given AND the whole line has to be underlined");
99
100 using namespace Ark::literals;
101
102 auto show_file_location = [&] {
103 if (filename != ARK_NO_NAME_FILE)
104 fmt::print(os, "In file {}:{}\n", filename, target_line + 1);
105 if (expr)
106 fmt::print(os, "At {} @ {}:{}\n", expr.value(), target_line + 1, col_start);
107 };
108
109 auto compute_start_end_window = [](const std::size_t center_of_window, const std::size_t line_count) {
110 std::size_t start = center_of_window >= 3 ? center_of_window - 3 : 0;
111 std::size_t end = center_of_window + 3 <= line_count ? center_of_window + 3 : line_count;
112 return std::make_pair(start, end);
113 };
114
115 auto print_line = [&os, colorize](const std::size_t i, const std::vector<std::string>& lines, LineColorContextCounts& color_context) {
116 // show current line with its number
117 fmt::print(os, "{: >5} |{}", i + 1, !lines[i].empty() ? " " : "");
118 if (colorize)
119 colorizeLine(lines[i], color_context, os);
120 else
121 fmt::print(os, "{}", lines[i]);
122 fmt::print(os, "\n");
123 };
124
125 const std::string line_no_num = " |";
126
127 auto print_context_hint = [&os, &maybe_context, &line_no_num, colorize]() mutable {
128 if (!maybe_context)
129 return;
130
131 fmt::print(os, "{}", line_no_num);
132 fmt::print(
133 os,
134 "{: <{}}{}\n",
135 // padding os spaces
136 " ",
137 std::max(1_z, maybe_context->col), // fixing padding when the error is on the first character
138 // underline the parent of the error in red
139 fmt::styled(
140 maybe_context->is_macro_expansion ? "^ macro expansion started here" : "^ expression started here",
141 colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
142 };
143
144 const std::string code = filename == ARK_NO_NAME_FILE ? "" : Utils::readFile(filename);
145 const std::vector<std::string> lines = Utils::splitString(code, '\n');
146 if (target_line >= lines.size() || code.empty())
147 {
148 // show the "in file..." before early return
149 show_file_location();
150 return;
151 }
152
153 auto [first_line, last_line] = compute_start_end_window(target_line, lines.size());
154 // number of characters that are on more lines below
155 std::size_t overflow = (col_start + sym_size < lines[target_line].size()) ? 0 : col_start + sym_size - lines[target_line].size();
156
157 const bool ctx_same_file = maybe_context && maybe_context->filename == filename;
158 const bool ctx_in_window = ctx_same_file && maybe_context &&
159 maybe_context->line >= first_line &&
160 maybe_context->line < last_line;
161
162 std::size_t start_line_skipping_at = 0;
163 std::size_t stop_line_skipping_at = first_line;
164 if (ctx_same_file && !ctx_in_window)
165 {
166 // showing the context will require an ellipsis, to avoid showing too many lines in the error message
167 if (maybe_context->line + 3 < first_line)
168 start_line_skipping_at = maybe_context->line + 3;
169 else
170 stop_line_skipping_at = start_line_skipping_at;
171
172 // due to how context works, if it points to the same file,
173 // we are guaranteed it will be before our error
174 first_line = maybe_context->line >= 3 ? maybe_context->line - 3 : 0;
175 }
176 else if (maybe_context && !ctx_same_file && !maybe_context->filename.empty())
177 {
178 // show the location of the parent of our error first
179 fmt::print(os, "Error originated from file {}:{}\n", maybe_context->filename, maybe_context->line + 1);
180
181 const std::vector<std::string> ctx_source_lines = Utils::splitString(Utils::readFile(maybe_context->filename), '\n');
182 auto [ctx_first_line, ctx_last_line] = compute_start_end_window(maybe_context->line, ctx_source_lines.size());
183 LineColorContextCounts line_color_context_counts;
184
185 for (auto i = ctx_first_line; i < ctx_last_line; ++i)
186 {
187 print_line(i, ctx_source_lines, line_color_context_counts);
188 if (i == maybe_context->line)
189 print_context_hint();
190 }
191
192 fmt::print(os, "\n");
193 }
194
195 show_file_location();
196 LineColorContextCounts line_color_context_counts;
197
198 for (auto i = first_line; i < last_line; ++i)
199 {
200 if (i >= start_line_skipping_at && i < stop_line_skipping_at)
201 continue;
202 print_line(i, lines, line_color_context_counts);
203
204 // if the error context is in the current file, point to it as the parent of our error
205 if (maybe_context && i == maybe_context->line && i != target_line)
206 print_context_hint();
207
208 // if the next line number wants us to skip line, and start != stop (meaning they got adjusted),
209 // display an ellipsis
210 if (i + 1 == start_line_skipping_at && i + 1 != stop_line_skipping_at)
211 fmt::print(os, " ... |\n");
212
213 // show where the error occurred (do not mark empty lines as being part of the error when we have overflow)
214 if (i == target_line || (i > target_line && overflow > 0 && !lines[i].empty()))
215 {
216 fmt::print(os, "{}", line_no_num);
217
218 if (!whole_line)
219 {
220 // if we have an overflow then we start at the beginning of the line
221 const std::size_t curr_col_start = (overflow == 0) ? col_start : 0;
222 // if we have an overflow, it is used as the end of the line
223 const std::size_t col_end = (i == target_line) ? std::min<std::size_t>(col_start + sym_size, lines[target_line].size())
224 : std::min<std::size_t>(overflow, lines[i].size());
225 // update the overflow to avoid going here again if not needed
226 overflow = (overflow > lines[i].size()) ? overflow - lines[i].size() : 0;
227
228 // show the error where it's at, using the normal process, if there is no context OR if the context line is different from the error line
229 if (!maybe_context || maybe_context->line != target_line)
230 fmt::print(
231 os,
232 "{: <{}}{:~<{}}\n",
233 // padding of spaces
234 " ",
235 std::max(1_z, curr_col_start), // fixing padding when the error is on the first character
236 // underline the error in red
237 fmt::styled("^", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),
238 col_end - curr_col_start);
239 else if (i == target_line) // maybe_context has a value, i == target_line to avoid having to deal with overflow
240 {
241 const auto padding_size = std::max(1_z, maybe_context->col);
242
243 fmt::print(
244 os,
245 "{: <{}}{}{}{}\n",
246 // padding of spaces
247 " ",
248 padding_size,
249 // indicate where the parent is, with color
250 fmt::styled("│", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),
251 // yet another padding of spaces between the parent and error column (if need be)
252 // -2 to account for the │ and then └
253 (col_start - maybe_context->col <= 2) ? "" : fmt::format("{: <{}}", " ", col_start - maybe_context->col - 2),
254 // underline the error in red
255 fmt::styled("└─ error", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
256 // new line, some spacing between the error and the parent
257 fmt::print(os, "{}{: <{}}{}\n", line_no_num, " ", padding_size, fmt::styled("│", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
258 // new line, now show the "expression started here for the source"
259 fmt::print(
260 os,
261 "{}{: <{}}{}\n",
262 line_no_num,
263 // padding of spaces
264 " ",
265 padding_size,
266 fmt::styled(
267 maybe_context->is_macro_expansion ? "└─ macro expansion started here" : "└─ expression started here",
268 colorize ? fmt::fg(fmt::color::red) : fmt::text_style()));
269 }
270 }
271 else
272 {
273 // first non-whitespace character of the line
274 // +1 for the leading whitespace after ` |` before the code
275 const std::size_t curr_col_start = lines[i].find_first_not_of(" \t\v") + 1;
276
277 // highlight the current line but skip any leading whitespace
278 fmt::print(
279 os,
280 "{: <{}}{:~<{}}\n",
281 // padding of spaces
282 " ",
283 curr_col_start,
284 // underline the whole line in red
285 fmt::styled("^", colorize ? fmt::fg(fmt::color::red) : fmt::text_style()),
286 lines[target_line].size() - curr_col_start);
287 }
288 }
289 }
290 }
291
292 void helper(std::ostream& os, const std::string& message, const bool colorize,
293 const std::string& filename,
294 const std::optional<std::string>& expr, const std::size_t sym_size,
295 const std::size_t line, const std::size_t column,
296 const std::optional<CodeErrorContext>& maybe_context = std::nullopt)
297 {
298 makeContext(os, filename, expr, sym_size, line, column, maybe_context, /* whole_line= */ false, colorize);
299
300 const auto message_lines = Utils::splitString(message, '\n');
301 for (const auto& text : message_lines)
302 fmt::print(os, " {}\n", text);
303 }
304
305 std::string makeContextWithNode(const std::string& message, const internal::Node& node)
306 {
307 std::stringstream ss;
308
309 std::size_t size = 3;
310 if (node.isStringLike())
311 size = node.string().size();
312
313 helper(
314 ss,
315 message,
316 true,
317 node.filename(),
318 node.repr(),
319 size,
320 node.line(),
321 node.col());
322
323 return ss.str();
324 }
325
326 void generate(const CodeError& e, std::ostream& os, bool colorize)
327 {
328#ifdef ARK_BUILD_EXE
329 if (const char* nocolor = std::getenv("NOCOLOR"); nocolor != nullptr)
330 colorize = false;
331#endif
332
333 std::string escaped_symbol;
334 if (e.context.symbol.has_value())
335 {
336 switch (e.context.symbol.value().codepoint())
337 {
338 case '\n': escaped_symbol = "'\\n'"; break;
339 case '\r': escaped_symbol = "'\\r'"; break;
340 case '\t': escaped_symbol = "'\\t'"; break;
341 case '\v': escaped_symbol = "'\\v'"; break;
342 case '\0': escaped_symbol = "EOF"; break;
343 case ' ': escaped_symbol = "' '"; break;
344 default:
345 escaped_symbol = e.context.symbol.value().c_str();
346 }
347 }
348 else
349 escaped_symbol = e.context.expr;
350
351 helper(
352 os,
353 e.what(),
354 colorize,
356 escaped_symbol,
357 e.context.expr.size(),
358 e.context.line,
359 e.context.col,
361 }
362}
Lots of utilities about string, filesystem and more.
Constants used by ArkScript.
#define ARK_NO_NAME_FILE
Definition Constants.hpp:26
ArkScript homemade exceptions.
Lots of utilities about the filesystem.
User defined literals for Ark internals.
AST node used by the parser, optimizer and compiler.
A node of an Abstract Syntax Tree for ArkScript.
Definition Node.hpp:30
const std::string & filename() const noexcept
Return the filename in which this node was created.
Definition Node.cpp:145
const std::string & string() const noexcept
Return the string held by the value (if the node type allows it)
Definition Node.cpp:37
std::string repr() const noexcept
Compute a representation of the node without any comments or additional sugar, colors,...
Definition Node.cpp:160
std::size_t col() const noexcept
Get the column at which this node was created.
Definition Node.cpp:140
bool isStringLike() const noexcept
Check if the node is a string like node.
Definition Node.cpp:87
std::size_t line() const noexcept
Get the line at which this node was created.
Definition Node.cpp:135
bool isPairableChar(const char c)
void helper(std::ostream &os, const std::string &message, const bool colorize, const std::string &filename, const std::optional< std::string > &expr, const std::size_t sym_size, const std::size_t line, const std::size_t column, const std::optional< CodeErrorContext > &maybe_context=std::nullopt)
void colorizeLine(const std::string &line, LineColorContextCounts &line_color_context_counts, std::ostream &ss)
ARK_API void generate(const CodeError &e, std::ostream &os=std::cout, bool colorize=true)
Generate a diagnostic from an error and print it to the standard output.
ARK_API std::string makeContextWithNode(const std::string &message, const internal::Node &node)
Helper used by the compiler to generate a colorized context from a node.
ARK_API void makeContext(std::ostream &os, const std::string &filename, const std::optional< std::string > &expr, std::size_t sym_size, std::size_t target_line, std::size_t col_start, const std::optional< CodeErrorContext > &maybe_context, bool whole_line, bool colorize)
Helper to create a colorized context to report errors to the user.
std::string readFile(const std::string &name)
Helper to read a file.
Definition Files.hpp:47
std::vector< std::string > splitString(const std::string &source, const char sep)
Cut a string into pieces, given a character separator.
Definition Utils.hpp:31
const std::size_t line
const std::string expr
const std::size_t col
const std::string filename
const std::optional< internal::utf8_char_t > symbol
CodeError thrown by the compiler (parser, macro processor, optimizer, and compiler itself)
const std::optional< CodeErrorContext > additional_context
const CodeErrorContext context