@jhlagado/azm 0.2.10 → 0.2.12

package/README.md

@@ -10,6 +10,7 @@ AZM manual and broader Debug80 documentation:
 - [Debug80 documentation](https://debug80.com/)
 - [AZM Book 0 — Assembler Manual](https://debug80.com/azm-book/book0/)
 - [AZM Book 4](https://jhlagado.github.io/debug80-docs/azm-book/book4/)
+- [AZM Grammar Reference](docs/reference/azm-grammar.md)
 
 ## Install
 
@@ -185,6 +186,19 @@ indent instructions and standalone directives, and align operands enough to keep
 dense assembly readable. Exact tab width is less important than keeping one
 source file internally consistent.
 
+AZM normally uses one statement per physical line. For short, dense instruction
+sequences, a physical line may contain multiple instructions or `op` invocations
+separated by a spaced backslash:
+
+```asm
+Loop:   ld      a,(hl) \ inc hl \ djnz Loop
+```
+
+This is only instruction compaction. Directives and declarations still belong on
+their own lines, and labels are only allowed before the first chained
+instruction. A semicolon still starts a comment; it is not an instruction
+separator.
+
 ## Literals
 
 AZM accepts the usual Z80 numeric forms:

package/dist/src/assembly/import-visibility.js

@@ -1,14 +1,22 @@
 import { diagnostic } from '../semantics/diagnostics.js';
 export function validateImportVisibility(items, diagnostics) {
-    const labels = collectLabelVisibility(items);
+    const symbols = collectSymbolVisibility(items);
     for (const item of items) {
-        validateItemReferences(item, labels, diagnostics);
+        validateItemReferences(item, symbols, diagnostics);
     }
 }
-function collectLabelVisibility(items) {
+function collectSymbolVisibility(items) {
     const labels = new Map();
+    const exactSymbols = new Set();
     const importedSourceUnits = importedUnitNames(items);
+    const symbolConflicts = buildSymbolConflictIndex(items);
     for (const item of items) {
+        for (const name of exactSymbolNames(item)) {
+            exactSymbols.add(name);
+        }
+    }
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
         if (item.kind !== 'label')
             continue;
         labels.set(item.name, {
@@ -16,14 +24,75 @@ function collectLabelVisibility(items) {
             definingSourceUnit: item.span.sourceUnit,
             definingSourceName: item.span.sourceName,
             public: isPublicLabel(item, importedSourceUnits),
+            duplicateName: hasAddressPlanningNameConflict(item.name, symbolConflicts, items, index),
         });
     }
-    return labels;
+    return { labels, exactSymbols };
+}
+function buildSymbolConflictIndex(items) {
+    const exact = new Map();
+    const declarationLower = new Map();
+    for (const item of items) {
+        for (const name of exactSymbolNames(item)) {
+            exact.set(name, (exact.get(name) ?? 0) + 1);
+        }
+        const declarationName = caseInsensitiveDeclarationName(item);
+        if (declarationName !== undefined) {
+            const key = declarationName.toLowerCase();
+            declarationLower.set(key, (declarationLower.get(key) ?? 0) + 1);
+        }
+    }
+    return { exact, declarationLower };
+}
+function hasAddressPlanningNameConflict(labelName, conflicts, items, labelIndex) {
+    return ((conflicts.exact.get(labelName) ?? 0) > 1 ||
+        (conflicts.declarationLower.get(labelName.toLowerCase()) ?? 0) > 0 ||
+        hasReportedEnumMemberConflict(labelName, items, labelIndex));
+}
+function hasReportedEnumMemberConflict(labelName, items, labelIndex) {
+    const lowerName = labelName.toLowerCase();
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (item.kind !== 'enum')
+            continue;
+        for (const memberName of qualifiedEnumMemberNames(item)) {
+            if (memberName === labelName)
+                return true;
+            if (index > labelIndex && memberName.toLowerCase() === lowerName)
+                return true;
+        }
+    }
+    return false;
+}
+function exactSymbolNames(item) {
+    switch (item.kind) {
+        case 'label':
+        case 'equ':
+            return [item.name];
+        case 'enum':
+            return qualifiedEnumMemberNames(item);
+        default:
+            return [];
+    }
+}
+function qualifiedEnumMemberNames(item) {
+    return item.kind === 'enum' ? item.members.map((member) => `${item.name}.${member}`) : [];
+}
+function caseInsensitiveDeclarationName(item) {
+    switch (item.kind) {
+        case 'enum':
+        case 'type':
+        case 'type-alias':
+            return item.name;
+        default:
+            return undefined;
+    }
 }
 function importedUnitNames(items) {
     const units = new Set();
     for (const item of items) {
-        if (item.span.sourceRelation === 'import' && item.span.sourceUnit !== undefined) {
+        if (item.span.sourceUnitRelation === 'import' &&
+            item.span.sourceUnit !== undefined) {
             units.add(item.span.sourceUnit);
         }
     }
@@ -34,39 +103,39 @@ function isPublicLabel(item, importedSourceUnits) {
         item.span.sourceUnit === undefined ||
         !importedSourceUnits.has(item.span.sourceUnit));
 }
-function validateItemReferences(item, labels, diagnostics) {
+function validateItemReferences(item, symbols, diagnostics) {
     switch (item.kind) {
         case 'org':
-            validateExpression(item.expression, item.span, labels, diagnostics);
+            validateExpression(item.expression, item.span, symbols, diagnostics);
             return;
         case 'equ':
-            validateExpression(item.expression, item.span, labels, diagnostics);
+            validateExpression(item.expression, item.span, symbols, diagnostics);
             return;
         case 'db':
             for (const value of item.values) {
-                validateDataValue(value, item.span, labels, diagnostics);
+                validateDataValue(value, item.span, symbols, diagnostics);
             }
             return;
         case 'dw':
             for (const value of item.values) {
-                validateExpression(value, item.span, labels, diagnostics);
+                validateExpression(value, item.span, symbols, diagnostics);
             }
             return;
         case 'ds':
-            validateExpression(item.size, item.span, labels, diagnostics);
+            validateExpression(item.size, item.span, symbols, diagnostics);
             if (item.fill !== undefined) {
-                validateExpression(item.fill, item.span, labels, diagnostics);
+                validateExpression(item.fill, item.span, symbols, diagnostics);
             }
             return;
         case 'align':
-            validateExpression(item.alignment, item.span, labels, diagnostics);
+            validateExpression(item.alignment, item.span, symbols, diagnostics);
             return;
         case 'binfrom':
         case 'binto':
-            validateExpression(item.expression, item.span, labels, diagnostics);
+            validateExpression(item.expression, item.span, symbols, diagnostics);
             return;
         case 'instruction':
-            validateInstruction(item.instruction, item.span, labels, diagnostics);
+            validateInstruction(item.instruction, item.span, symbols, diagnostics);
             return;
         case 'label':
         case 'comment':
@@ -78,14 +147,14 @@ function validateItemReferences(item, labels, diagnostics) {
             return;
     }
 }
-function validateDataValue(value, span, labels, diagnostics) {
+function validateDataValue(value, span, symbols, diagnostics) {
     if ('kind' in value && value.kind === 'string-fragment')
         return;
-    validateExpression(value, span, labels, diagnostics);
+    validateExpression(value, span, symbols, diagnostics);
 }
-function validateInstruction(instruction, span, labels, diagnostics) {
+function validateInstruction(instruction, span, symbols, diagnostics) {
     for (const expression of instructionExpressions(instruction)) {
-        validateExpression(expression, span, labels, diagnostics);
+        validateExpression(expression, span, symbols, diagnostics);
     }
 }
 function instructionExpressions(instruction) {
@@ -154,49 +223,55 @@ function operandExpressions(operand) {
             return [];
     }
 }
-function validateExpression(expression, span, labels, diagnostics) {
+function validateExpression(expression, span, symbols, diagnostics) {
     switch (expression.kind) {
         case 'symbol':
-            validateSymbolReference(expression.name, span, labels, diagnostics);
+            validateSymbolReference(expression.name, span, symbols, diagnostics);
             return;
         case 'byte-function':
         case 'unary':
-            validateExpression(expression.expression, span, labels, diagnostics);
+            validateExpression(expression.expression, span, symbols, diagnostics);
             return;
         case 'binary':
-            validateExpression(expression.left, span, labels, diagnostics);
-            validateExpression(expression.right, span, labels, diagnostics);
+            validateExpression(expression.left, span, symbols, diagnostics);
+            validateExpression(expression.right, span, symbols, diagnostics);
             return;
         case 'layout-cast':
-            validateExpression(expression.base, span, labels, diagnostics);
+            validateExpression(expression.base, span, symbols, diagnostics);
             for (const part of expression.path) {
                 if (part.kind === 'index') {
-                    validateExpression(part.expression, span, labels, diagnostics);
+                    validateExpression(part.expression, span, symbols, diagnostics);
                 }
             }
             return;
         case 'number':
         case 'current-location':
-        case 'type-size':
         case 'sizeof':
         case 'offset':
             return;
+        case 'type-size':
+            if (expression.typeExpr.length === undefined) {
+                validateSymbolReference(expression.typeExpr.name, span, symbols, diagnostics);
+            }
+            return;
     }
 }
-function validateSymbolReference(name, referenceSpan, labels, diagnostics) {
-    const label = lookupLabel(labels, name);
-    if (!label || label.public)
+function validateSymbolReference(name, referenceSpan, symbols, diagnostics) {
+    const label = lookupLabel(symbols, name);
+    if (!label || label.duplicateName || label.public)
         return;
     if (referenceSpan.sourceUnit === label.definingSourceUnit)
         return;
     diagnostics.push(diagnostic(referenceSpan, `symbol "${name}" is private to ${label.definingSourceName}; export it with @${label.name} or keep the reference inside that file`));
 }
-function lookupLabel(labels, name) {
-    const direct = labels.get(name);
+function lookupLabel(symbols, name) {
+    const direct = symbols.labels.get(name);
     if (direct)
         return direct;
+    if (symbols.exactSymbols.has(name))
+        return undefined;
     const lowerName = name.toLowerCase();
-    for (const [key, label] of labels) {
+    for (const [key, label] of symbols.labels) {
         if (key.toLowerCase() === lowerName)
             return label;
     }

package/dist/src/core/compile.js

@@ -2,10 +2,12 @@ import { assembleProgram } from '../assembly/assemble-program.js';
 import { writeIntelHex } from '../outputs/hex.js';
 import { createSourceFile } from '../source/source-file.js';
 import { scanLogicalLines } from '../source/logical-lines.js';
-import { stripLineComment } from '../source/strip-line-comment.js';
+import { extractLineComment, stripLineComment } from '../source/strip-line-comment.js';
+import { parseInstructionChain } from '../syntax/parse-instruction-chain.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
 import { parseLayoutDeclarationAt } from '../syntax/parse-layout-declarations.js';
 import { collectOps, expandOpInvocation, parseOpInvocation, } from '../expansion/op-expansion.js';
+import { parseZ80Instruction } from '../z80/parse-instruction.js';
 import { applyConditionalAssembly } from './conditional-assembly.js';
 export function parseNextSourceItems(lines, options = {}) {
     const diagnostics = [];
@@ -43,6 +45,9 @@ function parsePendingLine(context, index, afterTopLevelEnd) {
     if (parseExpandedOpLine(context, line)) {
         return { consumedUntilIndex: index, afterTopLevelEnd };
     }
+    if (parseInstructionChainLine(context, line)) {
+        return { consumedUntilIndex: index, afterTopLevelEnd };
+    }
     return parseNormalLine(context, index, line, afterTopLevelEnd);
 }
 function shouldSkipPendingLine(context, index, line, afterTopLevelEnd) {
@@ -78,6 +83,98 @@ function parseNormalLine(context, index, line, afterTopLevelEnd) {
         afterTopLevelEnd: afterTopLevelEnd || result.items.some((item) => item.kind === 'end'),
     };
 }
+function parseInstructionChainLine(context, line) {
+    const parsed = parseInstructionChain({
+        line,
+        parseStatement: (segmentLine, statementText, statementColumn) => parseChainStatement(context, segmentLine, statementText, statementColumn),
+        makeLabelItem: (label, segmentLine) => ({
+            kind: 'label',
+            name: label.name,
+            ...(label.isEntry ? { isEntry: true } : {}),
+            span: spanAt(segmentLine, label.labelColumn),
+        }),
+        makeDiagnostic: chainDiagnostic,
+        appendLineComment: appendChainComment,
+    });
+    if (parsed === undefined)
+        return false;
+    context.diagnostics.push(...parsed.diagnostics);
+    context.items.push(...parsed.items);
+    return true;
+}
+function parseChainStatement(context, line, statementText, statementColumn) {
+    const segmentLine = paddedSegmentLine(line, statementText, statementColumn);
+    const opCall = parseOpInvocation(segmentLine);
+    const overloads = opCall ? context.ops.get(opCall.name) : undefined;
+    if (opCall && overloads) {
+        const diagnostics = [];
+        return {
+            items: expandOpInvocation(context.ops, overloads, opCall.operands, segmentLine, diagnostics),
+            diagnostics,
+        };
+    }
+    return parseChainInstruction(line, statementText, statementColumn);
+}
+function parseChainInstruction(line, text, column) {
+    const instruction = parseZ80Instruction(text);
+    if (instruction?.instruction) {
+        return {
+            items: [{ kind: 'instruction', instruction: instruction.instruction, span: spanAt(line, column) }],
+            diagnostics: [],
+        };
+    }
+    if (instruction?.diagnostics && instruction.diagnostics.length > 0) {
+        return {
+            items: [],
+            diagnostics: instruction.diagnostics.map((message) => chainDiagnostic(line, column, message)),
+        };
+    }
+    if (instruction?.error) {
+        return { items: [], diagnostics: [chainDiagnostic(line, column, instruction.error)] };
+    }
+    return {
+        items: [],
+        diagnostics: [chainDiagnostic(line, column, `unsupported source line: ${text}`)],
+    };
+}
+function appendChainComment(items, line) {
+    const comment = extractLineComment(line.text);
+    if (!comment)
+        return;
+    items.push({
+        kind: 'comment',
+        text: comment,
+        origin: 'user',
+        span: spanAt(line, firstColumn(line.text)),
+    });
+}
+function paddedSegmentLine(line, text, column) {
+    return { ...line, text: `${' '.repeat(Math.max(0, column - 1))}${text}` };
+}
+function spanAt(line, column) {
+    return {
+        sourceName: line.sourceName,
+        line: line.line,
+        column,
+        ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
+        ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+        ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
+    };
+}
+function firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}
+function chainDiagnostic(line, column, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column,
+    };
+}
 export function compileSource(sourceText, options = {}) {
     const source = createSourceFile(options.entryName ?? '<memory>', sourceText);
     const { diagnostics, items } = parseNextSourceItems(scanLogicalLines(source));

package/dist/src/expansion/op-expand-selected.js

@@ -60,7 +60,14 @@ function expandTemplateItem(ops, item, bindings, line, diagnostics, overload, ex
 }
 function opEmittedSource(line) {
     return {
-        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+        span: {
+            sourceName: line.sourceName,
+            line: line.line,
+            column: firstColumn(line.text),
+            ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
+            ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+            ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
+        },
         kind: 'macro',
     };
 }

package/dist/src/expansion/op-expansion.d.ts

@@ -6,6 +6,9 @@ export type LogicalLineLike = {
     readonly sourceName: string;
     readonly line: number;
     readonly text: string;
+    readonly sourceUnit?: string;
+    readonly sourceRelation?: 'entry' | 'include' | 'import';
+    readonly sourceUnitRelation?: 'entry' | 'include' | 'import';
 };
 interface OpParam {
     readonly name: string;

package/dist/src/expansion/op-expansion.js

@@ -1,4 +1,6 @@
 import { stripLineComment } from '../source/strip-line-comment.js';
+import { IDENTIFIER_PATTERN } from '../syntax/names.js';
+import { parseInstructionChain, } from '../syntax/parse-instruction-chain.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
 import { expandSelectedOp } from './op-expand-selected.js';
 import { splitOperands } from './op-operand-splitting.js';
@@ -21,7 +23,7 @@ export function collectOps(lines, diagnostics, parseOptions = {}) {
     return { ops, opLineIndexes };
 }
 function parseOpHeader(line, diagnostics) {
-    const opHeader = /^op\s+([A-Za-z_][A-Za-z0-9_]*)\s*\((.*)\)\s*$/i.exec(stripLineComment(line.text).trim());
+    const opHeader = new RegExp(`^op\\s+(${IDENTIFIER_PATTERN})\\s*\\((.*)\\)\\s*$`, 'i').exec(stripLineComment(line.text).trim());
     if (!opHeader)
         return undefined;
     return { name: opHeader[1] ?? '', params: parseOpParams(opHeader[2] ?? '', line, diagnostics) };
@@ -35,9 +37,8 @@ function collectOpBody(lines, startIndex, params, diagnostics, parseOptions, opL
         if (isOpEnd(bodyLine.text)) {
             return { body, terminated: true, endIndex: index };
         }
-        const template = parseOpBodyTemplate(bodyLine, paramNames, diagnostics, parseOptions);
-        if (template)
-            body.push(template);
+        const templates = parseOpBodyTemplates(bodyLine, paramNames, diagnostics, parseOptions);
+        body.push(...templates);
     }
     return { body, terminated: false, endIndex: lines.length };
 }
@@ -60,7 +61,7 @@ function recordCollectedOp(ops, header, collected, line, diagnostics) {
 }
 export function parseOpInvocation(line) {
     const text = stripLineComment(line.text).trim();
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.+))?$/.exec(text);
+    const match = new RegExp(`^(${IDENTIFIER_PATTERN})(?:\\s+(.+))?$`).exec(text);
     if (!match) {
         return undefined;
     }
@@ -87,7 +88,7 @@ function parseOpParams(text, line, diagnostics) {
     }
     const params = [];
     for (const part of parts) {
-        const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+([A-Za-z][A-Za-z0-9_]*)$/.exec(part.trim());
+        const match = new RegExp(`^(${IDENTIFIER_PATTERN})\\s+([A-Za-z][A-Za-z0-9_]*)$`).exec(part.trim());
         if (!match) {
             diagnostics.push(parseDiagnostic(line, 'Invalid op parameter list: trailing or empty entries are not permitted.'));
             continue;
@@ -115,8 +116,42 @@ function parseOpBodyTemplate(line, paramNames, diagnostics, parseOptions) {
         return parsedSource;
     return template;
 }
+function parseOpBodyTemplates(line, paramNames, diagnostics, parseOptions) {
+    const parsed = parseInstructionChain({
+        line,
+        parseStatement: (segmentLine, statementText, statementColumn) => parseOpBodyStatement(paddedLine(segmentLine, statementText, statementColumn), paramNames, diagnostics, parseOptions),
+        makeLabelItem: (label, segmentLine) => ({
+            kind: 'source-items',
+            items: [
+                {
+                    kind: 'label',
+                    name: label.name,
+                    ...(label.isEntry ? { isEntry: true } : {}),
+                    span: { sourceName: segmentLine.sourceName, line: segmentLine.line, column: label.labelColumn },
+                },
+            ],
+        }),
+        makeDiagnostic: parseDiagnosticAt,
+    });
+    if (parsed === undefined) {
+        const template = parseOpBodyTemplate(line, paramNames, diagnostics, parseOptions);
+        return template ? [template] : [];
+    }
+    diagnostics.push(...parsed.diagnostics);
+    return parsed.items;
+}
+function parseOpBodyStatement(line, paramNames, diagnostics, parseOptions) {
+    const statementDiagnostics = [];
+    const template = parseOpBodyTemplate(line, paramNames, statementDiagnostics, parseOptions);
+    return template
+        ? { items: [template], diagnostics: statementDiagnostics }
+        : { items: [], diagnostics: statementDiagnostics };
+}
+function paddedLine(line, text, column) {
+    return { ...line, text: `${' '.repeat(Math.max(0, column - 1))}${text}` };
+}
 function parseTemplateInstructionCandidate(text, paramNames) {
-    const instruction = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.+))?$/.exec(text);
+    const instruction = new RegExp(`^(${IDENTIFIER_PATTERN})(?:\\s+(.+))?$`).exec(text);
     if (!instruction)
         return undefined;
     const operands = parseTemplateOperands(instruction[2] ?? '', paramNames);
@@ -155,7 +190,7 @@ function parseTemplateOperand(text, paramNames) {
     if (paramNames.has(trimmed)) {
         return { kind: 'param', name: trimmed };
     }
-    const portParam = /^\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)$/.exec(trimmed);
+    const portParam = new RegExp(`^\\(\\s*(${IDENTIFIER_PATTERN})\\s*\\)$`).exec(trimmed);
     if (portParam && paramNames.has(portParam[1] ?? '')) {
         return { kind: 'port-param', name: portParam[1] ?? '' };
     }
@@ -169,13 +204,16 @@ function isOpEnd(text) {
     return /^end\s*$/i.test(stripLineComment(text).trim());
 }
 function parseDiagnostic(line, message) {
+    return parseDiagnosticAt(line, firstColumn(line.text), message);
+}
+function parseDiagnosticAt(line, column, message) {
     return {
         severity: 'error',
         code: 'AZMN_PARSE',
         message,
         sourceName: line.sourceName,
         line: line.line,
-        column: firstColumn(line.text),
+        column,
     };
 }
 function firstColumn(text) {

package/dist/src/node/source-host.js

@@ -30,6 +30,7 @@ export async function expandSourceForTooling(options) {
         sourceStack: [],
         sourceUnit: entryFile,
         sourceRelation: 'entry',
+        sourceUnitRelation: 'entry',
         ...(options.preloadedText !== undefined ? { preloadedText: options.preloadedText } : {}),
         ...(options.signal !== undefined ? { signal: options.signal } : {}),
     });
@@ -60,7 +61,7 @@ async function expandFile(options) {
         recordLineComment(options.sourceLineComments, line);
         const directive = parseSourceLoadDirective(line.text);
         if (!directive) {
-            output.push(withSourceOwnership(line, options.sourceUnit, options.sourceRelation));
+            output.push(withSourceOwnership(line, options.sourceUnit, options.sourceRelation, options.sourceUnitRelation));
             continue;
         }
         const result = await resolveSourcePath(sourcePath, directive.path, options.includeDirs);
@@ -88,6 +89,7 @@ async function expandFile(options) {
             sourceStack: [...options.sourceStack, { sourcePath }],
             sourceUnit: directive.kind === 'import' ? result.resolved : options.sourceUnit,
             sourceRelation: directive.kind,
+            sourceUnitRelation: directive.kind === 'import' ? 'import' : options.sourceUnitRelation,
         });
         if (included !== undefined) {
             output.push(...included);
@@ -95,11 +97,12 @@ async function expandFile(options) {
     }
     return output;
 }
-function withSourceOwnership(line, sourceUnit, sourceRelation) {
+function withSourceOwnership(line, sourceUnit, sourceRelation, sourceUnitRelation) {
     return {
         ...line,
         sourceUnit,
         sourceRelation,
+        sourceUnitRelation,
     };
 }
 function recordLineComment(comments, line) {

package/dist/src/outputs/d8-files.js

@@ -53,6 +53,7 @@ function addSourceSegments(entries, sourceSegments) {
             start: segment.start,
             end: segment.end,
             line: segment.line,
+            column: segment.column,
             lstLine: segment.line,
             kind: segment.kind,
             confidence: segment.confidence,

package/dist/src/outputs/types.d.ts

@@ -100,6 +100,7 @@ export interface D8mSegment {
     end: number;
     lstLine: number;
     line?: number;
+    column?: number;
     kind: D8mSegmentKind;
     confidence: D8mSegmentConfidence;
 }

package/dist/src/source/instruction-chain.d.ts

@@ -0,0 +1,5 @@
+export interface InstructionChainSegment {
+    readonly text: string;
+    readonly column: number;
+}
+export declare function splitInstructionChain(text: string): readonly InstructionChainSegment[] | undefined;

package/dist/src/source/instruction-chain.js

@@ -0,0 +1,75 @@
+import { findLineCommentStart } from './line-comment-scanner.js';
+export function splitInstructionChain(text) {
+    const commentStart = findLineCommentStart(text);
+    const codeText = commentStart === undefined ? text : text.slice(0, commentStart);
+    const separators = findChainSeparators(codeText);
+    if (separators.length === 0)
+        return undefined;
+    const segments = [];
+    let start = 0;
+    for (const separator of [...separators, codeText.length]) {
+        const raw = codeText.slice(start, separator);
+        segments.push(segmentFromRaw(raw, start));
+        start = separator + 1;
+    }
+    return segments;
+}
+function findChainSeparators(text) {
+    const separators = [];
+    let state = {};
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (state.escaped === true) {
+            state = { ...state, escaped: false };
+            continue;
+        }
+        if (char === '\\' && state.quote !== undefined) {
+            state = { ...state, escaped: true };
+            continue;
+        }
+        if (startsOrEndsQuote(text, index, state)) {
+            state =
+                state.quote === char
+                    ? withoutQuote(state)
+                    : withQuote(state, state.quote ?? char ?? '');
+            continue;
+        }
+        if (char === '\\' && isReadableSeparator(text, index)) {
+            separators.push(index);
+        }
+    }
+    return separators;
+}
+function segmentFromRaw(raw, rawStart) {
+    const leading = /^\s*/.exec(raw)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(raw)?.[0].length ?? 0;
+    const text = raw.slice(leading, raw.length - trailing);
+    return {
+        text,
+        column: rawStart + (text.length === 0 ? 0 : leading) + 1,
+    };
+}
+function startsOrEndsQuote(text, index, state) {
+    const char = text[index];
+    return isQuote(char) && !isApostropheSuffix(text, index, state);
+}
+function isQuote(char) {
+    return char === '"' || char === "'";
+}
+function isApostropheSuffix(text, index, state) {
+    return (state.quote === undefined &&
+        text[index] === "'" &&
+        /[A-Za-z0-9_]/.test(text[index - 1] ?? ''));
+}
+function withoutQuote(state) {
+    return state.escaped === true ? { escaped: true } : {};
+}
+function withQuote(state, quote) {
+    return {
+        quote,
+        ...(state.escaped === true ? { escaped: true } : {}),
+    };
+}
+function isReadableSeparator(text, index) {
+    return /\s/.test(text[index - 1] ?? '') && /\s/.test(text[index + 1] ?? '');
+}