From bbd7e604dcd5a66f2063db7cf3752ad105252707 Mon Sep 17 00:00:00 2001 From: Maxime Coste Date: Mon, 23 Oct 2017 15:45:43 +0800 Subject: [PATCH] Regex: Remove "Ast" from names in the ParsedRegex It does not add much value, and makes names longer. --- src/regex_impl.cc | 76 +++++++++++++++++++++++------------------------ 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/src/regex_impl.cc b/src/regex_impl.cc index 52144762..821d6782 100644 --- a/src/regex_impl.cc +++ b/src/regex_impl.cc @@ -67,19 +67,19 @@ struct ParsedRegex }; }; - struct AstNode; - using AstNodeIndex = uint16_t; + struct Node; + using NodeIndex = uint16_t; - struct AstNode + struct Node { Op op; bool ignore_case; - AstNodeIndex children_end; + NodeIndex children_end; Codepoint value; Quantifier quantifier; }; - Vector nodes; + Vector nodes; size_t capture_count; Vector, MemoryDomain::Regex> matchers; }; @@ -87,7 +87,7 @@ struct ParsedRegex namespace { template -bool for_each_child(const ParsedRegex& parsed_regex, ParsedRegex::AstNodeIndex index, Func&& func) +bool for_each_child(const ParsedRegex& parsed_regex, ParsedRegex::NodeIndex index, Func&& func) { const auto end = parsed_regex.nodes[index].children_end; for (auto child = index+1; child != end; @@ -100,9 +100,9 @@ bool for_each_child(const ParsedRegex& parsed_regex, ParsedRegex::AstNodeIndex i } template -bool for_each_child_reverse(const ParsedRegex& parsed_regex, ParsedRegex::AstNodeIndex index, Func&& func) +bool for_each_child_reverse(const ParsedRegex& parsed_regex, ParsedRegex::NodeIndex index, Func&& func) { - auto find_last_child = [&](ParsedRegex::AstNodeIndex begin, ParsedRegex::AstNodeIndex end) { + auto find_last_child = [&](ParsedRegex::NodeIndex begin, ParsedRegex::NodeIndex end) { while (parsed_regex.nodes[begin].children_end != end) begin = parsed_regex.nodes[begin].children_end; return begin; @@ -128,7 +128,7 @@ struct RegexParser : m_regex{re}, m_pos{re.begin(), re} { m_parsed_regex.capture_count = 1; - AstNodeIndex root = disjunction(0); + NodeIndex root = disjunction(0); kak_assert(root == 0); } @@ -143,11 +143,11 @@ private: }; using Iterator = utf8::iterator; - using AstNodeIndex = ParsedRegex::AstNodeIndex; + using NodeIndex = ParsedRegex::NodeIndex; - AstNodeIndex disjunction(unsigned capture = -1) + NodeIndex disjunction(unsigned capture = -1) { - AstNodeIndex index = new_node(ParsedRegex::Alternation); + NodeIndex index = new_node(ParsedRegex::Alternation); get_node(index).value = capture; while (true) { @@ -161,9 +161,9 @@ private: return index; } - AstNodeIndex alternative(ParsedRegex::Op op = ParsedRegex::Sequence) + NodeIndex alternative(ParsedRegex::Op op = ParsedRegex::Sequence) { - AstNodeIndex index = new_node(op); + NodeIndex index = new_node(op); while (auto t = term()) {} get_node(index).children_end = m_parsed_regex.nodes.size(); @@ -171,7 +171,7 @@ private: return index; } - Optional term() + Optional term() { while (modifiers()) // read all modifiers {} @@ -212,7 +212,7 @@ private: return false; } - Optional assertion() + Optional assertion() { if (at_end()) return {}; @@ -253,7 +253,7 @@ private: if (not lookaround_op) return {}; - AstNodeIndex lookaround = alternative(*lookaround_op); + NodeIndex lookaround = alternative(*lookaround_op); if (at_end() or *m_pos++ != ')') parse_error("unclosed parenthesis"); @@ -264,7 +264,7 @@ private: return {}; } - Optional atom() + Optional atom() { if (at_end()) return {}; @@ -277,7 +277,7 @@ private: { ++m_pos; const bool capture = not accept("?:"); - AstNodeIndex content = disjunction(capture ? m_parsed_regex.capture_count++ : -1); + NodeIndex content = disjunction(capture ? m_parsed_regex.capture_count++ : -1); if (at_end() or *m_pos++ != ')') parse_error("unclosed parenthesis"); return content; @@ -298,7 +298,7 @@ private: } } - AstNodeIndex atom_escape() + NodeIndex atom_escape() { const Codepoint cp = *m_pos++; @@ -409,7 +409,7 @@ private: ranges.erase(pos+1, ranges.end()); } - AstNodeIndex character_class() + NodeIndex character_class() { const bool negative = m_pos != m_regex.end() and *m_pos == '^'; if (negative) @@ -580,21 +580,21 @@ private: } } - AstNodeIndex new_node(ParsedRegex::Op op, Codepoint value = -1, + NodeIndex new_node(ParsedRegex::Op op, Codepoint value = -1, ParsedRegex::Quantifier quantifier = {ParsedRegex::Quantifier::One}) { constexpr auto max_nodes = std::numeric_limits::max(); - const AstNodeIndex res = m_parsed_regex.nodes.size(); + const NodeIndex res = m_parsed_regex.nodes.size(); if (res == max_nodes) parse_error(format("regex parsed to more than {} ast nodes", max_nodes)); - const AstNodeIndex next = res+1; + const NodeIndex next = res+1; m_parsed_regex.nodes.push_back({op, m_ignore_case, next, value, quantifier}); return res; } bool at_end() const { return m_pos == m_regex.end(); } - ParsedRegex::AstNode& get_node(AstNodeIndex index) + ParsedRegex::Node& get_node(NodeIndex index) { return m_parsed_regex.nodes[index]; } @@ -608,9 +608,9 @@ private: StringView{m_pos.base(), m_regex.end()})); } - void validate_lookaround(AstNodeIndex index) + void validate_lookaround(NodeIndex index) { - for_each_child(m_parsed_regex, index, [this](AstNodeIndex child_index) { + for_each_child(m_parsed_regex, index, [this](NodeIndex child_index) { auto& child = get_node(child_index); if (child.op != ParsedRegex::Literal and child.op != ParsedRegex::Matcher and child.op != ParsedRegex::AnyChar) @@ -671,7 +671,7 @@ struct RegexCompiler private: - uint32_t compile_node_inner(ParsedRegex::AstNodeIndex index) + uint32_t compile_node_inner(ParsedRegex::NodeIndex index) { auto& node = get_node(index); @@ -701,11 +701,11 @@ private: case ParsedRegex::Sequence: { if (m_forward) - for_each_child(m_parsed_regex, index, [this](ParsedRegex::AstNodeIndex child) { + for_each_child(m_parsed_regex, index, [this](ParsedRegex::NodeIndex child) { compile_node(child); return true; }); else - for_each_child_reverse(m_parsed_regex, index, [this](ParsedRegex::AstNodeIndex child) { + for_each_child_reverse(m_parsed_regex, index, [this](ParsedRegex::NodeIndex child) { compile_node(child); return true; }); break; @@ -715,14 +715,14 @@ private: //kak_assert(children.size() > 1); auto split_pos = m_program.instructions.size(); - for_each_child(m_parsed_regex, index, [this, index](ParsedRegex::AstNodeIndex child) { + for_each_child(m_parsed_regex, index, [this, index](ParsedRegex::NodeIndex child) { if (child != index+1) push_inst(CompiledRegex::Split_PrioritizeParent); return true; }); for_each_child(m_parsed_regex, index, - [&, end = node.children_end](ParsedRegex::AstNodeIndex child) { + [&, end = node.children_end](ParsedRegex::NodeIndex child) { auto node = compile_node(child); if (child != index+1) m_program.instructions[split_pos++].param = node; @@ -799,7 +799,7 @@ private: return start_pos; } - uint32_t compile_node(ParsedRegex::AstNodeIndex index) + uint32_t compile_node(ParsedRegex::NodeIndex index) { auto& node = get_node(index); @@ -863,10 +863,10 @@ private: return res; } - uint32_t push_lookaround(ParsedRegex::AstNodeIndex index, bool reversed, bool ignore_case) + uint32_t push_lookaround(ParsedRegex::NodeIndex index, bool reversed, bool ignore_case) { uint32_t res = m_program.lookarounds.size(); - auto write_matcher = [this, ignore_case](ParsedRegex::AstNodeIndex child) { + auto write_matcher = [this, ignore_case](ParsedRegex::NodeIndex child) { auto& character = get_node(child); if (character.op == ParsedRegex::Literal) m_program.lookarounds.push_back(ignore_case ? to_lower(character.value) @@ -892,7 +892,7 @@ private: // Fills accepted and rejected according to which chars can start the given node, // returns true if the node did not consume the char, hence a following node in // sequence would be still relevant for the parent node start chars computation. - bool compute_start_chars(ParsedRegex::AstNodeIndex index, + bool compute_start_chars(ParsedRegex::NodeIndex index, CompiledRegex::StartChars& start_chars) const { auto& node = get_node(index); @@ -939,7 +939,7 @@ private: case ParsedRegex::Alternation: { bool all_consumed = not node.quantifier.allows_none(); - for_each_child(m_parsed_regex, index, [&](ParsedRegex::AstNodeIndex child) { + for_each_child(m_parsed_regex, index, [&](ParsedRegex::NodeIndex child) { if (compute_start_chars(child, start_chars)) all_consumed = false; return true; @@ -975,7 +975,7 @@ private: return std::make_unique(start_chars); } - const ParsedRegex::AstNode& get_node(ParsedRegex::AstNodeIndex index) const + const ParsedRegex::Node& get_node(ParsedRegex::NodeIndex index) const { return m_parsed_regex.nodes[index]; }