Use stdlib re for Shortcode matching

novelwriter/core/tokenizer.py

@@ -1116,27 +1116,21 @@ class Tokenizer(ABC):
                 )
 
         # Match Shortcodes
-        rxItt = self._rxShortCodes.globalMatch(text, 0)
+        for match in re.finditer(REGEX_PATTERNS.shortcodePlain, text):
-        while rxItt.hasNext():
-            rxMatch = rxItt.next()
             temp.append((
-                rxMatch.capturedStart(1),
+                match.start(1), len(match.group(1)),
-                rxMatch.capturedLength(1),
+                self._shortCodeFmt.get(match.group(1).lower(), 0),
-                self._shortCodeFmt.get(rxMatch.captured(1).lower(), 0),
                 "",
             ))
 
         # Match Shortcode w/Values
-        rxItt = self._rxShortCodeVals.globalMatch(text, 0)
         tHandle = self._handle or ""
-        while rxItt.hasNext():
+        for match in re.finditer(REGEX_PATTERNS.shortcodeValue, text):
-            rxMatch = rxItt.next()
+            kind = self._shortCodeVals.get(match.group(1).lower(), 0)
-            kind = self._shortCodeVals.get(rxMatch.captured(1).lower(), 0)
             temp.append((
-                rxMatch.capturedStart(0),
+                match.start(0), len(match.group(0)),
-                rxMatch.capturedLength(0),
                 self.FMT_STRIP if kind == skip else kind,
-                f"{tHandle}:{rxMatch.captured(2)}",
+                f"{tHandle}:{match.group(2)}",
             ))
 
         # Match Dialogue

novelwriter/text/patterns.py

@@ -34,34 +34,37 @@ from novelwriter.types import QRegExUnicode
 
 class RegExPatterns:
 
+    # Static RegExes
+    _rxItalic  = re.compile(nwRegEx.FMT_EI, re.UNICODE)
+    _rxBold    = re.compile(nwRegEx.FMT_EB, re.UNICODE)
+    _rxStrike  = re.compile(nwRegEx.FMT_ST, re.UNICODE)
+    _rxSCPlain = re.compile(nwRegEx.FMT_SC, re.UNICODE)
+    _rxSCValue = re.compile(nwRegEx.FMT_SV, re.UNICODE)
+
     @property
     def markdownItalic(self) -> re.Pattern:
         """Markdown italic style."""
-        return re.compile(nwRegEx.FMT_EI, re.UNICODE)
+        return self._rxItalic
 
     @property
     def markdownBold(self) -> re.Pattern:
         """Markdown bold style."""
-        return re.compile(nwRegEx.FMT_EB, re.UNICODE)
+        return self._rxBold
 
     @property
     def markdownStrike(self) -> re.Pattern:
         """Markdown strikethrough style."""
-        return re.compile(nwRegEx.FMT_ST, re.UNICODE)
+        return self._rxStrike
 
     @property
-    def shortcodePlain(self) -> QRegularExpression:
+    def shortcodePlain(self) -> re.Pattern:
         """Plain shortcode style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_SC)
+        return self._rxSCPlain
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
 
     @property
-    def shortcodeValue(self) -> QRegularExpression:
+    def shortcodeValue(self) -> re.Pattern:
         """Plain shortcode style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_SV)
+        return self._rxSCValue
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
 
     @property
     def dialogStyle(self) -> QRegularExpression: