@jhlagado/azm 0.2.6 → 0.2.8

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/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;

package/dist/src/z80/effect-groups.js

@@ -0,0 +1,265 @@
+import { BIT_FLAG_WRITES, FLAG_WRITES, INC_DEC_FLAG_WRITES, ROTATE_SHIFT_FLAG_WRITES, STACK_POINTER_UNITS, baseEffect, concatUnique, operandReads, operandWrites, reg16Units, reg8Units, regHalfUnits, unknownEffect, } from './effect-units.js';
+export function callControl(target, conditional) {
+    return target === undefined
+        ? { kind: 'call', conditional }
+        : { kind: 'call', target, conditional };
+}
+export function rstControl(vector) {
+    return vector === undefined ? { kind: 'rst' } : { kind: 'rst', vector };
+}
+export function jumpControl(target, conditional) {
+    return target === undefined
+        ? { kind: 'jump', conditional }
+        : { kind: 'jump', target, conditional };
+}
+export function controlEffect(control, reads = []) {
+    return {
+        ...baseEffect(),
+        reads,
+        control,
+    };
+}
+export function stackControlEffect(control, reads = []) {
+    return {
+        ...controlEffect(control, reads),
+        writes: STACK_POINTER_UNITS,
+        stack: { kind: 'unknown' },
+    };
+}
+export function ldEffect(instruction) {
+    const srcReads = operandReads(instruction.source);
+    if (srcReads === undefined)
+        return unknownEffect();
+    const dstWrites = operandWrites(instruction.target);
+    if (instruction.target.kind === 'reg8' || instruction.target.kind === 'reg16') {
+        if (dstWrites === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+            writes: dstWrites,
+        };
+    }
+    if (instruction.target.kind === 'reg-index16' ||
+        instruction.target.kind === 'reg-half-index') {
+        if (dstWrites === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+            writes: dstWrites,
+        };
+    }
+    if (instruction.target.kind === 'reg-indirect' || instruction.target.kind === 'indexed') {
+        const dstReads = operandReads(instruction.target);
+        if (dstReads === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: concatUnique(dstReads, srcReads),
+        };
+    }
+    if (instruction.target.kind === 'mem-abs') {
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+        };
+    }
+    return unknownEffect();
+}
+export function incDecEffect(instruction) {
+    const operand = instruction.operand;
+    if (operand.kind === 'reg8') {
+        const units = reg8Units(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
+        };
+    }
+    if (operand.kind === 'reg16') {
+        const units = reg16Units(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: units,
+        };
+    }
+    if (operand.kind === 'reg-half-index') {
+        const units = regHalfUnits(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
+        };
+    }
+    const reads = operandReads(operand);
+    if (reads === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads,
+        writes: INC_DEC_FLAG_WRITES,
+    };
+}
+export function aluEffect(instruction) {
+    if (instruction.mnemonic === 'add' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        return wideAluEffect(instruction, []);
+    }
+    if (instruction.mnemonic === 'adc' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        return wideAluEffect(instruction, ['carry']);
+    }
+    if (instruction.mnemonic === 'sbc' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        return wideAluEffect(instruction, ['carry']);
+    }
+    if (!('source' in instruction))
+        return unknownEffect();
+    const source = instruction.source;
+    const sourceReads = aluSourceReads(source);
+    const xorSelfZero = instruction.mnemonic === 'xor' &&
+        source.kind === 'reg8' &&
+        source.register === 'a';
+    const reads = xorSelfZero ? [] : concatUnique(['A'], sourceReads);
+    const carryReads = instruction.mnemonic === 'adc' || instruction.mnemonic === 'sbc' ? ['carry'] : [];
+    if (instruction.mnemonic === 'cp') {
+        return {
+            ...baseEffect(),
+            reads: concatUnique(reads, carryReads),
+            writes: FLAG_WRITES,
+        };
+    }
+    return {
+        ...baseEffect(),
+        reads: concatUnique(reads, carryReads),
+        writes: concatUnique(['A'], FLAG_WRITES),
+    };
+}
+export function pushEffect(register) {
+    const units = reg16Units(register);
+    return {
+        ...baseEffect(),
+        reads: units,
+        writes: STACK_POINTER_UNITS,
+        stack: { kind: 'push', units },
+    };
+}
+export function popEffect(register) {
+    const units = reg16Units(register);
+    return {
+        ...baseEffect(),
+        writes: concatUnique(units, STACK_POINTER_UNITS),
+        stack: { kind: 'pop', units },
+    };
+}
+export function rotateShiftEffect(instruction) {
+    const reads = operandReads(instruction.operand);
+    const writes = operandWrites(instruction.operand);
+    if (reads === undefined || writes === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads,
+        writes: concatUnique(writes, ROTATE_SHIFT_FLAG_WRITES),
+    };
+}
+export function bitEffect(instruction) {
+    const reads = operandReads(instruction.operand);
+    if (reads === undefined)
+        return unknownEffect();
+    if (instruction.mnemonic === 'bit') {
+        return {
+            ...baseEffect(),
+            reads,
+            writes: BIT_FLAG_WRITES,
+        };
+    }
+    const writes = operandWrites(instruction.operand);
+    if (writes === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads,
+        writes,
+    };
+}
+export function inEffect(instruction) {
+    const targetWrites = instruction.target?.kind === 'reg8' ? reg8Units(instruction.target.register) : undefined;
+    if (instruction.port.kind === 'imm') {
+        return {
+            ...baseEffect(),
+            reads: ['A'],
+            writes: targetWrites ?? [],
+        };
+    }
+    return {
+        ...baseEffect(),
+        reads: ['C'],
+        writes: concatUnique(targetWrites ?? [], BIT_FLAG_WRITES),
+    };
+}
+export function outEffect(instruction) {
+    const valueReads = instruction.source.kind === 'reg8' ? reg8Units(instruction.source.register) : [];
+    if (instruction.port.kind === 'c') {
+        return {
+            ...baseEffect(),
+            reads: concatUnique(['C'], valueReads),
+        };
+    }
+    return {
+        ...baseEffect(),
+        reads: valueReads,
+    };
+}
+export function blockTransferEffect() {
+    return {
+        ...baseEffect(),
+        reads: ['H', 'L', 'D', 'E', 'B', 'C'],
+        writes: ['H', 'L', 'D', 'E', 'B', 'C', 'halfCarry', 'parity'],
+    };
+}
+export function exEffect(instruction) {
+    if (instruction.form === 'de-hl') {
+        return {
+            ...baseEffect(),
+            reads: ['D', 'E', 'H', 'L'],
+            writes: ['D', 'E', 'H', 'L'],
+        };
+    }
+    return unknownEffect();
+}
+export function accumulatorRotateEffect(mnemonic) {
+    const reads = mnemonic === 'rla' || mnemonic === 'rra' ? ['A', 'carry'] : ['A'];
+    return {
+        ...baseEffect(),
+        reads,
+        writes: ['A', 'carry', 'halfCarry'],
+    };
+}
+function wideAluEffect(instruction, extraReads) {
+    const targetReads = operandReads(instruction.target);
+    const sourceReads = operandReads(instruction.source);
+    if (targetReads === undefined || sourceReads === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads: concatUnique(targetReads, sourceReads, extraReads),
+        writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
+    };
+}
+function aluSourceReads(source) {
+    if (source.kind === 'reg8')
+        return reg8Units(source.register);
+    if (source.kind === 'reg16' || source.kind === 'reg-index16')
+        return reg16Units(source.register);
+    if (source.kind === 'reg-half-index')
+        return regHalfUnits(source.register);
+    if (source.kind === 'reg-indirect' || source.kind === 'indexed')
+        return operandReads(source) ?? [];
+    return [];
+}

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

@@ -0,0 +1,18 @@
+import type { Expression } from '../model/expression.js';
+import type { InstructionEffect, RegisterContractsUnit } from '../register-contracts/types.js';
+import type { Z80Condition, Z80Operand, Z80RelativeCondition } from './instruction.js';
+export declare const FLAG_WRITES: RegisterContractsUnit[];
+export declare const INC_DEC_FLAG_WRITES: RegisterContractsUnit[];
+export declare const ROTATE_SHIFT_FLAG_WRITES: RegisterContractsUnit[];
+export declare const BIT_FLAG_WRITES: RegisterContractsUnit[];
+export declare const STACK_POINTER_UNITS: RegisterContractsUnit[];
+export declare function baseEffect(): InstructionEffect;
+export declare function unknownEffect(): InstructionEffect;
+export declare function concatUnique(...groups: RegisterContractsUnit[][]): RegisterContractsUnit[];
+export declare function reg8Units(raw: string): RegisterContractsUnit[];
+export declare function reg16Units(raw: string): RegisterContractsUnit[];
+export declare function regHalfUnits(raw: string): RegisterContractsUnit[];
+export declare function expressionSymbol(expression: Expression): string | undefined;
+export declare function operandReads(op: Z80Operand): RegisterContractsUnit[] | undefined;
+export declare function operandWrites(op: Z80Operand): RegisterContractsUnit[] | undefined;
+export declare function conditionFlagRead(condition: Z80Condition | Z80RelativeCondition): RegisterContractsUnit[];