Less complex regexes

.github/workflows/run-tests.yml

@@ -12,8 +12,8 @@ jobs:
       - uses: actions/checkout@v6
       - uses: lukka/get-cmake@latest
         with:
-          cmakeVersion: "~3.25.0"
-          ninjaVersion: "^1.11.1"
+          cmakeVersion: "~4.2.0"  # <--= optional, use most recent 4.2.x version
+          ninjaVersion: "^1.11.1"  # <--= optional, use most recent 1.x version
       - name: build
         run: |
           mkdir tmp
@@ -39,13 +39,13 @@ jobs:
       - uses: actions/checkout@v6
       - uses: lukka/get-cmake@latest
         with:
-          cmakeVersion: "~3.25.0"
-          ninjaVersion: "^1.11.1"
+          cmakeVersion: "~4.2.0"  # <--= optional, use most recent 4.2.x version
+          ninjaVersion: "^1.11.1"  # <--= optional, use most recent 1.x version
       - name: build
         run: |
           mkdir tmp
           cd tmp
-          cmake -G "Visual Studio 17 2022" -A x64 -DMADDY_BUILD_WITH_TESTS=ON ..
+          cmake -G "Visual Studio 18 2026" -A x64 -DMADDY_BUILD_WITH_TESTS=ON ..
           cmake --build . --config Debug
       - name: run tests
         run: |
@@ -57,8 +57,8 @@ jobs:
       - uses: actions/checkout@v6
       - uses: lukka/get-cmake@latest
         with:
-          cmakeVersion: "~3.25.0"
-          ninjaVersion: "^1.11.1"
+          cmakeVersion: "~4.2.0"  # <--= optional, use most recent 4.2.x version
+          ninjaVersion: "^1.11.1"  # <--= optional, use most recent 1.x version
       - name: build
         run: |
           mkdir tmp

CHANGELOG.md

@@ -14,6 +14,9 @@ maddy uses [semver versioning](https://semver.org/).
 
 ## Upcoming
 
+* ![**ADDED**](https://img.shields.io/badge/-ADDED-%23099) New `maddy::types::MADDY_SPECIFIC_PARSER` config flag (on by default, keeping current behavior). Turning it off switches `TableParser` from maddy's own `|table>` sigil syntax to standard GitHub-flavored-Markdown pipe tables (which have no footer concept).
+* ![**FIXED**](https://img.shields.io/badge/-FIXED-%23090) Only create strong and emphasis tags at word boundaries, i.e. `not only_internal_underscores`.
+* ![**FIXED**](https://img.shields.io/badge/-FIXED-%23090) Correctly leave any leftover strong or emphasis delimiters outside the tag on either side, however many there are, i.e. `___text__` becomes `_<strong>text</strong>` and `_text_______` becomes `<em>text</em>______`.
 * ...
 
 ## version 1.6.0 2025-07-26

docs/definitions.md

@@ -385,6 +385,53 @@ becomes
 ```
 table header and footer are optional
 
+This is maddy's own historical table syntax, and it's used by default
+(`maddy::types::MADDY_SPECIFIC_PARSER`). If you need standard
+GitHub-flavored-Markdown pipe tables instead, disable it in config:
+
+```cpp
+std::shared_ptr<maddy::ParserConfig> config = std::make_shared<maddy::ParserConfig>();
+config->enabledParsers &= ~maddy::types::MADDY_SPECIFIC_PARSER;
+
+std::shared_ptr<maddy::Parser> parser = std::make_shared<maddy::Parser>(config);
+std::string htmlOutput = parser->Parse(markdownInput);
+```
+
+After this, tables look like:
+
+```
+| Left header | middle header | last header |
+| --- | --- | --- |
+| cell 1 | cell 2 | cell 3 |
+| cell 4 | cell 5 | cell 6 |
+```
+becomes
+```html
+<table>
+  <thead>
+    <tr>
+      <th>Left header</th>
+      <th>middle header</th>
+      <th>last header</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>cell 1</td>
+      <td>cell 2</td>
+      <td>cell 3</td>
+    </tr>
+    <tr>
+      <td>cell 4</td>
+      <td>cell 5</td>
+      <td>cell 6</td>
+    </tr>
+  </tbody>
+</table>
+```
+GFM pipe tables have no footer concept, so this mode never produces a
+`<tfoot>`.
+
 ## LaTeX(MathJax) block support
 
 To turn on the LaTeX support - which basically is only a

include/maddy/codespanutils.h

@@ -0,0 +1,139 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#pragma once
+
+// -----------------------------------------------------------------------------
+
+#include <cstddef>
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
+// -----------------------------------------------------------------------------
+
+namespace maddy {
+
+// -----------------------------------------------------------------------------
+
+/**
+ * FindProtectedSpans
+ *
+ * Finds non-overlapping [start, end) ranges of a line that inline
+ * delimiter parsers (strong, emphasized, strikethrough, italic) must not
+ * alter: a `<code>...</code>` HTML span, or a code span delimited by a
+ * run of N backtick characters and a later run of exactly N backticks
+ * (per CommonMark, a run with no matching close is ordinary text, and
+ * scanning resumes right after it).
+ *
+ * @method
+ * @param {const std::string&} line
+ * @return {std::vector<std::pair<std::size_t, std::size_t>>}
+ */
+inline std::vector<std::pair<std::size_t, std::size_t>> FindProtectedSpans(
+  const std::string& line
+)
+{
+  static const std::string openCodeTag = "<code>";
+  static const std::string closeCodeTag = "</code>";
+
+  std::vector<std::pair<std::size_t, std::size_t>> spans;
+  std::size_t i = 0;
+
+  while (i < line.size())
+  {
+    if (line.compare(i, openCodeTag.size(), openCodeTag) == 0)
+    {
+      std::size_t closeStart = line.find(closeCodeTag, i + openCodeTag.size());
+      if (closeStart != std::string::npos)
+      {
+        std::size_t end = closeStart + closeCodeTag.size();
+        spans.emplace_back(i, end);
+        i = end;
+        continue;
+      }
+    }
+
+    if (line[i] == '`')
+    {
+      std::size_t runStart = i;
+      while (i < line.size() && line[i] == '`')
+      {
+        ++i;
+      }
+      std::size_t runLength = i - runStart;
+
+      std::size_t searchPos = i;
+      while (searchPos < line.size())
+      {
+        std::size_t closeStart = line.find('`', searchPos);
+        if (closeStart == std::string::npos)
+        {
+          break;
+        }
+
+        std::size_t closeEnd = closeStart;
+        while (closeEnd < line.size() && line[closeEnd] == '`')
+        {
+          ++closeEnd;
+        }
+
+        if (closeEnd - closeStart == runLength)
+        {
+          spans.emplace_back(runStart, closeEnd);
+          i = closeEnd;
+          break;
+        }
+
+        searchPos = closeEnd;
+      }
+
+      continue;
+    }
+
+    ++i;
+  }
+
+  return spans;
+}
+
+/**
+ * ApplyOutsideProtectedSpans
+ *
+ * Runs `transform` on each stretch of `line` that falls outside its
+ * protected spans (see FindProtectedSpans), leaving the spans themselves
+ * untouched, then writes the reassembled result back into `line`.
+ *
+ * @method
+ * @param {std::string&} line
+ * @param {const std::function<void(std::string&)>&} transform
+ * @return {void}
+ */
+inline void ApplyOutsideProtectedSpans(
+  std::string& line, const std::function<void(std::string&)>& transform
+)
+{
+  std::string result;
+  std::size_t pos = 0;
+
+  for (const auto& span : FindProtectedSpans(line))
+  {
+    std::string segment = line.substr(pos, span.first - pos);
+    transform(segment);
+    result += segment;
+    result += line.substr(span.first, span.second - span.first);
+    pos = span.second;
+  }
+
+  std::string tail = line.substr(pos);
+  transform(tail);
+  result += tail;
+
+  line = result;
+}
+
+// -----------------------------------------------------------------------------
+
+} // namespace maddy

include/maddy/emphasizedparser.h

@@ -9,6 +9,7 @@
 #include <regex>
 #include <string>
 
+#include "maddy/codespanutils.h"
 #include "maddy/lineparser.h"
 
 // -----------------------------------------------------------------------------
@@ -40,12 +41,17 @@ class EmphasizedParser : public LineParser
    */
   void Parse(std::string& line) override
   {
-    static std::regex re(
-      R"((?!.*`.*|.*<code>.*)_(?!.*`.*|.*<\/code>.*)([^_]*)_(?!.*`.*|.*<\/code>.*))"
+    // The leading and trailing `(_*)` groups absorb any leftover underscores
+    // from an unbalanced run (e.g. `__foo_` or `_foo____`), re-emitted
+    // outside the <em> tag instead of into its content.
+    static std::regex re(R"(\b(_*)_(?![\s_])(.*?[^\s])_(_*)\b)");
+    static std::string replacement = "$1<em>$2</em>$3";
+
+    ApplyOutsideProtectedSpans(
+      line,
+      [](std::string& segment)
+      { segment = std::regex_replace(segment, re, replacement); }
     );
-    static std::string replacement = "<em>$1</em>";
-
-    line = std::regex_replace(line, re, replacement);
   }
 }; // class EmphasizedParser
 

include/maddy/italicparser.h

@@ -9,6 +9,7 @@
 #include <regex>
 #include <string>
 
+#include "maddy/codespanutils.h"
 #include "maddy/lineparser.h"
 
 // -----------------------------------------------------------------------------
@@ -38,11 +39,14 @@ class ItalicParser : public LineParser
    */
   void Parse(std::string& line) override
   {
-    static std::regex re(
-      R"((?!.*`.*|.*<code>.*)\*(?!.*`.*|.*<\/code>.*)([^\*]*)\*(?!.*`.*|.*<\/code>.*))"
-    );
+    static std::regex re(R"(\*([^\*]*)\*)");
     static std::string replacement = "<i>$1</i>";
-    line = std::regex_replace(line, re, replacement);
+
+    ApplyOutsideProtectedSpans(
+      line,
+      [](std::string& segment)
+      { segment = std::regex_replace(segment, re, replacement); }
+    );
   }
 }; // class ItalicParser
 

include/maddy/parser.h

@@ -59,7 +59,7 @@ class Parser
    */
   static const std::string& version()
   {
-    static const std::string v = "1.6.0"; // MADDY_VERSION_LINE_REPLACEMENT
+    static const std::string v = "1.5.0";
     return v;
   }
 
@@ -278,10 +278,17 @@ class Parser
     }
     else if ((!this->config || (this->config->enabledParsers &
                                 maddy::types::TABLE_PARSER) != 0) &&
-             maddy::TableParser::IsStartingLine(line))
+             maddy::TableParser::IsStartingLine(
+               line,
+               !this->config || (this->config->enabledParsers &
+                                 maddy::types::MADDY_SPECIFIC_PARSER) != 0
+             ))
     {
       parser = std::make_shared<maddy::TableParser>(
-        [this](std::string& line) { this->runLineParser(line); }, nullptr
+        [this](std::string& line) { this->runLineParser(line); },
+        nullptr,
+        !this->config || (this->config->enabledParsers &
+                          maddy::types::MADDY_SPECIFIC_PARSER) != 0
       );
     }
     else if ((!this->config || (this->config->enabledParsers &

include/maddy/parserconfig.h

@@ -44,8 +44,13 @@ enum PARSER_TYPE : uint32_t
   UNORDERED_LIST_PARSER    = 0b100000000000000000,
   LATEX_BLOCK_PARSER       = 0b1000000000000000000,
 
-  DEFAULT                  = 0b0111111111110111111,
-  ALL                      = 0b1111111111111111111,
+  // Not a parser of its own: gates maddy's own historical markdown dialect
+  // wherever a parser supports both that and a more standard alternative
+  // (currently just TableParser's `|table>` syntax vs. GFM pipe tables).
+  MADDY_SPECIFIC_PARSER    = 0b10000000000000000000,
+
+  DEFAULT                  = 0b10111111111110111111,
+  ALL                      = 0b11111111111111111111,
 };
 // clang-format on
 

include/maddy/strikethroughparser.h

@@ -9,6 +9,7 @@
 #include <regex>
 #include <string>
 
+#include "maddy/codespanutils.h"
 #include "maddy/lineparser.h"
 
 // -----------------------------------------------------------------------------
@@ -38,12 +39,14 @@ class StrikeThroughParser : public LineParser
    */
   void Parse(std::string& line) override
   {
-    static std::regex re(
-      R"((?!.*`.*|.*<code>.*)\~\~(?!.*`.*|.*<\/code>.*)([^\~]*)\~\~(?!.*`.*|.*<\/code>.*))"
-    );
+    static std::regex re(R"(\~\~([^\~]*)\~\~)");
     static std::string replacement = "<s>$1</s>";
 
-    line = std::regex_replace(line, re, replacement);
+    ApplyOutsideProtectedSpans(
+      line,
+      [](std::string& segment)
+      { segment = std::regex_replace(segment, re, replacement); }
+    );
   }
 }; // class StrikeThroughParser