@tikoci/centrs 0.1.9-next.22 → 0.1.9-next.24

package/src/explain/segment.ts

@@ -84,13 +84,16 @@ import {
 	MAX_STRING_FRAME_DEPTH,
 	scanQuotedString as scanQuotedStringShared,
 } from "./quoted-string.ts";
+import { runNamesCommand } from "./run-tokens.ts";
 import {
 	braceStartsStatements,
 	canRetainStatementIndex,
 	hashStartsHardError,
 	isIndexedStatementStart,
 	matchingBraceEnd,
+	menuBlockPath,
 	scopeNameFromMasked,
+	startsArrayCommentLine,
 } from "./scope-brace.ts";
 
 /** One top-level statement located in analyzed-byte space. */
@@ -130,6 +133,15 @@ export interface SegmentResult {
 	 * a throw. Includes the two coordinate-pass classes (`bom`, `non-ascii`).
 	 */
 	defects: Defect[];
+	/**
+	 * The first `}` or `]` that closes nothing at the top level, where RouterOS
+	 * stops reading (#504). The device accepts the script and silently discards
+	 * that byte and everything after it: `:put 1};:put 2` lowers to
+	 * `(evl /putmessage=1)` and `}⏎:put 1` to `/`, on CHR 7.24.5 and 7.23.8.
+	 * A `)` there, or any stray close inside an open group, is a rejection
+	 * instead and is only an `unbalanced-close` defect. Absent when there is none.
+	 */
+	discardFrom?: number;
 }
 
 const isSpace = (c: string): boolean => c === " " || c === "\t" || c === "\r";
@@ -510,7 +522,12 @@ function maskUncached(
 		// indented `#` is a comment when the statement is still empty (`do={\` +
 		// newline + `  # c`) and content when it is not (`:put a\` + newline +
 		// `  # x`, which the device classes `error`) — exactly what `atLead` says.
-		if (c === "#" && (atLead || contComment)) {
+		if (
+			c === "#" &&
+			(atLead ||
+				contComment ||
+				startsArrayCommentLine(original, i, contexts.at(-1)))
+		) {
 			const commentStart = i;
 			while (i < original.length && original[i] !== "\n") i++;
 			if (pieces === undefined) pieces = [];
@@ -608,6 +625,137 @@ export function segmentScopeBody(
 	);
 }
 
+/** Nesting cap for dispatch-statement counting (#549): the 16× guard (#322). */
+const MAX_DISPATCH_STATEMENT_DEPTH = 16;
+
+/**
+ * Executable statements in `text`, at any nesting depth (#549).
+ *
+ * A dispatched script can carry statements inside executed control scopes
+ * (`:if … do={…}`, `:for`/`:foreach`/`:while`, `:do`, `:retry`, `:onerror`,
+ * `once do={…}`), and those run before a later refusal exactly like
+ * top-level ones do — `:if (true) do={ /system/note/set …; /user/add … }`
+ * applies the note before the refused add on CHR 7.25. Stored bodies
+ * (`source={…}`, `on-event={…}`, any other `name={`) never execute at
+ * dispatch, so only `scopeNameFromMasked` scopes recurse — except a `do={…}`
+ * under a `:global`/`:local`/`:set` head, which stores a function value.
+ * Command substitutions (`[…]`) run at dispatch too — `:put [:put "p5-first";
+ * /system/identity/set …]` prints before the refused set on CHR 7.25 — so
+ * they recurse unless they sit inside a stored or array `{…}`. An `else={…}`
+ * paired with its `do={…}` counts the larger side, not the sum, because the
+ * branches exclude each other.
+ *
+ * A segment with executed blocks or substitutions counts their inner
+ * statements, not itself (a control head is not an effect); a `/menu { … }`
+ * prefix counts nothing (navigation is not an effect); any other segment
+ * counts one. So the commonest write shape, `/… remove [find …]`, stays one
+ * statement — at the cost of a lone substitution that itself writes before a
+ * refused enclosing statement, which also counts one. Past the depth cap the
+ * inner text counts its top-level siblings only. Unbalanced input counts what
+ * precedes the break and never throws.
+ */
+export function countExecutableStatements(text: string): number {
+	return countExecutableStatementsWithin(text, 0);
+}
+
+function countExecutableStatementsWithin(text: string, depth: number): number {
+	const { segments, ascii } = segmentStatements(text);
+	if (depth >= MAX_DISPATCH_STATEMENT_DEPTH) return segments.length;
+	let count = 0;
+	for (const segment of segments) {
+		// A `/menu { … }` prefix only navigates; it is not an effect. The
+		// `ascii` guard is load-bearing: segment offsets are analyzed-byte
+		// offsets, which are string indexes only for pure-ASCII input.
+		if (ascii && segment.menuOnly && /^\s*\{/.test(text.slice(segment.end)))
+			continue;
+		const inner = countExecutedBlockStatements(segment.text, depth);
+		count += inner > 0 ? inner : 1;
+	}
+	return count;
+}
+
+/** Executable statements in the segment's executed `{…}` scopes and `[…]`. */
+function countExecutedBlockStatements(
+	segmentText: string,
+	depth: number,
+): number {
+	const masked = maskComments(segmentText);
+	const storedDoHead = /^:(?:global|local|set)\b/i.test(masked);
+	let total = 0;
+	let i = 0;
+	const stack: string[] = [];
+	// The last executed scope closed at this level, for `do`/`else` pairing.
+	let lastScope: { name: string; count: number; end: number } | null = null;
+	// The outermost open `[` that executes at dispatch, and its stack depth.
+	let substitution: { start: number; depth: number } | null = null;
+	while (i < masked.length) {
+		const c = masked[i];
+		if (c === '"') {
+			i = scanQuotedString(masked, i).end;
+			continue;
+		}
+		if (c === "[" || c === "(") {
+			if (c === "[" && !stack.includes("[") && !stack.includes("{")) {
+				substitution = { start: i, depth: stack.length };
+			}
+			stack.push(c);
+			i++;
+			continue;
+		}
+		if (c === "]" || c === ")") {
+			const want = c === "]" ? "[" : "(";
+			if (stack.at(-1) === want) {
+				stack.pop();
+				if (c === "]" && stack.length === substitution?.depth) {
+					total += countExecutableStatementsWithin(
+						segmentText.slice(substitution.start + 1, i),
+						depth + 1,
+					);
+					substitution = null;
+				}
+			}
+			i++;
+			continue;
+		}
+		if (c === "{") {
+			const scope = stack.length === 0 ? scopeNameFromMasked(masked, i) : null;
+			if (
+				scope !== null &&
+				!(storedDoHead && (scope === "do" || scope === "command"))
+			) {
+				const end = matchingBraceEnd(masked, i);
+				if (end === undefined) return total;
+				const count = countExecutableStatementsWithin(
+					segmentText.slice(i + 1, end),
+					depth + 1,
+				);
+				if (
+					scope === "else" &&
+					lastScope?.name === "do" &&
+					/^\s*else\s*=?\s*$/.test(masked.slice(lastScope.end + 1, i))
+				) {
+					total += Math.max(lastScope.count, count) - lastScope.count;
+				} else {
+					total += count;
+				}
+				lastScope = { name: scope, count, end };
+				i = end + 1;
+				continue;
+			}
+			stack.push("{");
+			i++;
+			continue;
+		}
+		if (c === "}") {
+			if (stack.at(-1) === "{") stack.pop();
+			i++;
+			continue;
+		}
+		i++;
+	}
+	return total;
+}
+
 function segmentStatementsInternal(
 	original: string,
 	range: MaskedRange | undefined,
@@ -650,6 +798,7 @@ function segmentStatementsInternal(
 			analysis === undefined ? [] : coordinateDefects(analysis),
 			raw.defects,
 		),
+		...(raw.discardFrom === undefined ? {} : { discardFrom: raw.discardFrom }),
 	};
 }
 
@@ -699,6 +848,8 @@ interface Frame {
 	/** Incremental equivalent of trimming and checking the H7 prefix. */
 	prefixSawNonSpace: boolean;
 	prefixValid: boolean;
+	/** The prefix's run has been checked for a command verb (#496). */
+	prefixVerbChecked: boolean;
 	/** statements collected here; the flattened output for a committed container. */
 	buffer: RawSegment[];
 	/** true for a container frame; false for the synthetic top level. */
@@ -726,6 +877,7 @@ function scanAscii(
 	segments: RawSegment[];
 	comments: { start: number; end: number }[];
 	defects: Defect[];
+	discardFrom?: number;
 } {
 	// Local indices remain local in the result; only index-backed questions use
 	// document coordinates. The floor prevents an enclosing head from becoming
@@ -736,6 +888,7 @@ function scanAscii(
 	const comments: { start: number; end: number }[] = [];
 	const defects: Defect[] = [];
 	const overDepth: number[] = [];
+	let discardFrom: number | undefined;
 	let hardHashSeen = false;
 	let hardApostropheSeen = false;
 	// H2 — every open bracket, for balance. Each frame carries WHERE it opened so
@@ -752,6 +905,7 @@ function scanAscii(
 		prefixScanEnd: -1,
 		prefixSawNonSpace: false,
 		prefixValid: true,
+		prefixVerbChecked: false,
 		buffer: [],
 		container: false,
 		openIndex: -1,
@@ -777,6 +931,7 @@ function scanAscii(
 		f.prefixScanEnd = -1;
 		f.prefixSawNonSpace = false;
 		f.prefixValid = true;
+		f.prefixVerbChecked = false;
 	};
 
 	const makeSegment = (
@@ -814,7 +969,8 @@ function scanAscii(
 	};
 
 	// A container prefix is empty or a bare `/`-menu path with no `=[($"` — the
-	// same test the old `containerOpen` applied to the group's prefix.
+	// same test the old `containerOpen` applied to the group's prefix — whose
+	// run names no command (#496).
 	const validPrefix = (f: Frame, start: number, end: number): boolean => {
 		if (f.prefixScanStart !== start || f.prefixScanEnd > end) {
 			resetPrefixScan(f);
@@ -841,6 +997,12 @@ function scanAscii(
 			}
 		}
 		f.prefixScanEnd = end;
+		// Checked once per statement: a later `{` sits behind this one, which
+		// already ended the run, so the answer cannot change.
+		if (f.prefixValid && !f.prefixVerbChecked) {
+			f.prefixVerbChecked = true;
+			if (runNamesCommand(ascii.slice(start, end))) f.prefixValid = false;
+		}
 		return f.prefixValid;
 	};
 
@@ -860,6 +1022,7 @@ function scanAscii(
 			prefixScanEnd: -1,
 			prefixSawNonSpace: false,
 			prefixValid: true,
+			prefixVerbChecked: false,
 			buffer: [],
 			container: true,
 			openIndex: i,
@@ -920,7 +1083,12 @@ function scanAscii(
 		// mid-continuation stays content.
 		const inCont = f.cont !== "none";
 		const contComment = c === "#" && inCont && f.contLineStart;
-		if (c === "#" && (f.atLead || contComment)) {
+		if (
+			c === "#" &&
+			(f.atLead ||
+				contComment ||
+				startsArrayCommentLine(ascii, i, delimStack.at(-1)))
+		) {
 			const nl = ascii.indexOf("\n", i);
 			const end = nl === -1 ? ascii.length : nl;
 			comments.push({ start: i, end });
@@ -1037,7 +1205,10 @@ function scanAscii(
 			if (
 				c === "{" &&
 				atContainerLevel() &&
-				validPrefix(f, f.stmtStart >= 0 ? f.stmtStart : i, i)
+				(validPrefix(f, f.stmtStart >= 0 ? f.stmtStart : i, i) ||
+					// A relative submenu inside a container is one too (#351).
+					(frames.length > 1 &&
+						menuBlockPath(indexed, floor + i, floor) !== null))
 			) {
 				if (frames.length - 1 < MAX_CONTAINER_DEPTH) {
 					openContainer(i);
@@ -1091,6 +1262,7 @@ function scanAscii(
 					f.atLead = false;
 				}
 			} else {
+				if (delimStack.length === 0 && c !== ")") discardFrom ??= i;
 				defects.push(defectAt("unbalanced-close", i, c));
 				ensureStmt(f, i);
 				f.atLead = false;
@@ -1148,6 +1320,7 @@ function scanAscii(
 			// event fail to de-duplicate across analyzers.
 			...overDepth.map((offset) => defectAt("over-depth", offset)),
 		],
+		...(discardFrom === undefined ? {} : { discardFrom }),
 	};
 }
 

package/src/explain/spaced-args.ts

@@ -0,0 +1,116 @@
+/**
+ * The space-for-`=` argument spelling (#350).
+ *
+ * RouterOS lets a space stand in for the `=` of an ordinary command argument:
+ * `/ip/firewall/layer7-protocol add comment "something" regexp 1.1` lowers to
+ * `(evl /ip/firewall/layer7-protocol/addcomment=something;regexp=1.1)`, byte for
+ * byte the IL of the `=` spelling, and the spellings mix freely. That is not a
+ * schema-free rule. The device pairs `comment` with `"something"` because it
+ * knows `/ip/firewall/layer7-protocol/add` has a `comment` argument:
+ * `/system/script add zzznotanarg beep` is `bad parameter zzznotanarg` on
+ * 7.24.5 and `expected end of command` on 7.22.1.
+ *
+ * ## What the device actually does (CHR 7.22.1 and 7.24.5, `:parse` + `highlight`)
+ *
+ * Identical on both builds:
+ *
+ * | input | IL | `highlight` on the gap |
+ * | ----- | -- | ---------------------- |
+ * | `/interface set ether1 comment "x"` | `setcomment=x;numbers=ether1` | `syntax-obsolete` |
+ * | `/interface set ether1 name x` | `setname=x;numbers=ether1` | `syntax-obsolete` |
+ * | `/interface set ether1 disabled yes` | `setdisabled=true;numbers=ether1` | `syntax-obsolete` |
+ * | `/user group set full policy "read,write"` | `setnumbers=full;policy=read,write` | `syntax-obsolete` |
+ * | `/interface print detail without-paging` | `printdetail=true;without-paging=true` | none |
+ *
+ * Two facts come out of that table, and they are why this module has two
+ * outputs rather than one.
+ *
+ * - **Two adjacent bare operands have no schema-free reading.** `name x` is an
+ *   argument and its value; `detail without-paging` is two value-less flags;
+ *   `ether1 name` is an unnamed `numbers` operand and then an argument name. The
+ *   bytes are the same shape in all three. So the strict reading ABSTAINS on any
+ *   such pair: it never publishes `args: {}` plus a positional list, which
+ *   claims the list was read and holds no arguments.
+ * - **The obsolete marker follows the value, not the name.** The device marks
+ *   the gap `syntax-obsolete` exactly when it paired the words, and a flag pair
+ *   gets no marker. Offline can see one half of that: a second operand that is
+ *   not itself name-shaped (`"x"`, `1.1`, `10s`, `$v`) cannot be a flag, so the
+ *   pair is very probably the spaced spelling and gets a warning. A bare-word
+ *   second operand (`name x`, `disabled yes`) is also obsolete on device, but
+ *   offline cannot tell it from `detail without-paging`, so it abstains with no
+ *   warning rather than flagging the most common `print` spelling there is. The
+ *   warning says "possible"; a live probe (#491) is what makes it definite.
+ *
+ * ## What this deliberately does not decide
+ *
+ * Root statements are out of scope. A scripting directive's operands are
+ * positional by grammar, not spelling: `:pick abc 0 1` lowers to
+ * `pickbegin=0;counter=abc;end=1`, and `:local t 200ms` to `name=t;value=200ms`.
+ * Pairing those would fabricate argument names the device never uses. `/ping
+ * 1.1.1.1 count 1` is spaced (`count` is `syntax-obsolete`) and resolves to the
+ * root, so it stays read here; telling a root command's positional grammar from a
+ * spaced argument is per-command schema and belongs to the live probe.
+ *
+ * `where` ends the scan. What follows it is a query expression, and the word
+ * before it is never paired with it: `print count-only where …` lowers to
+ * `count-only=true;where=…`.
+ *
+ * Like the #311 separator rule, this reads only what the argument lexer
+ * already decided (`lexArgumentTokens`, the skip-tolerant reading), so a
+ * `[…]` substitution or a quoted run is one token by construction.
+ */
+
+import { ARGUMENT_NAME, type Argument } from "./args.ts";
+
+/** Two adjacent operands that may be the spaced spelling of `name=value`. */
+export interface SpacedPair {
+	/** First byte of the would-be name through the end of the would-be value. */
+	span: { start: number; end: number };
+	/** The would-be argument name, verbatim. */
+	name: string;
+	/** The would-be value, verbatim (quotes kept). */
+	value: string;
+	/**
+	 * The second operand cannot be a flag, so the device very probably reads the
+	 * pair as `name=value` and marks the gap `syntax-obsolete`.
+	 */
+	valueShaped: boolean;
+}
+
+/**
+ * An argument-name-shaped bare word. This is the lexer's own grammar, so a word
+ * the lexer would read as `name=` in the `=` spelling is a name here too.
+ */
+const NAME_SHAPED = ARGUMENT_NAME;
+
+function isWhere(token: Argument): boolean {
+	return token.kind === "positional" && token.text.toLowerCase() === "where";
+}
+
+/**
+ * Every adjacent `name operand` pair in one statement's argument tokens.
+ *
+ * Pairs overlap on purpose. `set ether1 comment "x"` yields `ether1 comment`
+ * and `comment "x"`: the first only abstains, the second also warns, and
+ * consuming the first would hide the second.
+ *
+ * Coordinate-space agnostic, like `findMissingSeparators`: spans come back in
+ * whatever space `tokens` were lexed in.
+ */
+export function findSpacedPairs(tokens: readonly Argument[]): SpacedPair[] {
+	const out: SpacedPair[] = [];
+	for (let i = 0; i + 1 < tokens.length; i++) {
+		const name = tokens[i] as Argument;
+		const value = tokens[i + 1] as Argument;
+		if (isWhere(name)) break;
+		if (name.kind !== "positional" || value.kind !== "positional") continue;
+		if (!NAME_SHAPED.test(name.text) || isWhere(value)) continue;
+		out.push({
+			span: { start: name.span.start, end: value.span.end },
+			name: name.text,
+			value: value.text,
+			valueShaped: !NAME_SHAPED.test(value.text),
+		});
+	}
+	return out;
+}