@jhlagado/azm 0.2.7 → 0.2.9

package/dist/src/syntax/parse-line.js

@@ -1,13 +1,13 @@
 import { extractLineComment, stripLineComment } from '../source/strip-line-comment.js';
 import { normalizeDirectiveAlias } from './directive-aliases.js';
-import { parseExpression, parseTypeExpr } from './parse-expression.js';
+import { parseColonDeclaration, parseDirectiveStatement } from './parse-directive-statement.js';
 import { parseZ80Instruction } from '../z80/parse-instruction.js';
 export function parseLogicalLine(line, options = {}) {
     const text = normalizeDirectiveAlias(stripLineComment(line.text), options.directiveAliasPolicy).trim();
     if (text.length === 0) {
         return commentOnlyLine(line);
     }
-    const span = { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) };
+    const span = spanForLine(line);
     const labelWithStatement = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):\s*(.+)$/.exec(text);
     if (labelWithStatement) {
         const rawLabel = labelWithStatement[1] ?? '';
@@ -20,7 +20,10 @@ export function parseLogicalLine(line, options = {}) {
         }
         const parsedStatement = parseCanonicalStatement(line, statementText, span);
         return withLineComment(line, {
-            items: [{ kind: 'label', name: labelName, ...(isEntry ? { isEntry: true } : {}), span }, ...parsedStatement.items],
+            items: [
+                { kind: 'label', name: labelName, ...(isEntry ? { isEntry: true } : {}), span },
+                ...parsedStatement.items,
+            ],
             diagnostics: parsedStatement.diagnostics,
         });
     }
@@ -56,6 +59,8 @@ function commentOnlyLine(line) {
                     sourceName: line.sourceName,
                     line: line.line,
                     column: firstColumn(line.text),
+                    ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
+                    ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
                 },
             },
         ],
@@ -78,155 +83,18 @@ function withLineComment(line, result) {
                     sourceName: line.sourceName,
                     line: line.line,
                     column: firstColumn(line.text),
+                    ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
+                    ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
                 },
             },
         ],
         diagnostics: result.diagnostics,
     };
 }
-function parseEquItem(line, name, expressionText, span) {
-    const stringValue = parseWholeQuotedString(expressionText.trim());
-    const expression = stringValue !== undefined && stringValue.length > 1
-        ? { kind: 'number', value: 0 }
-        : parseExpression(expressionText);
-    if (!expression) {
-        return {
-            items: [],
-            diagnostics: [parseError(line, `invalid .equ expression: ${expressionText}`)],
-        };
-    }
-    return {
-        items: [
-            {
-                kind: 'equ',
-                name,
-                expression,
-                ...(stringValue !== undefined && stringValue.length > 1 ? { stringValue } : {}),
-                span,
-            },
-        ],
-        diagnostics: [],
-    };
-}
 function parseCanonicalStatement(line, text, span) {
-    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/.exec(text);
-    if (equ) {
-        return parseEquItem(line, equ[1] ?? '', equ[2] ?? '', span);
-    }
-    const org = /^\.org\s+(.+)$/.exec(text);
-    if (org) {
-        const expressionText = org[1] ?? '';
-        const expression = parseExpression(expressionText);
-        if (!expression) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid .org expression: ${expressionText}`)],
-            };
-        }
-        return { items: [{ kind: 'org', expression, span }], diagnostics: [] };
-    }
-    const enumDecl = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/.exec(text);
-    if (enumDecl) {
-        return {
-            items: [],
-            diagnostics: [parseError(line, `Use "${enumDecl[1] ?? ''} .enum ..." for enums.`)],
-        };
-    }
-    const nameLeftEnum = /^([A-Za-z_][A-Za-z0-9_]*)\s+\.enum\s+(.+)$/.exec(text);
-    if (nameLeftEnum) {
-        return parseEnumItem(line, nameLeftEnum[1] ?? '', nameLeftEnum[2] ?? '', span);
-    }
-    const data = /^(\.db|\.dw)\s+(.+)$/.exec(text);
-    if (data) {
-        const directive = (data[1] ?? '').slice(1).toLowerCase();
-        const valueText = data[2] ?? '';
-        const parts = splitValueList(valueText);
-        const values = directive === 'db'
-            ? parts.map(parseDataValue).filter((value) => value !== undefined)
-            : parts.map(parseExpression).filter((value) => value !== undefined);
-        if (values.length !== parts.length) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid .${directive} value list`)],
-            };
-        }
-        return {
-            items: directive === 'db'
-                ? [{ kind: 'db', values: values, span }]
-                : [{ kind: 'dw', values: values, span }],
-            diagnostics: [],
-        };
-    }
-    const ds = /^\.ds\s+(.+)$/.exec(text);
-    if (ds) {
-        const parts = splitValueList(ds[1] ?? '');
-        if (parts.length < 1 || parts.length > 2) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid .ds value list`)],
-            };
-        }
-        const sizeText = parts[0] ?? '';
-        const size = parseTypeSizeExpression(sizeText) ?? parseExpression(sizeText);
-        if (!size) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid .ds size: ${sizeText}`)],
-            };
-        }
-        const fillText = parts[1];
-        const fill = fillText === undefined ? undefined : parseExpression(fillText);
-        if (fillText !== undefined && !fill) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid .ds fill: ${fillText}`)],
-            };
-        }
-        return {
-            items: [fill === undefined ? { kind: 'ds', size, span } : { kind: 'ds', size, fill, span }],
-            diagnostics: [],
-        };
-    }
-    const align = /^\.align\s+(.+)$/.exec(text);
-    if (align) {
-        const expressionText = align[1] ?? '';
-        const alignment = parseExpression(expressionText);
-        if (!alignment) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid .align expression: ${expressionText}`)],
-            };
-        }
-        return { items: [{ kind: 'align', alignment, span }], diagnostics: [] };
-    }
-    if (/^\.end\s*$/.test(text)) {
-        return { items: [{ kind: 'end', span }], diagnostics: [] };
-    }
-    const rangeControl = /^(\.binfrom|\.binto)\s+(.+)$/.exec(text);
-    if (rangeControl) {
-        const kind = (rangeControl[1] ?? '').slice(1).toLowerCase();
-        const expressionText = rangeControl[2] ?? '';
-        const expression = parseExpression(expressionText);
-        if (!expression) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid .${kind} expression: ${expressionText}`)],
-            };
-        }
-        return { items: [{ kind, expression, span }], diagnostics: [] };
-    }
-    const stringData = /^(\.cstr|\.pstr|\.istr)\s+(.+)$/.exec(text);
-    if (stringData) {
-        const directive = (stringData[1] ?? '').slice(1).toLowerCase();
-        const valueText = stringData[2] ?? '';
-        const value = parseQuotedString(valueText);
-        if (value === undefined) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `.${directive} expects one double-quoted string`)],
-            };
-        }
-        return { items: [{ kind: 'string-data', directive, value, span }], diagnostics: [] };
+    const directive = parseDirectiveStatement(line, text, span);
+    if (directive) {
+        return directive;
     }
     const instruction = parseZ80Instruction(text);
     if (instruction?.instruction) {
@@ -246,134 +114,14 @@ function parseCanonicalStatement(line, text, span) {
     }
     return { items: [], diagnostics: [parseError(line, `unsupported source line: ${text}`)] };
 }
-function parseColonDeclaration(line, name, statementText, span) {
-    const equ = /^\.equ\s+(.+)$/.exec(statementText);
-    if (equ) {
-        return parseEquItem(line, name, equ[1] ?? '', span);
-    }
-    const enumDecl = /^\.enum\s+(.+)$/.exec(statementText);
-    if (enumDecl) {
-        return parseEnumItem(line, name, enumDecl[1] ?? '', span);
-    }
-    return undefined;
-}
-function parseEnumItem(line, name, membersText, span) {
-    const rawMembers = membersText.split(',').map((member) => member.trim());
-    if (membersText.trim().length === 0 || rawMembers.some((member) => member.length === 0)) {
-        return {
-            items: [],
-            diagnostics: [parseError(line, `invalid enum member list`)],
-        };
-    }
-    const members = [];
-    const diagnostics = [];
-    for (const member of rawMembers) {
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(member)) {
-            diagnostics.push(parseError(line, `Invalid enum member name "${member}": expected <identifier>.`));
-            continue;
-        }
-        members.push(member);
-    }
-    if (diagnostics.length > 0) {
-        return { items: [], diagnostics };
-    }
-    return { items: [{ kind: 'enum', name, members, span }], diagnostics: [] };
-}
-function parseTypeSizeExpression(text) {
-    const typeExpr = parseTypeExpr(text);
-    return typeExpr ? { kind: 'type-size', typeExpr } : undefined;
-}
-function splitValueList(text) {
-    const values = [];
-    let quote;
-    let escaped = false;
-    let parenDepth = 0;
-    let start = 0;
-    for (let index = 0; index < text.length; index += 1) {
-        const char = text[index];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (char === '\\' && quote) {
-            escaped = true;
-            continue;
-        }
-        if (char === '"' || char === "'") {
-            quote = quote === char ? undefined : (quote ?? char);
-            continue;
-        }
-        if (!quote && char === '(') {
-            parenDepth += 1;
-            continue;
-        }
-        if (!quote && char === ')') {
-            parenDepth = Math.max(0, parenDepth - 1);
-            continue;
-        }
-        if (char === ',' && !quote && parenDepth === 0) {
-            values.push(text.slice(start, index));
-            start = index + 1;
-        }
-    }
-    values.push(text.slice(start));
-    return values;
-}
-function parseQuotedString(text) {
-    const input = text.trim();
-    const quote = input[0];
-    if (quote !== '"' || input[input.length - 1] !== quote) {
-        return undefined;
-    }
-    let value = '';
-    for (let index = 1; index < input.length - 1; index += 1) {
-        const char = input[index] ?? '';
-        if (char === '\\') {
-            if (index + 1 >= input.length - 1) {
-                return undefined;
-            }
-            value += input[index + 1] ?? '';
-            index += 1;
-            continue;
-        }
-        if (char === quote) {
-            return undefined;
-        }
-        value += char;
-    }
-    return value;
-}
-function parseDataValue(text) {
-    const expression = parseExpression(text);
-    if (expression) {
-        return expression;
-    }
-    const value = parseWholeQuotedString(text);
-    return value === undefined ? undefined : { kind: 'string-fragment', value };
-}
-function parseWholeQuotedString(text) {
-    const input = text.trim();
-    const quote = input[0];
-    if ((quote !== '"' && quote !== "'") || input[input.length - 1] !== quote) {
-        return undefined;
-    }
-    let value = '';
-    for (let index = 1; index < input.length - 1; index += 1) {
-        const char = input[index] ?? '';
-        if (char === '\\') {
-            if (index + 1 >= input.length - 1) {
-                return undefined;
-            }
-            value += input[index + 1] ?? '';
-            index += 1;
-            continue;
-        }
-        if (char === quote) {
-            return undefined;
-        }
-        value += char;
-    }
-    return value;
+function spanForLine(line) {
+    return {
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstColumn(line.text),
+        ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
+        ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+    };
 }
 function normalizeEntryLabelName(raw) {
     return raw.startsWith('@') ? raw.slice(1) : raw;

package/dist/src/syntax/parse-token-expression.d.ts

@@ -0,0 +1,3 @@
+import type { Expression } from '../model/expression.js';
+import type { Token } from './expression-tokenizer.js';
+export declare function parseTokenExpression(tokenList: readonly Token[]): Expression | undefined;

package/dist/src/syntax/parse-token-expression.js

@@ -0,0 +1,133 @@
+const PRECEDENCE = new Map([
+    ['|', 1],
+    ['^', 2],
+    ['&', 3],
+    ['<<', 4],
+    ['>>', 4],
+    ['+', 5],
+    ['-', 5],
+    ['*', 6],
+    ['/', 6],
+    ['%', 6],
+]);
+export function parseTokenExpression(tokenList) {
+    let index = 0;
+    function consume() {
+        const token = tokenList[index];
+        if (!token) {
+            throw new Error('parseExpression consumed past end of token list');
+        }
+        index += 1;
+        return token;
+    }
+    function parsePrimary() {
+        const token = tokenList[index];
+        if (!token)
+            return undefined;
+        if (token.kind === 'number')
+            return parseNumberToken(consume());
+        if (token.kind === 'expression')
+            return parseNestedExpressionToken(consume());
+        if (token.kind === 'symbol')
+            return parseSymbolPrimary();
+        if (token.kind === 'current-location')
+            return parseCurrentLocationPrimary();
+        if (token.kind === 'operator' && isUnaryOperator(token.text)) {
+            return parseUnaryPrimary(token.text);
+        }
+        if (token.kind === 'left-paren')
+            return parseParenthesizedPrimary();
+        return undefined;
+    }
+    function parseNumberToken(token) {
+        return token.kind === 'number' ? { kind: 'number', value: token.value } : undefined;
+    }
+    function parseNestedExpressionToken(token) {
+        return token.kind === 'expression' ? token.expression : undefined;
+    }
+    function parseCurrentLocationPrimary() {
+        consume();
+        return { kind: 'current-location' };
+    }
+    function parseSymbolPrimary() {
+        const token = tokenList[index];
+        if (token?.kind !== 'symbol')
+            return undefined;
+        if (token.text === 'sizeof' && tokenList[index + 1]?.kind === 'left-paren') {
+            return parseSizeofPrimary();
+        }
+        if (token.text === 'offset' && tokenList[index + 1]?.kind === 'left-paren') {
+            return parseOffsetPrimary();
+        }
+        index += 1;
+        return { kind: 'symbol', name: token.text };
+    }
+    function parseSizeofPrimary() {
+        index += 2;
+        const typeName = tokenList[index];
+        if (typeName?.kind !== 'symbol' || tokenList[index + 1]?.kind !== 'right-paren') {
+            return undefined;
+        }
+        index += 2;
+        return { kind: 'sizeof', typeExpr: { name: typeName.text } };
+    }
+    function parseOffsetPrimary() {
+        index += 2;
+        const typeName = tokenList[index];
+        const comma = tokenList[index + 1];
+        const fieldName = tokenList[index + 2];
+        const rightParen = tokenList[index + 3];
+        if (typeName?.kind !== 'symbol' ||
+            comma?.kind !== 'comma' ||
+            fieldName?.kind !== 'symbol' ||
+            rightParen?.kind !== 'right-paren') {
+            return undefined;
+        }
+        index += 4;
+        return {
+            kind: 'offset',
+            typeExpr: { name: typeName.text },
+            path: [{ kind: 'field', name: fieldName.text }],
+        };
+    }
+    function parseUnaryPrimary(operator) {
+        index += 1;
+        const expression = parsePrimary();
+        return expression ? { kind: 'unary', operator, expression } : undefined;
+    }
+    function parseParenthesizedPrimary() {
+        index += 1;
+        const expression = parseBinary(1);
+        if (!expression || tokenList[index]?.kind !== 'right-paren')
+            return undefined;
+        index += 1;
+        return expression;
+    }
+    function parseBinary(minPrecedence) {
+        let left = parsePrimary();
+        if (!left)
+            return undefined;
+        while (true) {
+            const token = tokenList[index];
+            if (!token || token.kind !== 'operator' || !isBinaryOperator(token.text))
+                break;
+            const precedence = PRECEDENCE.get(token.text) ?? 0;
+            if (precedence < minPrecedence)
+                break;
+            index += 1;
+            const right = parseBinary(precedence + 1);
+            if (!right)
+                return undefined;
+            left = { kind: 'binary', operator: token.text, left, right };
+        }
+        return left;
+    }
+    const expression = parseBinary(1);
+    return expression && index === tokenList.length ? expression : undefined;
+}
+function isUnaryOperator(operator) {
+    return operator === '+' || operator === '-' || operator === '~';
+}
+function isBinaryOperator(operator) {
+    return PRECEDENCE.has(operator);
+}

package/dist/src/tooling/api.js

@@ -34,7 +34,7 @@ export function analyzeProgramNext(loadedProgram, options = {}) {
         mode: options.caseStyle ?? 'off',
     });
     return {
-        diagnostics: caseStyleDiagnostics,
+        diagnostics: [...assembly.diagnostics, ...caseStyleDiagnostics],
         env: { symbols: assembly.symbols },
     };
 }

package/dist/src/tooling/case-style.js

@@ -40,29 +40,38 @@ function lintInstructionLine(rawLine, sourceName, line, mode, state, diagnostics
 }
 function lintSourceLines(sourceLines, instructionLines, mode, state, diagnostics) {
     for (const [sourceName, lines] of sourceLines) {
-        let inOpBody = false;
+        const lineState = { inOpBody: false };
         for (let index = 0; index < lines.length; index += 1) {
             const line = index + 1;
             const rawLine = lines[index] ?? '';
-            const text = stripLeadingLabels(stripLineComment(rawLine)).trim();
-            if (text.length === 0)
-                continue;
-            if (/^op\s+[A-Za-z_][A-Za-z0-9_]*\s*\(/i.test(text)) {
-                inOpBody = true;
-                continue;
-            }
-            if (inOpBody && /^end\s*$/i.test(text)) {
-                inOpBody = false;
-                continue;
-            }
-            if (inOpBody ||
-                instructionLines.has(lineKey(sourceName, line)) ||
-                isPotentialOpInvocationLine(text)) {
+            if (shouldLintCaseStyleLine(rawLine, sourceName, line, instructionLines, lineState)) {
                 lintInstructionLine(rawLine, sourceName, line, mode, state, diagnostics);
             }
         }
     }
 }
+function shouldLintCaseStyleLine(rawLine, sourceName, line, instructionLines, state) {
+    const text = stripLeadingLabels(stripLineComment(rawLine)).trim();
+    if (text.length === 0)
+        return false;
+    if (isOpHeaderLine(text)) {
+        state.inOpBody = true;
+        return false;
+    }
+    if (state.inOpBody && isOpEndLine(text)) {
+        state.inOpBody = false;
+        return false;
+    }
+    return (state.inOpBody ||
+        instructionLines.has(lineKey(sourceName, line)) ||
+        isPotentialOpInvocationLine(text));
+}
+function isOpHeaderLine(text) {
+    return /^op\s+[A-Za-z_][A-Za-z0-9_]*\s*\(/i.test(text);
+}
+function isOpEndLine(text) {
+    return /^end\s*$/i.test(text);
+}
 function isPotentialOpInvocationLine(text) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*(?:\s+.*)?$/.test(text))
         return false;
@@ -86,23 +95,31 @@ function lintToken(mode, state, token, category, sourceName, line, diagnostics)
     if (!style)
         return;
     if (mode === 'consistent') {
-        if (!state.consistentStyle && (style === 'upper' || style === 'lower')) {
-            state.consistentStyle = style;
-            return;
-        }
-        const expected = state.consistentStyle;
-        if (!expected || style === expected)
-            return;
-        diagnostics.push({
-            severity: 'warning',
-            code: 'AZMN_CASE_STYLE',
-            message: `Case-style lint: ${category} "${token}" does not match established ${expected}case style under --case-style=consistent.`,
-            sourceName,
-            line,
-            column: 1,
-        });
+        lintConsistentToken(state, style, token, category, sourceName, line, diagnostics);
         return;
     }
+    if (mode === 'off')
+        return;
+    lintFixedStyleToken(mode, style, token, category, sourceName, line, diagnostics);
+}
+function lintConsistentToken(state, style, token, category, sourceName, line, diagnostics) {
+    if (!state.consistentStyle && (style === 'upper' || style === 'lower')) {
+        state.consistentStyle = style;
+        return;
+    }
+    const expected = state.consistentStyle;
+    if (!expected || style === expected)
+        return;
+    diagnostics.push({
+        severity: 'warning',
+        code: 'AZMN_CASE_STYLE',
+        message: `Case-style lint: ${category} "${token}" does not match established ${expected}case style under --case-style=consistent.`,
+        sourceName,
+        line,
+        column: 1,
+    });
+}
+function lintFixedStyleToken(mode, style, token, category, sourceName, line, diagnostics) {
     if (style === mode)
         return;
     const expectedText = mode === 'upper' ? 'uppercase' : 'lowercase';

package/dist/src/z80/effect-groups.d.ts

@@ -0,0 +1,38 @@
+import type { ControlEffect, InstructionEffect, RegisterContractsUnit } from '../register-contracts/types.js';
+import type { Z80Instruction, Z80StackRegister16 } from './instruction.js';
+export declare function callControl(target: string | undefined, conditional: boolean): ControlEffect;
+export declare function rstControl(vector: number | undefined): ControlEffect;
+export declare function jumpControl(target: string | undefined, conditional: boolean): ControlEffect;
+export declare function controlEffect(control: ControlEffect, reads?: RegisterContractsUnit[]): InstructionEffect;
+export declare function stackControlEffect(control: ControlEffect, reads?: RegisterContractsUnit[]): InstructionEffect;
+export declare function ldEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'ld';
+}>): InstructionEffect;
+export declare function incDecEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'inc' | 'dec';
+}>): InstructionEffect;
+export declare function aluEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'add' | 'adc' | 'sbc';
+}>): InstructionEffect;
+export declare function aluEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'sub' | 'and' | 'or' | 'xor' | 'cp' | 'add' | 'adc' | 'sbc';
+}>): InstructionEffect;
+export declare function pushEffect(register: Z80StackRegister16): InstructionEffect;
+export declare function popEffect(register: Z80StackRegister16): InstructionEffect;
+export declare function rotateShiftEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'rlc' | 'rrc' | 'rl' | 'rr' | 'sla' | 'sra' | 'sll' | 'sls' | 'srl';
+}>): InstructionEffect;
+export declare function bitEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'bit' | 'res' | 'set';
+}>): InstructionEffect;
+export declare function inEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'in';
+}>): InstructionEffect;
+export declare function outEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'out';
+}>): InstructionEffect;
+export declare function blockTransferEffect(): InstructionEffect;
+export declare function exEffect(instruction: Extract<Z80Instruction, {
+    mnemonic: 'ex';
+}>): InstructionEffect;
+export declare function accumulatorRotateEffect(mnemonic: 'rlca' | 'rrca' | 'rla' | 'rra'): InstructionEffect;