@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/semantics/layout-evaluation.js

@@ -0,0 +1,202 @@
+import { diagnostic } from './diagnostics.js';
+import { formatOffsetPath, formatTypeExpr, registerIndexName, scalarSize, } from './layout-format.js';
+import { arrayElementOffset, fieldPathOffset } from './layout-path.js';
+export function evaluateSizeof(typeExpr, layouts, span, diagnostics) {
+    if (!layouts) {
+        diagnostics.push(diagnostic(span, `unknown type: ${formatTypeExpr(typeExpr)}`));
+        return undefined;
+    }
+    return typeExprSize(typeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+}
+export function evaluateOffset(typeExpr, path, layouts, span, diagnostics) {
+    if (!layouts) {
+        diagnostics.push(diagnostic(span, `unknown type: ${formatTypeExpr(typeExpr)}`));
+        return undefined;
+    }
+    const diagnosticCount = diagnostics.length;
+    const offset = offsetPath(typeExpr, path, layouts, span, diagnostics);
+    if (offset !== undefined) {
+        return offset;
+    }
+    if (diagnostics.length === diagnosticCount) {
+        diagnostics.push(diagnostic(span, `unknown field "${formatOffsetPath(path)}" in type ${formatTypeExpr(typeExpr)}`));
+    }
+    return undefined;
+}
+export function evaluateLayoutCast(expression, labels, equates, span, diagnostics, options, evaluateExpression) {
+    const base = evaluateExpression(expression.base, labels, equates, span, diagnostics, options);
+    if (base === undefined) {
+        return undefined;
+    }
+    if (!options.layouts) {
+        diagnostics.push(diagnostic(span, `unknown type: ${formatTypeExpr(expression.typeExpr)}`));
+        return undefined;
+    }
+    const offset = layoutCastOffset(expression.typeExpr, expression.path, labels, equates, options.layouts, span, diagnostics, options, evaluateExpression);
+    return offset === undefined ? undefined : base + offset;
+}
+export function validateLayouts(layouts, diagnostics) {
+    for (const [name, layout] of layouts) {
+        layoutSize(name, layout, layouts, layout.span, diagnostics, new Set([name]));
+    }
+}
+export function typeExprSize(typeExpr, layouts, span, diagnostics, visiting) {
+    const resolvedTypeExpr = resolveLayoutAlias(typeExpr, layouts, span, diagnostics, visiting);
+    if (!resolvedTypeExpr) {
+        return undefined;
+    }
+    if (resolvedTypeExpr !== typeExpr) {
+        return typeExprSize(resolvedTypeExpr, layouts, span, diagnostics, visiting);
+    }
+    const scalar = scalarSize(typeExpr.name);
+    const baseSize = scalar ??
+        (() => {
+            const layout = layouts.get(typeExpr.name);
+            if (!layout) {
+                diagnostics.push(diagnostic(span, `unknown type: ${typeExpr.name}`));
+                return undefined;
+            }
+            return layoutSize(typeExpr.name, layout, layouts, span, diagnostics, visiting);
+        })();
+    if (baseSize === undefined) {
+        return undefined;
+    }
+    return typeExpr.length === undefined ? baseSize : baseSize * typeExpr.length;
+}
+function layoutSize(typeName, layout, layouts, span, diagnostics, visiting) {
+    if (layout.kind === 'alias') {
+        return typeExprSize(layout.typeExpr, layouts, span, diagnostics, visiting);
+    }
+    const fieldSizes = [];
+    for (const field of layout.fields) {
+        const size = fieldSize(field, layouts, span, diagnostics, visiting);
+        if (size === undefined) {
+            return undefined;
+        }
+        fieldSizes.push(size);
+    }
+    return layout.kind === 'union'
+        ? fieldSizes.reduce((largest, size) => Math.max(largest, size), 0)
+        : fieldSizes.reduce((sum, size) => sum + size, 0);
+}
+function fieldSize(field, layouts, span, diagnostics, visiting) {
+    if (field.typeExpr === undefined) {
+        return field.size;
+    }
+    if (visiting.has(field.typeExpr.name)) {
+        diagnostics.push(diagnostic(span, visiting.size === 1
+            ? `Self-referential field type "${field.typeExpr.name}" has no finite size; use .addr for a pointer field.`
+            : `recursive type: ${field.typeExpr.name}`));
+        return undefined;
+    }
+    return typeExprSize(field.typeExpr, layouts, span, diagnostics, new Set([...visiting, field.typeExpr.name]));
+}
+function offsetPath(typeExpr, parts, layouts, span, diagnostics) {
+    const resolvedTypeExpr = resolveLayoutAlias(typeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+    if (!resolvedTypeExpr) {
+        return undefined;
+    }
+    if (resolvedTypeExpr !== typeExpr) {
+        return offsetPath(resolvedTypeExpr, parts, layouts, span, diagnostics);
+    }
+    const [head, ...tail] = parts;
+    if (head === undefined) {
+        return undefined;
+    }
+    if (head.kind === 'index') {
+        return staticArrayOffset(typeExpr, head.index, tail, layouts, span, diagnostics);
+    }
+    return fieldPathOffset({
+        typeExpr,
+        head,
+        tail,
+        layouts,
+        span,
+        diagnostics,
+        fieldSize: (field, ownerTypeExpr) => fieldSize(field, layouts, span, diagnostics, new Set([ownerTypeExpr.name])),
+        nestedOffset: (fieldTypeExpr, nestedTail) => offsetPath(fieldTypeExpr, nestedTail, layouts, span, diagnostics),
+    });
+}
+function layoutCastOffset(typeExpr, parts, labels, equates, layouts, span, diagnostics, options, evaluateExpression) {
+    const resolvedTypeExpr = resolveLayoutAlias(typeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+    if (!resolvedTypeExpr) {
+        return undefined;
+    }
+    if (resolvedTypeExpr !== typeExpr) {
+        return layoutCastOffset(resolvedTypeExpr, parts, labels, equates, layouts, span, diagnostics, options, evaluateExpression);
+    }
+    const [head, ...tail] = parts;
+    if (head === undefined) {
+        return 0;
+    }
+    if (head.kind === 'index') {
+        const index = evaluateLayoutCastIndex(head.expression, typeExpr, labels, equates, layouts, span, diagnostics, options, evaluateExpression);
+        if (index === undefined) {
+            return undefined;
+        }
+        return dynamicArrayOffset(typeExpr, index, tail, labels, equates, layouts, span, diagnostics, options, evaluateExpression);
+    }
+    return fieldPathOffset({
+        typeExpr,
+        head,
+        tail,
+        layouts,
+        span,
+        diagnostics,
+        fieldSize: (field, ownerTypeExpr) => fieldSize(field, layouts, span, diagnostics, new Set([ownerTypeExpr.name])),
+        nestedOffset: (fieldTypeExpr, nestedTail) => layoutCastOffset(fieldTypeExpr, nestedTail, labels, equates, layouts, span, diagnostics, options, evaluateExpression),
+    });
+}
+function staticArrayOffset(typeExpr, index, tail, layouts, span, diagnostics) {
+    if (typeExpr.length === undefined) {
+        return undefined;
+    }
+    if (index >= typeExpr.length) {
+        diagnostics.push(diagnostic(span, `array index ${index} out of range for ${formatTypeExpr(typeExpr)}`));
+        return undefined;
+    }
+    return arrayElementOffset(typeExpr, index, tail, (elementTypeExpr) => typeExprSize(elementTypeExpr, layouts, span, diagnostics, new Set([typeExpr.name])), (elementTypeExpr, nestedTail) => offsetPath(elementTypeExpr, nestedTail, layouts, span, diagnostics));
+}
+function dynamicArrayOffset(typeExpr, index, tail, labels, equates, layouts, span, diagnostics, options, evaluateExpression) {
+    return arrayElementOffset(typeExpr, index, tail, (elementTypeExpr) => typeExprSize(elementTypeExpr, layouts, span, diagnostics, new Set([typeExpr.name])), (elementTypeExpr, nestedTail) => layoutCastOffset(elementTypeExpr, nestedTail, labels, equates, layouts, span, diagnostics, options, evaluateExpression));
+}
+function evaluateLayoutCastIndex(expression, typeExpr, labels, equates, layouts, span, diagnostics, options, evaluateExpression) {
+    if (typeExpr.length === undefined) {
+        return undefined;
+    }
+    const registerName = registerIndexName(expression);
+    if (registerName) {
+        diagnostics.push(diagnostic(span, `runtime register index "${registerName}" is not supported in layout casts`));
+        return undefined;
+    }
+    const index = evaluateExpression(expression, labels, equates, span, diagnostics, {
+        ...options,
+        layouts,
+    });
+    if (index === undefined) {
+        return undefined;
+    }
+    if (index < 0 || index >= typeExpr.length) {
+        diagnostics.push(diagnostic(span, `array index ${index} out of range for ${formatTypeExpr(typeExpr)}`));
+        return undefined;
+    }
+    return index;
+}
+function resolveLayoutAlias(typeExpr, layouts, span, diagnostics, visiting) {
+    const layout = layouts.get(typeExpr.name);
+    if (!layout || layout.kind !== 'alias') {
+        return typeExpr;
+    }
+    if (visiting.has(layout.typeExpr.name)) {
+        diagnostics.push(diagnostic(span, `recursive type: ${typeExpr.name}`));
+        return undefined;
+    }
+    const target = resolveLayoutAlias(layout.typeExpr, layouts, span, diagnostics, new Set([...visiting, layout.typeExpr.name]));
+    if (!target) {
+        return undefined;
+    }
+    const length = typeExpr.length === undefined
+        ? target.length
+        : (target.length ?? 1) * typeExpr.length;
+    return length === undefined ? { name: target.name } : { name: target.name, length };
+}

package/dist/src/semantics/layout-format.d.ts

@@ -0,0 +1,5 @@
+import type { Expression, OffsetPathPart, TypeExpr } from '../model/expression.js';
+export declare function scalarSize(typeName: string): number | undefined;
+export declare function formatTypeExpr(typeExpr: TypeExpr): string;
+export declare function formatOffsetPath(path: readonly OffsetPathPart[]): string;
+export declare function registerIndexName(expression: Expression): string | undefined;

package/dist/src/semantics/layout-format.js

@@ -0,0 +1,31 @@
+export function scalarSize(typeName) {
+    switch (typeName.toLowerCase()) {
+        case 'byte':
+            return 1;
+        case 'word':
+        case 'addr':
+            return 2;
+        default:
+            return undefined;
+    }
+}
+export function formatTypeExpr(typeExpr) {
+    return typeExpr.length === undefined ? typeExpr.name : `${typeExpr.name}[${typeExpr.length}]`;
+}
+export function formatOffsetPath(path) {
+    return path.map((part) => (part.kind === 'field' ? part.name : `[${part.index}]`)).join('.');
+}
+export function registerIndexName(expression) {
+    switch (expression.kind) {
+        case 'symbol':
+            return /^(a|b|c|d|e|h|l|af|bc|de|hl|ix|iy|sp|i|r|ixh|ixl|iyh|iyl)$/i.test(expression.name)
+                ? expression.name.toUpperCase()
+                : undefined;
+        case 'unary':
+            return registerIndexName(expression.expression);
+        case 'binary':
+            return registerIndexName(expression.left) ?? registerIndexName(expression.right);
+        default:
+            return undefined;
+    }
+}

package/dist/src/semantics/layout-path.d.ts

@@ -0,0 +1,24 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { LayoutCastPathPart, OffsetPathPart, TypeExpr } from '../model/expression.js';
+import type { LayoutField } from '../model/source-item.js';
+import type { SourceSpan } from '../source/source-span.js';
+import type { LayoutRecord } from './layout-evaluation.js';
+type PathPart = OffsetPathPart | LayoutCastPathPart;
+type FieldPathHead = Extract<PathPart, {
+    readonly kind: 'field';
+}>;
+type TypeSize = (typeExpr: TypeExpr) => number | undefined;
+type FieldSize = (field: LayoutField, ownerTypeExpr: TypeExpr) => number | undefined;
+type FieldOffsetOptions<TPart extends PathPart> = {
+    readonly typeExpr: TypeExpr;
+    readonly head: FieldPathHead;
+    readonly tail: readonly TPart[];
+    readonly layouts: ReadonlyMap<string, LayoutRecord>;
+    readonly span: SourceSpan;
+    readonly diagnostics: Diagnostic[];
+    readonly fieldSize: FieldSize;
+    readonly nestedOffset: (typeExpr: TypeExpr, tail: readonly TPart[]) => number | undefined;
+};
+export declare function arrayElementOffset<TPart extends PathPart>(typeExpr: TypeExpr, index: number, tail: readonly TPart[], typeSize: TypeSize, nestedOffset: (typeExpr: TypeExpr, tail: readonly TPart[]) => number | undefined): number | undefined;
+export declare function fieldPathOffset<TPart extends PathPart>({ typeExpr, head, tail, layouts, span, diagnostics, fieldSize, nestedOffset, }: FieldOffsetOptions<TPart>): number | undefined;
+export {};

package/dist/src/semantics/layout-path.js

@@ -0,0 +1,58 @@
+import { diagnostic } from './diagnostics.js';
+export function arrayElementOffset(typeExpr, index, tail, typeSize, nestedOffset) {
+    const elementTypeExpr = { name: typeExpr.name };
+    const stride = typeSize(elementTypeExpr);
+    if (stride === undefined) {
+        return undefined;
+    }
+    if (tail.length === 0) {
+        return index * stride;
+    }
+    const nested = nestedOffset(elementTypeExpr, tail);
+    return nested === undefined ? undefined : index * stride + nested;
+}
+export function fieldPathOffset({ typeExpr, head, tail, layouts, span, diagnostics, fieldSize, nestedOffset, }) {
+    if (typeExpr.length !== undefined) {
+        return undefined;
+    }
+    const layout = layouts.get(typeExpr.name);
+    if (!layout) {
+        diagnostics.push(diagnostic(span, `unknown type: ${typeExpr.name}`));
+        return undefined;
+    }
+    if (layout.kind === 'alias') {
+        return nestedOffset(layout.typeExpr, [head, ...tail]);
+    }
+    return findFieldOffset(typeExpr, layout, head, tail, fieldSize, nestedOffset);
+}
+function findFieldOffset(typeExpr, layout, head, tail, fieldSize, nestedOffset) {
+    let currentOffset = 0;
+    for (const field of layout.fields) {
+        const foundOffset = field.name === head.name
+            ? selectedFieldOffset(typeExpr, layout.kind, field, currentOffset, tail, fieldSize, nestedOffset)
+            : undefined;
+        if (foundOffset !== undefined) {
+            return foundOffset;
+        }
+        const size = fieldSize(field, typeExpr);
+        if (size === undefined) {
+            return undefined;
+        }
+        currentOffset += size;
+    }
+    return undefined;
+}
+function selectedFieldOffset(typeExpr, layoutKind, field, currentOffset, tail, fieldSize, nestedOffset) {
+    const fieldOffset = layoutKind === 'union' ? 0 : currentOffset;
+    if (field.typeExpr !== undefined && fieldSize(field, typeExpr) === undefined) {
+        return undefined;
+    }
+    if (tail.length === 0) {
+        return fieldOffset;
+    }
+    if (field.typeExpr === undefined) {
+        return undefined;
+    }
+    const nested = nestedOffset(field.typeExpr, tail);
+    return nested === undefined ? undefined : fieldOffset + nested;
+}

package/dist/src/semantics/unary-operators.d.ts

@@ -0,0 +1,2 @@
+import type { UnaryOperator } from './constant-operator-types.js';
+export declare function applyUnaryOperator(operator: UnaryOperator, value: number): number;

package/dist/src/semantics/unary-operators.js

@@ -0,0 +1,8 @@
+const unaryOperators = {
+    '+': (value) => value,
+    '-': (value) => -value,
+    '~': (value) => ~value,
+};
+export function applyUnaryOperator(operator, value) {
+    return unaryOperators[operator](value);
+}

package/dist/src/source/line-comment-scanner.d.ts

@@ -0,0 +1 @@
+export declare function findLineCommentStart(text: string): number | undefined;

package/dist/src/source/line-comment-scanner.js

@@ -0,0 +1,51 @@
+export function findLineCommentStart(text) {
+    let state = {};
+    for (let index = 0; index < text.length; index += 1) {
+        const result = scanCommentChar(text, index, state);
+        if (result.kind === 'comment') {
+            return index;
+        }
+        state = result.state;
+    }
+    return undefined;
+}
+function scannerState(quote, escaped = false) {
+    return {
+        ...(quote === undefined ? {} : { quote }),
+        ...(escaped ? { escaped } : {}),
+    };
+}
+function scanCommentChar(text, index, state) {
+    const char = text[index];
+    if (state.escaped === true) {
+        return { kind: 'continue', state: scannerState(state.quote) };
+    }
+    if (startsEscape(char, state)) {
+        return { kind: 'continue', state: scannerState(state.quote, true) };
+    }
+    if (startsOrEndsQuote(text, index, state)) {
+        return {
+            kind: 'continue',
+            state: scannerState(state.quote === char ? undefined : (state.quote ?? char)),
+        };
+    }
+    if (char === ';' && state.quote === undefined) {
+        return { kind: 'comment' };
+    }
+    return { kind: 'continue', state };
+}
+function startsEscape(char, state) {
+    return char === '\\' && state.quote !== undefined;
+}
+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] ?? ''));
+}

package/dist/src/source/strip-line-comment.js

@@ -1,53 +1,17 @@
+import { findLineCommentStart } from './line-comment-scanner.js';
 /**
  * Remove an ASM80-style end-of-line comment (`;`), respecting quoted strings.
  */
 export function stripLineComment(text) {
-    let quote;
-    let escaped = false;
-    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 === "'") &&
-            !(char === "'" && quote === undefined && /[A-Za-z0-9_]/.test(text[index - 1] ?? ''))) {
-            quote = quote === char ? undefined : (quote ?? char);
-            continue;
-        }
-        if (char === ';' && !quote) {
-            return text.slice(0, index);
-        }
-    }
-    return text;
+    const commentStart = findLineCommentStart(text);
+    return commentStart === undefined ? text : text.slice(0, commentStart);
 }
 /** Trailing `;` comment text, or undefined when absent or whitespace-only. */
 export function extractLineComment(text) {
-    let quote;
-    let escaped = false;
-    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 === "'") &&
-            !(char === "'" && quote === undefined && /[A-Za-z0-9_]/.test(text[index - 1] ?? ''))) {
-            quote = quote === char ? undefined : (quote ?? char);
-            continue;
-        }
-        if (char === ';' && !quote) {
-            const comment = text.slice(index + 1).trim();
-            return comment.length > 0 ? comment : undefined;
-        }
+    const commentStart = findLineCommentStart(text);
+    if (commentStart === undefined) {
+        return undefined;
     }
-    return undefined;
+    const comment = text.slice(commentStart + 1).trim();
+    return comment.length > 0 ? comment : undefined;
 }

package/dist/src/syntax/directive-aliases.js

@@ -107,34 +107,48 @@ export function buildDirectiveAliasPolicy(projectProfiles = []) {
     const directiveAliases = new Map(BUILT_IN_DIRECTIVE_ALIASES);
     const baselineKeys = new Set(directiveAliases.keys());
     for (const profile of projectProfiles) {
-        if (profile.extends !== undefined && profile.extends !== 'azm') {
-            throw new Error(`Unsupported directive alias base "${String(profile.extends)}"`);
-        }
-        if (profile.extends === undefined) {
-            throw new Error(`Project directive alias files must extend "azm"`);
-        }
+        validateProjectAliasProfile(profile);
         for (const [rawKey, rawTarget] of Object.entries(profile.directiveAliases ?? {})) {
-            const key = normalizeAliasKey(rawKey);
-            if (!key)
-                throw new Error(`Invalid directive alias head "${rawKey}"`);
-            if (baselineKeys.has(key)) {
-                throw new Error(`Directive alias "${rawKey}" conflicts with the AZM baseline`);
-            }
-            const lowerKey = key.toLowerCase();
-            if (RESERVED_INSTRUCTION_HEADS.has(lowerKey)) {
-                throw new Error(`Directive alias "${rawKey}" conflicts with a Z80 instruction`);
-            }
-            if (RESERVED_LANGUAGE_HEADS.has(lowerKey)) {
-                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}"`);
+            const key = validatedAliasKey(rawKey, baselineKeys);
+            const target = validatedAliasTarget(rawKey, rawTarget);
             directiveAliases.set(key, target);
         }
     }
     return { directiveAliases };
 }
+function validateProjectAliasProfile(profile) {
+    if (profile.extends !== undefined && profile.extends !== 'azm') {
+        throw new Error(`Unsupported directive alias base "${String(profile.extends)}"`);
+    }
+    if (profile.extends === undefined) {
+        throw new Error(`Project directive alias files must extend "azm"`);
+    }
+}
+function validatedAliasKey(rawKey, baselineKeys) {
+    const key = normalizeAliasKey(rawKey);
+    if (!key)
+        throw new Error(`Invalid directive alias head "${rawKey}"`);
+    rejectReservedAliasKey(rawKey, key, baselineKeys);
+    return key;
+}
+function rejectReservedAliasKey(rawKey, key, baselineKeys) {
+    if (baselineKeys.has(key)) {
+        throw new Error(`Directive alias "${rawKey}" conflicts with the AZM baseline`);
+    }
+    const lowerKey = key.toLowerCase();
+    if (RESERVED_INSTRUCTION_HEADS.has(lowerKey)) {
+        throw new Error(`Directive alias "${rawKey}" conflicts with a Z80 instruction`);
+    }
+    if (RESERVED_LANGUAGE_HEADS.has(lowerKey)) {
+        throw new Error(`Directive alias "${rawKey}" conflicts with an AZM language keyword`);
+    }
+}
+function validatedAliasTarget(rawKey, rawTarget) {
+    const target = normalizeAliasTarget(rawTarget);
+    if (!target)
+        throw new Error(`Invalid directive alias target "${rawTarget}" for "${rawKey}"`);
+    return target;
+}
 export async function readDirectiveAliasProfile(path) {
     const text = await readFile(path, 'utf8');
     const parsed = JSON.parse(text);

package/dist/src/syntax/expression-tokenizer.d.ts

@@ -0,0 +1,30 @@
+import type { Expression } from '../model/expression.js';
+import { type ParseNestedExpression } from './parse-layout-expression.js';
+export type Operator = Extract<Expression, {
+    readonly kind: 'binary';
+}>['operator'];
+export type UnaryOperator = Extract<Expression, {
+    readonly kind: 'unary';
+}>['operator'];
+export type Token = {
+    readonly kind: 'expression';
+    readonly expression: Expression;
+} | {
+    readonly kind: 'number';
+    readonly value: number;
+} | {
+    readonly kind: 'symbol';
+    readonly text: string;
+} | {
+    readonly kind: 'current-location';
+} | {
+    readonly kind: 'operator';
+    readonly text: Operator | UnaryOperator;
+} | {
+    readonly kind: 'comma';
+} | {
+    readonly kind: 'left-paren';
+} | {
+    readonly kind: 'right-paren';
+};
+export declare function tokenizeExpression(text: string, parseNestedExpression: ParseNestedExpression): Token[] | undefined;