pluto-src 0.1.1+0.10.4

Sources of Pluto (Lua 5.4 dialect) and logic to build it.
Documentation 
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
107
108
109
110
111

#pragma once

#include <optional>
#include <string>
#include <vector>

#include "fwd.hpp"
#include "Regex.hpp"
#include "RegexMatchResult.hpp"

NAMESPACE_SOUP
{
	struct RegexMatcher
	{
		struct RollbackPoint
		{
			const RegexConstraint* c;
			const char* it;
			RegexMatchResult result{};
		};

		const RegexConstraint* c;
		const char* it;
		const char* const begin;
		const char* const end;
		std::vector<RollbackPoint> rollback_points{};
		std::vector<const char*> checkpoints{};
		RegexMatchResult result{};

		RegexMatcher(const Regex& r, const char* begin, const char* end)
			: c(r.group.initial), begin(begin), end(end)
		{
		}

		void reset(const Regex& r) noexcept
		{
			c = r.group.initial;
			rollback_points.clear();
			checkpoints.clear();
			result.groups.clear();
		}

		void saveRollback(const RegexConstraint* rollback_transition)
		{
			rollback_points.emplace_back(RollbackPoint{ rollback_transition, it, result });
		}

		void restoreRollback()
		{
			c = rollback_points.back().c;
			it = rollback_points.back().it;
			result = std::move(rollback_points.back().result);
			rollback_points.pop_back();
		}

		bool shouldSaveCheckpoint() noexcept
		{
			if (reinterpret_cast<uintptr_t>(c) & 0b1)
			{
				c = reinterpret_cast<const RegexConstraint*>(reinterpret_cast<uintptr_t>(c) & ~0b1);
				SOUP_ASSERT(c != nullptr);
				return true;
			}
			return false;
		}

		bool shouldResetCapture() noexcept
		{
			if (reinterpret_cast<uintptr_t>(c) & 0b10)
			{
				c = reinterpret_cast<const RegexConstraint*>(reinterpret_cast<uintptr_t>(c) & ~0b10);
				return true;
			}
			return false;
		}

		void saveCheckpoint()
		{
			checkpoints.emplace_back(it);
		}

		void restoreCheckpoint()
		{
			it = checkpoints.back();
			checkpoints.pop_back();
		}

		void insertMissingCapturingGroups(const RegexGroup* g)
		{
			for (; g; g = g->parent)
			{
				if (g->lookahead_or_lookbehind)
				{
					break;
				}
				if (g->isNonCapturing())
				{
					continue;
				}
				while (g->index >= this->result.groups.size())
				{
					this->result.groups.emplace_back(std::nullopt);
				}
				if (!this->result.groups.at(g->index).has_value())
				{
					this->result.groups.at(g->index) = RegexMatchedGroup{ g->name, this->it, this->it };
				}
			}
		}
	};
}