` and the `<` after it, so a fragment holding many `open`s that no `>`
+ * follows soon cost their count times that walk: the square of a run that the
+ * file's bytes decide.
+ *
+ * At one start the regex can match only one way. `[^>]*` cannot pass a `>`, so its
+ * `>` is the first one after `open`; `[^<]*` cannot pass a `<`, so the text ends at
+ * the first `<` after that, where `
` either is or is not. `open` starts with its
+ * only `<` and holds no `>`, so a later start either lies before that `>` (and meets
+ * the same `>`, the same `<` and the same answer) or lies at or after that `<`. So
+ * the next start worth trying is the next `open` from there, and no character is
+ * read more than a bounded number of times.
+ */
+export function pNodeText(fragment: string, open: string): string | null {
+ let at = fragment.indexOf(open);
+ while (at >= 0) {
+ const gt = fragment.indexOf('>', at + open.length);
+ if (gt < 0) return null;
+ const lt = fragment.indexOf('<', gt + 1);
+ if (lt < 0) return null;
+ if (fragment.startsWith('', lt)) return fragment.slice(gt + 1, lt);
+ at = fragment.indexOf(open, lt);
+ }
+ return null;
}
/**
diff --git a/test/mdlParser.test.ts b/test/mdlParser.test.ts
index 6fd358ea..1b8076dc 100644
--- a/test/mdlParser.test.ts
+++ b/test/mdlParser.test.ts
@@ -17,7 +17,7 @@
// of the same diagram — are test/parity/mdl.parity.test.ts.
import { describe, it, expect } from 'vitest';
import { strToU8, zipSync } from 'fflate';
-import { parseMdl } from '../src/datamodel/parser/MdlParser.js';
+import { parseMdl, styleWithoutOptions } from '../src/datamodel/parser/MdlParser.js';
import { parseModel } from '../src/datamodel/parser/ModelParser.js';
import { parseSlx } from '../src/datamodel/parser/SlxParser.js';
@@ -453,6 +453,81 @@ describe('parseMdl — classic .mdl block parameters', () => {
});
});
+describe('parseMdl — classic .mdl mask styles', () => {
+ // The cut `styleWithoutOptions` replaced, kept here as the specification it is held to.
+ // It is quadratic on a style of many `(` ahead of a line terminator, which is why it is
+ // not the implementation; every input below is small enough for it to finish.
+ const viaRegex = (s: string): string => s.replace(/\(.*$/, '');
+
+ // Random strings over the characters the cut gives meaning to, all four line
+ // terminators among them, seeded so a failure reproduces.
+ it('cuts a style where the regex cut it, on random input', () => {
+ let seed = 1;
+ const rand = (n: number): number => {
+ seed ^= seed << 13;
+ seed ^= seed >>> 17;
+ seed ^= seed << 5;
+ return (seed >>> 0) % n;
+ };
+ const pieces = ['(', ')', 'x', ' ', '\n', '\r', '\u2028', '\u2029', 'popup(', 'edit', '|', ','];
+ for (let k = 0; k < 20000; k++) {
+ let s = '';
+ for (let i = 1 + rand(30); i > 0; i--) {
+ s += pieces[rand(pieces.length)];
+ }
+ expect(styleWithoutOptions(s), JSON.stringify(s)).toBe(viaRegex(s));
+ }
+ });
+
+ // One masked block, its three mask properties spelled as given: escapes and all, since
+ // the scanner unescapes them.
+ const masked = (styles: string, vars: string, values: string): ArrayBuffer =>
+ bytes(`Model {
+ Name "m"
+ System {
+ Name "m"
+ Block {
+ BlockType SubSystem
+ Name "Masked"
+ SID "1"
+ MaskStyleString "${styles}"
+ MaskVariables "${vars}"
+ MaskValueString "${values}"
+ }
+ }
+}
+`);
+
+ // `\(.*$` failed at every `(` that a line terminator follows, and each failure walked to
+ // it. The scanner unescapes `\n`, so the first style below holds 80,000 `(` ahead of
+ // one: with the regex it took 3.9 s to read. Here it takes 5 ms over two full runs, so
+ // 1 s is past five times CI's time, at 3.3 times this machine's (fe238c7).
+ it('reads a style of many `(` ahead of a line break at once, and the style after it', () => {
+ const n = 80_000;
+ const t0 = performance.now();
+ const parsed = parseMdl(masked('('.repeat(n) + '\\n' + ')'.repeat(n) + ',edit', 'k=@1;g=@2;', 'Kp|Kg'), 'm.mdl');
+ expect(performance.now() - t0).toBeLessThan(1000);
+ // `k`'s style is no expression type, so only `g` is a row; both are in scope.
+ expect(parsed.blockParamUsages).toEqual([
+ { blockName: 'Masked', blockType: 'SubSystem', paramProperty: 'g', paramValue: 'Kg', sid: '1', systemPath: '' },
+ ]);
+ expect(parsed.masks.map((m) => m.names)).toEqual([['k', 'g']]);
+ });
+
+ // A style was read again for every declaration naming its slot, and reading one is
+ // linear in its length, so the two multiplied: 30,000 declarations naming a style of
+ // 200,000 characters took 3.7 s with the regex. Each slot's style is read once now, and
+ // this takes 21 ms over two full runs, so 1 s is past five times CI's time, at 3.3
+ // times this machine's (fe238c7).
+ it('reads one long style named by many declarations at once', () => {
+ const t0 = performance.now();
+ const parsed = parseMdl(masked(`edit(${'x'.repeat(200_000)})`, 'k=@1;'.repeat(30_000), 'Kp'), 'm.mdl');
+ expect(performance.now() - t0).toBeLessThan(1000);
+ expect(parsed.blockParamUsages).toHaveLength(30_000);
+ expect(new Set(parsed.blockParamUsages.map((u) => `${u.paramProperty}=${u.paramValue}`))).toEqual(new Set(['k=Kp']));
+ });
+});
+
describe('parseMdl — classic .mdl grammar edge cases', () => {
it('reads a Library the same way as a Model', () => {
const parsed = parseMdl(bytes('Library {\n Name "lib"\n Creator "someone"\n}\n'), 'lib.mdl');
diff --git a/test/xmlEntrySplice.test.ts b/test/xmlEntrySplice.test.ts
index 0f13ba6a..ad699739 100644
--- a/test/xmlEntrySplice.test.ts
+++ b/test/xmlEntrySplice.test.ts
@@ -7,6 +7,7 @@ import {
findEntryObjectSpan,
findEntryElementSpan,
findEntryInsertionPoint,
+ pNodeText,
} from '../src/datamodel/parser/xmlEntrySplice.js';
function chunkXml(fixture: string): string {
@@ -179,3 +180,68 @@ describe('findEntryElementSpan', () => {
expect(findEntryElementSpan(nested, 'NoSuchEntry')).toBeNull();
});
});
+
+describe('the Name and UUID reads, on fragments that are not well-formed entries', () => {
+ // The two patterns `pNodeText` replaced, kept here as the specification it is held to.
+ // Each is quadratic on a fragment holding many opens that no `>` follows soon, which is
+ // why it is not the implementation; every input below is small enough for it to finish.
+ const SPEC: Record = {
+ ']*>([^<]*)<\/P>/,
+ '
]*>([^<]*)<\/P>/,
+ };
+ const viaRegex = (s: string, open: string): string | null => {
+ const m = s.match(SPEC[open]);
+ return m ? m[1] : null;
+ };
+
+ // Random strings over the pieces the patterns give meaning to, seeded so a failure
+ // reproduces: opens with and without their `>`, closes, and the `<` that ends a text.
+ it('reads what the regexes read, on random input', () => {
+ let seed = 1;
+ const rand = (n: number): number => {
+ seed ^= seed << 13;
+ seed ^= seed >>> 17;
+ seed ^= seed << 5;
+ return (seed >>> 0) % n;
+ };
+ const pieces = [
+ '
', '<', '>', '/', 'P', ' ', 'Name="Name"',
+ 'x', '\n', '
', '"', '',
+ ];
+ for (let k = 0; k < 20000; k++) {
+ let s = '';
+ for (let i = 1 + rand(30); i > 0; i--) {
+ s += pieces[rand(pieces.length)];
+ }
+ for (const open of Object.keys(SPEC)) {
+ expect(pNodeText(s, open), JSON.stringify([open, s])).toBe(viaRegex(s, open));
+ }
+ }
+ });
+
+ // An entry ahead of the one looked up, holding a comment of 25,000 Name opens. The
+ // regex retried at each and walked from each to the comment's `>`: the lookup took
+ // 4.1 s. Here it takes 0.4 ms over two full runs, so 1 s is past five times CI's time,
+ // at 3.3 times this machine's (fe238c7).
+ it('looks past an entry holding many Name opens at once', () => {
+ const run = ``;
+ const xml = nested.replace('
StructWithParam
');
+ });
+
+ // The same run of UUID opens, ahead of the UUID that breaks a tie between two entries
+ // of one name, which is read only once the name has matched. With the regex the lookup
+ // took 4.1 to 5.5 s; here it takes 1.1 ms over two full runs, under the same bound.
+ it('reads the UUID that breaks a name tie past an entry holding many UUID opens, at once', () => {
+ const run = ``;
+ const xml = nested.replace('([^<]*)<\/P>/.exec(nested)![1];
+ const t0 = performance.now();
+ const span = findEntryObjectSpan(xml, { name: 'CellWithParam', uuid });
+ expect(performance.now() - t0).toBeLessThan(1000);
+ expect(xml.slice(span!.offset, span!.offset + span!.length)).toContain(run);
+ });
+});