@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/frontend/ast.d.ts

@@ -1,376 +0,0 @@
-/**
- * Frontend AST contracts for AZM.
- *
- * This module intentionally defines types/interfaces only (no parsing/semantics).
- * Later PRs extend these contracts via coordinated changes.
- */
-export interface SourcePosition {
-    /** 1-based line number. */
-    line: number;
-    /** 1-based column number. */
-    column: number;
-    /** 0-based byte offset in the file. */
-    offset: number;
-}
-/**
- * Source span with inclusive start and end positions.
- */
-export interface SourceSpan {
-    /** User-facing file path (as provided on input). */
-    file: string;
-    start: SourcePosition;
-    end: SourcePosition;
-}
-/**
- * Base shape for all AST nodes.
- */
-export interface BaseNode {
-    kind: string;
-    span: SourceSpan;
-}
-/**
- * Parsed compilation unit, including the entry file and all loaded source files.
- */
-export interface ProgramNode extends BaseNode {
-    kind: 'Program';
-    entryFile: string;
-    files: SourceFileNode[];
-}
-/**
- * A single AZM source file.
- */
-export interface SourceFileNode extends BaseNode {
-    kind: 'SourceFile';
-    path: string;
-    items: SourceItemNode[];
-}
-interface AsmEquNode extends BaseNode {
-    kind: 'AsmEqu';
-    name: string;
-    exprText: string;
-}
-interface AsmOrgNode extends BaseNode {
-    kind: 'AsmOrg';
-    exprText: string;
-}
-interface AsmBinFromNode extends BaseNode {
-    kind: 'AsmBinFrom';
-    exprText: string;
-}
-interface AsmBinToNode extends BaseNode {
-    kind: 'AsmBinTo';
-    exprText: string;
-}
-interface AsmEndNode extends BaseNode {
-    kind: 'AsmEnd';
-}
-interface AsmAlignNode extends BaseNode {
-    kind: 'AsmAlign';
-    value: ImmExprNode;
-}
-type AsmRawDataValueNode = ImmExprNode | {
-    kind: 'AsmString';
-    value: string;
-};
-export type AsmRawDataNode = {
-    kind: 'AsmRawData';
-    span: SourceSpan;
-    name?: string;
-    directive: 'db' | 'dw' | 'cstr' | 'pstr' | 'istr';
-    values: AsmRawDataValueNode[];
-    valuesText?: string;
-} | {
-    kind: 'AsmRawData';
-    span: SourceSpan;
-    name?: string;
-    directive: 'ds';
-    values?: AsmRawDataValueNode[];
-    size?: ImmExprNode;
-    fill?: ImmExprNode;
-    valuesText?: string;
-};
-/**
- * Top-level items permitted in a source file.
- */
-export type SourceItemNode = AsmEquNode | AsmOrgNode | AsmBinFromNode | AsmBinToNode | AsmEndNode | AsmAlignNode | AsmRawDataNode | AsmLabelNode | AsmInstructionNode | EnumDeclNode | UnionDeclNode | TypeDeclNode | OpDeclNode;
-/**
- * Packed record layout declaration.
- */
-export interface TypeDeclNode extends BaseNode {
-    kind: 'TypeDecl';
-    name: string;
-    typeExpr: Extract<TypeExprNode, {
-        kind: 'RecordType';
-    }>;
-}
-/**
- * Union declaration.
- */
-export interface UnionDeclNode extends BaseNode {
-    kind: 'UnionDecl';
-    name: string;
-    fields: RecordFieldNode[];
-}
-/**
- * Enum declaration.
- */
-export interface EnumDeclNode extends BaseNode {
-    kind: 'EnumDecl';
-    name: string;
-    members: string[];
-}
-/**
- * `op` (macro-instruction) declaration.
- */
-export interface OpDeclNode extends BaseNode {
-    kind: 'OpDecl';
-    name: string;
-    params: OpParamNode[];
-    body: AsmBlockNode;
-}
-/**
- * `op` parameter with a matcher type.
- */
-export interface OpParamNode extends BaseNode {
-    kind: 'OpParam';
-    name: string;
-    matcher: OpMatcherNode;
-}
-/**
- * Operand matcher variants for `op` parameters.
- */
-export type OpMatcherNode = {
-    kind: 'MatcherReg8';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherReg16';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherIdx16';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherCc';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherImm8';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherImm16';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherEa';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherMem8';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherMem16';
-    span: SourceSpan;
-} | {
-    kind: 'MatcherFixed';
-    span: SourceSpan;
-    token: string;
-};
-/**
- * Instruction stream inside ASM source or an `op` body.
- */
-export interface AsmBlockNode extends BaseNode {
-    kind: 'AsmBlock';
-    items: AsmItemNode[];
-}
-/**
- * Items that can appear inside an instruction stream.
- */
-export type AsmItemNode = AsmInstructionNode | AsmLabelNode;
-/**
- * Label definition inside an `asm` stream.
- */
-export interface AsmLabelNode extends BaseNode {
-    kind: 'AsmLabel';
-    name: string;
-    /** True when the source label used the ASM80-style `@Name:` entry marker. */
-    isEntry?: boolean;
-}
-/**
- * Z80 instruction-like statement inside an `asm` stream.
- */
-export interface AsmInstructionNode extends BaseNode {
-    kind: 'AsmInstruction';
-    /** Canonical lower-case instruction mnemonic. */
-    head: string;
-    operands: AsmOperandNode[];
-    /** Original unparsed operand tail for ASM80 source preservation. */
-    operandText?: string;
-}
-/**
- * Operand variants in `asm` instructions.
- */
-export type AsmOperandNode = {
-    kind: 'Reg';
-    span: SourceSpan; /** Canonical upper-case register token. */
-    name: string;
-} | {
-    kind: 'Imm';
-    span: SourceSpan;
-    expr: ImmExprNode;
-} | {
-    kind: 'Ea';
-    span: SourceSpan;
-    expr: EaExprNode;
-} | {
-    kind: 'Mem';
-    span: SourceSpan;
-    expr: EaExprNode;
-} | {
-    kind: 'PortC';
-    span: SourceSpan;
-} | {
-    kind: 'PortImm8';
-    span: SourceSpan;
-    expr: ImmExprNode;
-};
-/**
- * Type expression variants.
- */
-export type TypeExprNode = {
-    kind: 'TypeName';
-    span: SourceSpan;
-    name: string;
-} | {
-    kind: 'ArrayType';
-    span: SourceSpan;
-    element: TypeExprNode;
-    length?: number;
-} | {
-    kind: 'RecordType';
-    span: SourceSpan;
-    fields: RecordFieldNode[];
-};
-/**
- * Field inside a record type.
- */
-export interface RecordFieldNode extends BaseNode {
-    kind: 'RecordField';
-    name: string;
-    typeExpr: TypeExprNode;
-}
-/**
- * Immediate-expression variants.
- */
-export type ImmExprNode = {
-    kind: 'ImmLiteral';
-    span: SourceSpan;
-    value: number;
-} | {
-    kind: 'ImmCurrentLocation';
-    span: SourceSpan;
-} | {
-    kind: 'ImmName';
-    span: SourceSpan;
-    name: string;
-} | {
-    kind: 'ImmSizeof';
-    span: SourceSpan;
-    typeExpr: TypeExprNode;
-} | {
-    kind: 'ImmOffset';
-    span: SourceSpan;
-    typeExpr: TypeExprNode;
-    path: OffsetPathNode;
-} | {
-    kind: 'ImmUnary';
-    span: SourceSpan;
-    op: '+' | '-' | '~';
-    expr: ImmExprNode;
-} | {
-    kind: 'ImmBinary';
-    span: SourceSpan;
-    op: '*' | '/' | '%' | '+' | '-' | '&' | '^' | '|' | '<<' | '>>';
-    left: ImmExprNode;
-    right: ImmExprNode;
-};
-/**
- * Effective-address expression variants.
- */
-export type EaExprNode = {
-    kind: 'EaName';
-    span: SourceSpan;
-    name: string;
-} | {
-    kind: 'EaImm';
-    span: SourceSpan;
-    expr: ImmExprNode;
-} | {
-    kind: 'EaLayoutCast';
-    span: SourceSpan;
-    typeExpr: TypeExprNode;
-    base: EaExprNode;
-} | {
-    kind: 'EaField';
-    span: SourceSpan;
-    base: EaExprNode;
-    field: string;
-} | {
-    kind: 'EaIndex';
-    span: SourceSpan;
-    base: EaExprNode;
-    index: EaIndexNode;
-} | {
-    kind: 'EaAdd';
-    span: SourceSpan;
-    base: EaExprNode;
-    offset: ImmExprNode;
-} | {
-    kind: 'EaSub';
-    span: SourceSpan;
-    base: EaExprNode;
-    offset: ImmExprNode;
-};
-/**
- * Index expression variants for effective addresses.
- */
-export type EaIndexNode = {
-    kind: 'IndexImm';
-    span: SourceSpan;
-    value: ImmExprNode;
-} | {
-    kind: 'IndexReg8';
-    span: SourceSpan; /** Canonical upper-case reg8 token. */
-    reg: string;
-} | {
-    kind: 'IndexReg16';
-    span: SourceSpan; /** Canonical upper-case reg16 token. */
-    reg: string;
-} | {
-    kind: 'IndexMemHL';
-    span: SourceSpan;
-} | {
-    kind: 'IndexMemIxIy';
-    span: SourceSpan;
-    /** Canonical upper-case base register token. */
-    base: 'IX' | 'IY';
-    /** Optional displacement imm expression (signed). */
-    disp?: ImmExprNode;
-} | {
-    kind: 'IndexEa';
-    span: SourceSpan;
-    expr: EaExprNode;
-};
-/**
- * Field path used by the `offset(Type, path)` built-in.
- */
-export interface OffsetPathNode extends BaseNode {
-    kind: 'OffsetPath';
-    base?: string;
-    steps: OffsetPathStepNode[];
-}
-export type OffsetPathStepNode = {
-    kind: 'OffsetField';
-    span: SourceSpan;
-    name: string;
-} | {
-    kind: 'OffsetIndex';
-    span: SourceSpan;
-    expr: ImmExprNode;
-};
-export {};

package/dist/legacy-root-azm/src/frontend/ast.js

@@ -1 +0,0 @@
-export {};

package/dist/legacy-root-azm/src/frontend/directiveAliases.d.ts

@@ -1,14 +0,0 @@
-type DirectiveAliasProfileName = 'azm';
-export type DirectiveAliasProfile = {
-    name?: string;
-    extends?: DirectiveAliasProfileName;
-    directiveAliases?: Record<string, string>;
-};
-export type DirectiveAliasPolicy = {
-    directiveAliases: Map<string, string>;
-};
-export declare function defaultDirectiveAliasProfileName(): DirectiveAliasProfileName;
-export declare function buildDirectiveAliasPolicy(profileName: DirectiveAliasProfileName, projectProfiles?: DirectiveAliasProfile[]): DirectiveAliasPolicy;
-export declare function readDirectiveAliasProfile(path: string): Promise<DirectiveAliasProfile>;
-export declare function resolveDirectiveAlias(head: string, policy: DirectiveAliasPolicy | undefined): string | undefined;
-export {};

package/dist/legacy-root-azm/src/frontend/directiveAliases.js

@@ -1,189 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { TOP_LEVEL_KEYWORDS } from './grammarData.js';
-const RESERVED_INSTRUCTION_HEADS = new Set([
-    'adc',
-    'add',
-    'and',
-    'bit',
-    'call',
-    'ccf',
-    'cp',
-    'cpd',
-    'cpdr',
-    'cpi',
-    'cpir',
-    'cpl',
-    'daa',
-    'dec',
-    'di',
-    'djnz',
-    'ei',
-    'ex',
-    'exx',
-    'halt',
-    'im',
-    'in',
-    'inc',
-    'ind',
-    'indr',
-    'ini',
-    'inir',
-    'jp',
-    'jr',
-    'ld',
-    'ldd',
-    'lddr',
-    'ldi',
-    'ldir',
-    'neg',
-    'nop',
-    'or',
-    'otdr',
-    'otir',
-    'out',
-    'outd',
-    'outi',
-    'pop',
-    'push',
-    'res',
-    'ret',
-    'reti',
-    'retn',
-    'rl',
-    'rla',
-    'rlc',
-    'rlca',
-    'rld',
-    'rr',
-    'rra',
-    'rrc',
-    'rrca',
-    'rrd',
-    'rst',
-    'sbc',
-    'scf',
-    'set',
-    'sla',
-    'sll',
-    'sra',
-    'srl',
-    'sub',
-    'xor',
-]);
-const CANONICAL_DIRECTIVES = new Set([
-    '.align',
-    '.binfrom',
-    '.binto',
-    '.cstr',
-    '.db',
-    '.ds',
-    '.dw',
-    '.end',
-    '.equ',
-    '.include',
-    '.istr',
-    '.org',
-    '.pstr',
-]);
-const BUILTIN_PROFILES = {
-    azm: {
-        name: 'azm',
-        directiveAliases: {
-            ALIGN: '.align',
-            BINFROM: '.binfrom',
-            BINTO: '.binto',
-            CSTR: '.cstr',
-            DB: '.db',
-            DS: '.ds',
-            DW: '.dw',
-            END: '.end',
-            EQU: '.equ',
-            INCLUDE: '.include',
-            ISTR: '.istr',
-            ORG: '.org',
-            PSTR: '.pstr',
-        },
-    },
-};
-export function defaultDirectiveAliasProfileName() {
-    return 'azm';
-}
-function normalizeAliasKey(key) {
-    const trimmed = key.trim();
-    if (!/^[.]?[A-Za-z][A-Za-z0-9_]*$/.test(trimmed))
-        return undefined;
-    return trimmed.replace(/^\./, '').toLowerCase();
-}
-function normalizeAliasTarget(value) {
-    const trimmed = value.trim().toLowerCase();
-    const dotted = trimmed.startsWith('.') ? trimmed : `.${trimmed}`;
-    if (!CANONICAL_DIRECTIVES.has(dotted))
-        return undefined;
-    return dotted;
-}
-function mergeProfile(profile, out, seen, source, baselineKeys = new Set()) {
-    if (profile.extends) {
-        if (seen.has(profile.extends)) {
-            throw new Error(`Directive alias profile cycle at "${profile.extends}"`);
-        }
-        seen.add(profile.extends);
-        mergeProfile(BUILTIN_PROFILES[profile.extends], out, seen, 'builtin', baselineKeys);
-        seen.delete(profile.extends);
-    }
-    for (const [rawKey, rawTarget] of Object.entries(profile.directiveAliases ?? {})) {
-        const key = normalizeAliasKey(rawKey);
-        if (!key)
-            throw new Error(`Invalid directive alias head "${rawKey}"`);
-        if (source === 'project') {
-            if (baselineKeys.has(key)) {
-                throw new Error(`Directive alias "${rawKey}" conflicts with the AZM baseline`);
-            }
-            if (RESERVED_INSTRUCTION_HEADS.has(key)) {
-                throw new Error(`Directive alias "${rawKey}" conflicts with a Z80 instruction`);
-            }
-            if (TOP_LEVEL_KEYWORDS.has(key)) {
-                throw new Error(`Directive alias "${rawKey}" conflicts with an AZM language keyword`);
-            }
-        }
-        const target = normalizeAliasTarget(rawTarget);
-        if (!target)
-            throw new Error(`Invalid directive alias target "${rawTarget}" for "${rawKey}"`);
-        out.set(key, target);
-    }
-}
-export function buildDirectiveAliasPolicy(profileName, projectProfiles = []) {
-    const directiveAliases = new Map();
-    mergeProfile(BUILTIN_PROFILES[profileName], directiveAliases, new Set([profileName]), 'builtin');
-    const baselineKeys = new Set(directiveAliases.keys());
-    for (const profile of projectProfiles) {
-        mergeProfile(profile, directiveAliases, new Set(), 'project', baselineKeys);
-    }
-    return { directiveAliases };
-}
-export async function readDirectiveAliasProfile(path) {
-    const text = await readFile(path, 'utf8');
-    const parsed = JSON.parse(text);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`Directive alias file "${path}" must contain a JSON object`);
-    }
-    const profile = parsed;
-    if (profile.extends !== undefined && profile.extends !== 'azm') {
-        throw new Error(`Unsupported directive alias base "${String(profile.extends)}" in "${path}"`);
-    }
-    if (profile.directiveAliases !== undefined &&
-        (!profile.directiveAliases ||
-            typeof profile.directiveAliases !== 'object' ||
-            Array.isArray(profile.directiveAliases))) {
-        throw new Error(`Directive alias file "${path}" has invalid "directiveAliases"`);
-    }
-    return profile;
-}
-export function resolveDirectiveAlias(head, policy) {
-    const normalized = normalizeAliasKey(head);
-    if (!normalized)
-        return undefined;
-    const dotted = `.${normalized}`;
-    if (head.trim().startsWith('.') && CANONICAL_DIRECTIVES.has(dotted))
-        return dotted;
-    return policy?.directiveAliases.get(normalized);
-}

package/dist/legacy-root-azm/src/frontend/grammarData.d.ts

@@ -1,14 +0,0 @@
-export declare const TOP_LEVEL_KEYWORDS: Set<string>;
-export declare const ALL_REGISTER_NAMES: Set<string>;
-export declare const INDEX_REG8_NAMES: Set<string>;
-export declare const INDEX_REG16_NAMES: Set<string>;
-export declare const INDEX_MEM_BASE_REGISTERS: Set<string>;
-export declare const IMM_BINARY_OPERATOR_PRECEDENCE: Map<string, number>;
-export declare const IMM_BINARY_OPERATORS: Set<string>;
-export declare const IMM_UNARY_OPERATOR_SET: Set<string>;
-export declare const IMM_MULTI_CHAR_OPERATORS: Set<string>;
-export declare const CHAR_ESCAPE_VALUES: Map<string, number>;
-declare const MATCHER_TYPE_LIST: readonly ["reg8", "reg16", "idx16", "cc", "imm8", "imm16", "ea", "mem8", "mem16"];
-export declare const MATCHER_TYPES: Set<string>;
-export declare const MATCHER_KIND_BY_TYPE: Readonly<Record<(typeof MATCHER_TYPE_LIST)[number], 'MatcherReg8' | 'MatcherReg16' | 'MatcherIdx16' | 'MatcherCc' | 'MatcherImm8' | 'MatcherImm16' | 'MatcherEa' | 'MatcherMem8' | 'MatcherMem16'>>;
-export {};

package/dist/legacy-root-azm/src/frontend/grammarData.js

@@ -1,65 +0,0 @@
-const TOP_LEVEL_KEYWORD_LIST = ['enum', 'type', 'union', 'op'];
-export const TOP_LEVEL_KEYWORDS = new Set(TOP_LEVEL_KEYWORD_LIST);
-const REGISTERS_8 = ['A', 'B', 'C', 'D', 'E', 'H', 'L'];
-const REGISTERS_8_EXTENDED = ['IXH', 'IXL', 'IYH', 'IYL', 'I', 'R'];
-const REGISTERS_16_GENERAL = ['HL', 'DE', 'BC', 'SP', 'IX', 'IY'];
-const REGISTERS_16_SPECIAL = ['AF'];
-const REGISTERS_16 = [...REGISTERS_16_GENERAL, ...REGISTERS_16_SPECIAL];
-const REGISTERS_16_SHADOW = ["AF'"];
-const ALL_REGISTER_NAME_LIST = [
-    ...REGISTERS_8,
-    ...REGISTERS_8_EXTENDED,
-    ...REGISTERS_16,
-    ...REGISTERS_16_SHADOW,
-];
-export const ALL_REGISTER_NAMES = new Set(ALL_REGISTER_NAME_LIST);
-export const INDEX_REG8_NAMES = new Set(REGISTERS_8);
-const INDEX_REG16_LIST = ['HL', 'DE', 'BC'];
-export const INDEX_REG16_NAMES = new Set(INDEX_REG16_LIST);
-const INDEX_MEM_BASE_REGISTER_LIST = ['IX', 'IY'];
-export const INDEX_MEM_BASE_REGISTERS = new Set(INDEX_MEM_BASE_REGISTER_LIST);
-const IMM_OPERATOR_PRECEDENCE = [
-    { level: 7, ops: ['*', '/', '%'] },
-    { level: 6, ops: ['+', '-'] },
-    { level: 5, ops: ['<<', '>>'] },
-    { level: 4, ops: ['&'] },
-    { level: 3, ops: ['^'] },
-    { level: 2, ops: ['|'] },
-];
-export const IMM_BINARY_OPERATOR_PRECEDENCE = new Map(IMM_OPERATOR_PRECEDENCE.flatMap(({ level, ops }) => ops.map((op) => [op, level])));
-export const IMM_BINARY_OPERATORS = new Set(IMM_BINARY_OPERATOR_PRECEDENCE.keys());
-const IMM_UNARY_OPERATORS = ['+', '-', '~'];
-export const IMM_UNARY_OPERATOR_SET = new Set(IMM_UNARY_OPERATORS);
-export const IMM_MULTI_CHAR_OPERATORS = new Set(['<<', '>>']);
-export const CHAR_ESCAPE_VALUES = new Map([
-    ['n', 10],
-    ['r', 13],
-    ['t', 9],
-    ['0', 0],
-    ['\\', 92],
-    ["'", 39],
-    ['"', 34],
-]);
-const MATCHER_TYPE_LIST = [
-    'reg8',
-    'reg16',
-    'idx16',
-    'cc',
-    'imm8',
-    'imm16',
-    'ea',
-    'mem8',
-    'mem16',
-];
-export const MATCHER_TYPES = new Set(MATCHER_TYPE_LIST);
-export const MATCHER_KIND_BY_TYPE = {
-    reg8: 'MatcherReg8',
-    reg16: 'MatcherReg16',
-    idx16: 'MatcherIdx16',
-    cc: 'MatcherCc',
-    imm8: 'MatcherImm8',
-    imm16: 'MatcherImm16',
-    ea: 'MatcherEa',
-    mem8: 'MatcherMem8',
-    mem16: 'MatcherMem16',
-};

package/dist/legacy-root-azm/src/frontend/immExprUtils.d.ts

@@ -1,2 +0,0 @@
-import type { ImmExprNode } from './ast.js';
-export declare function containsCurrentLocation(expr: ImmExprNode): boolean;

package/dist/legacy-root-azm/src/frontend/immExprUtils.js

@@ -1,12 +0,0 @@
-export function containsCurrentLocation(expr) {
-    switch (expr.kind) {
-        case 'ImmCurrentLocation':
-            return true;
-        case 'ImmUnary':
-            return containsCurrentLocation(expr.expr);
-        case 'ImmBinary':
-            return containsCurrentLocation(expr.left) || containsCurrentLocation(expr.right);
-        default:
-            return false;
-    }
-}

package/dist/legacy-root-azm/src/frontend/parseAsmFlatDirectiveLine.d.ts

@@ -1,17 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { SourceItemNode, SourceSpan } from './ast.js';
-import type { DirectiveAliasPolicy } from './directiveAliases.js';
-import type { ParseItemContext } from './parseSourceItemDispatch.js';
-/** Parses one source-file line of ASM flat assembler directives. */
-export declare function parseAsmFlatDirectiveLine(args: {
-    rest: string;
-    stmtSpan: SourceSpan;
-    filePath: string;
-    lineNo: number;
-    diagnostics: Diagnostic[];
-    ctx: Extract<ParseItemContext, {
-        scope: 'source';
-    }>;
-    aliasPolicy?: DirectiveAliasPolicy;
-    stringEquates: Map<string, string>;
-}): SourceItemNode[] | undefined;