@scriptc/compiler 0.3.0 → 0.3.2

package/dist/backend/llvm/regex-matchers.d.ts

@@ -0,0 +1,39 @@
+/** Regex literals compiled to native matchers at build time.
+ *
+ * A regex literal whose pattern stays inside a common subset (literals,
+ * classes and their escapes, `.`, anchors, word boundaries, greedy and lazy
+ * quantifiers, alternation, capturing and non-capturing groups) gets a
+ * specialized LLVM function next to its immortal template. The runtime calls
+ * it in place of the bytecode engines for one-byte (ASCII) subjects; every
+ * other subject, and every pattern outside the subset, keeps the interpreter.
+ *
+ * The generated code is a direct backtracking matcher over the pattern's
+ * ECMAScript semantics: ordered alternation, RepeatMatcher's capture reset
+ * at each iteration and its empty-iteration check, greedy-first and
+ * lazy-first quantifiers. Choice points and the undo records of register
+ * writes share one explicit stack; a failure pops the newest entry and
+ * resumes there. Single-character loops count instead of pushing one entry
+ * per character, and they push nothing when no continuation can start with
+ * a character of their own class.
+ *
+ * Function contract (scr_runtime.h `ScrRegexMatcher`):
+ * `i32 (ptr s, i32 len, i32 start, ptr capture)` searches the ASCII bytes
+ * `s[0..len)` from `start` (one anchored attempt for sticky patterns) and,
+ * on a match, stores `2 * ncap` pointers into `s` (NULL for unset captures)
+ * and returns 1; it returns 0 when nothing matches. Called with a negative
+ * `len`, it returns the capture count (whole match included) so the runtime
+ * can check it against the compiled bytecode. */
+export interface RegexMatcherCode {
+    /** Module-level lines: tables and the function definition. */
+    lines: string[];
+    /** External declarations the function uses. */
+    decls: string[];
+}
+export declare const REGEX_MATCHER_DECLS: string[];
+/** Whether a literal compiles to a native matcher (tests and size caps). */
+export declare function regexLiteralCompiles(pattern: string, flags: string): boolean;
+/** Why a literal keeps the interpreter ("" when it compiles). */
+export declare function regexLiteralBailReason(pattern: string, flags: string): string;
+/** The native matcher `@sym` of a regex literal, or null when the pattern
+ * is outside the compiled subset. */
+export declare function compileRegexMatcher(sym: string, pattern: string, flags: string, sizeType: string, vector: boolean): RegexMatcherCode | null;