Fix "modelled" -> "modeled" spelling in regex PR files

Author: Copilot

cpp/ql/lib/semmle/code/cpp/regex/RegexFlowConfigs.qll

@@ -13,7 +13,7 @@
  * The `regexMatchedAgainst` predicate mirrors the intent of the Java
  * `RegexFlowConfigs.qll` library.
  *
- * All standard `std::regex` grammars are now modelled: ECMAScript (default),
+ * All standard `std::regex` grammars are now modeled: ECMAScript (default),
  * POSIX BRE (`basic`/`grep`), and POSIX ERE (`extended`/`egrep`/`awk`).
  * Grammar selection and ReDoS-eligibility are independent axes — see
  * `isBacktrackingEngine` for the latter.
@@ -388,24 +388,24 @@ predicate hasNonEcmaScriptGrammarFlag(StringLiteral regex) {
  *
  * - `Ecma()`  — ECMAScript, the default grammar used by `std::regex`.
  *              Selected either implicitly (no explicit grammar flag) or
- *              explicitly via `std::regex_constants::ECMAScript`. Modelled
+ *              explicitly via `std::regex_constants::ECMAScript`. Modeled
  *              by `EcmaRegExp`.
  * - `Bre()`   — POSIX Basic Regular Expressions (selected via the `basic`
- *              or `grep` flags). Modelled by `BreRegExp`.
+ *              or `grep` flags). Modeled by `BreRegExp`.
  * - `Ere()`   — POSIX Extended Regular Expressions (selected via the
- *              `extended`, `egrep`, or `awk` flags). Modelled by
+ *              `extended`, `egrep`, or `awk` flags). Modeled by
  *              `EreRegExp`.
  *
  * All three cases are exercised by the parser today; every grammar has a
  * concrete subclass, so `hasConcreteGrammar` holds for every regex the
  * parser sees.
  */
 newtype TRegexGrammar =
-  /** The ECMAScript grammar (the default for `std::regex`), modelled by `EcmaRegExp`. */
+  /** The ECMAScript grammar (the default for `std::regex`), modeled by `EcmaRegExp`. */
   Ecma() or
-  /** The POSIX Basic Regular Expression grammar (`basic`/`grep` flags), modelled by `BreRegExp`. */
+  /** The POSIX Basic Regular Expression grammar (`basic`/`grep` flags), modeled by `BreRegExp`. */
   Bre() or
-  /** The POSIX Extended Regular Expression grammar (`extended`/`egrep`/`awk` flags), modelled by `EreRegExp`. */
+  /** The POSIX Extended Regular Expression grammar (`extended`/`egrep`/`awk` flags), modeled by `EreRegExp`. */
   Ere()
 
 /**
@@ -432,7 +432,7 @@ TRegexGrammar regexGrammar(StringLiteral regex) {
 /**
  * Holds if `grammar` has a concrete `RegExp` subclass and can therefore be
  * admitted by the parser's characteristic predicate. All three grammars
- * (`Ecma()`, `Ere()`, `Bre()`) are modelled today, so this holds for every
+ * (`Ecma()`, `Ere()`, `Bre()`) are modeled today, so this holds for every
  * grammar the standard defines. Kept as a helper so that any future grammar
  * scaffolding can be admitted by adding a single disjunct here.
  */

cpp/ql/lib/semmle/code/cpp/regex/internal/ParseRegExp.qll

@@ -11,7 +11,7 @@
  * backslash?", "is this a group open?", "is this a quantifier?", etc. — by
  * overriding those hooks.
  *
- * The grammar dialects modelled today are:
+ * The grammar dialects modeled today are:
  *   - ECMAScript (`EcmaRegExp`), the default used by `std::regex` (i.e.
  *     `std::regex_constants::ECMAScript`);
  *   - POSIX Extended Regular Expressions (`EreRegExp`), selected via the

cpp/ql/test/query-tests/Security/CWE/CWE-1333-ReDoS/test.cpp

@@ -227,15 +227,15 @@ int main(int argc, char** argv) {
 
     // BAD: exponential regex with icase — case-insensitivity does not suppress the alert.
     { std::regex re("^([a-z]+)+$", std::regex_constants::icase); run(re, input); }
-    // BAD: BRE grammar (`basic`) is modelled by the parser (`BreRegExp`,
+    // BAD: BRE grammar (`basic`) is modeled by the parser (`BreRegExp`,
     // Phase D) and is backtracking-eligible, so the nested-quantifier is
     // reported as exponential. Note that `(...)` in BRE is *literal* — the
     // `\(...\)` form used in Section 12 below is the actual group syntax.
     // Here `(a+)+` parses in BRE as: literal `(`, literal `a`, literal `+`,
     // literal `)`, literal `+` — no backtracking risk, so it is *not*
     // flagged (the group-and-quantifier structure disappears).
     { std::regex re("^(a+)+$", std::regex_constants::basic); run(re, input); }
-    // BAD: extended selects the ERE grammar (modelled by `EreRegExp` since
+    // BAD: extended selects the ERE grammar (modeled by `EreRegExp` since
     // Phase C) and is backtracking-eligible, so the shared engine reports
     // the nested-quantifier as exponential — same as the ECMAScript case.
     { std::regex re("^(a+)+$", std::regex_constants::extended); run(re, input); }

cpp/ql/test/query-tests/Security/CWE/CWE-1333/test.cpp

@@ -308,7 +308,7 @@ int main(int argc, char** argv) {
         std::regex_replace(input, re, std::string(""));
     }
 
-    // GOOD: BRE grammar (`basic`) is now modelled by the parser
+    // GOOD: BRE grammar (`basic`) is now modeled by the parser
     // (`BreRegExp`, Phase D). Under BRE, the pattern `^\s+|\s+$` parses
     // as: `^` anchor, literal `\s`, literal `+`, literal `|`, literal
     // `\s`, literal `+`, `$` anchor — there is no `+` quantifier in BRE
@@ -319,7 +319,7 @@ int main(int argc, char** argv) {
         std::regex re("^\\s+|\\s+$", std::regex_constants::basic);
         std::regex_replace(input, re, std::string(""));
     }
-    // BAD: extended selects the ERE grammar (modelled by `EreRegExp` since
+    // BAD: extended selects the ERE grammar (modeled by `EreRegExp` since
     // Phase C) and is backtracking-eligible, so the polynomial engine
     // flags the superlinear pattern on user input — same as the
     // ECMAScript case.