@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/syntax/parse-layout-declarations.js

@@ -0,0 +1,180 @@
+import { stripLineComment } from '../source/strip-line-comment.js';
+import { parseTypeExpr } from './parse-expression.js';
+export function parseLayoutDeclarationAt(lines, index) {
+    const line = lines[index];
+    if (line === undefined)
+        return undefined;
+    const text = stripLineComment(line.text).trim();
+    const typeAlias = parseTypeAlias(line, text);
+    if (typeAlias !== undefined) {
+        return { consumedUntilIndex: index, ...typeAlias };
+    }
+    const prefixLayoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/.exec(text);
+    if (prefixLayoutHeader) {
+        const directive = prefixLayoutHeader[1] ?? 'type';
+        return {
+            consumedUntilIndex: skipToLayoutEnd(lines, index, directive),
+            diagnostics: [
+                parseDiagnostic(line, `Use "${prefixLayoutHeader[2] ?? ''} .${directive}" for layouts.`),
+            ],
+        };
+    }
+    const layoutHeader = parseNameLeftLayoutHeader(text);
+    if (layoutHeader === undefined) {
+        return undefined;
+    }
+    return parseLayoutBlock(lines, index, layoutHeader);
+}
+function parseTypeAlias(line, text) {
+    const nameLeftTypeAlias = /^([A-Za-z_][A-Za-z0-9_]*)(?::\s*|\s+)\.typealias\s+(.+)$/.exec(text);
+    if (nameLeftTypeAlias) {
+        const typeExprText = nameLeftTypeAlias[2] ?? '';
+        const typeExpr = parseTypeExpr(typeExprText);
+        if (!typeExpr) {
+            return { diagnostics: [parseDiagnostic(line, `invalid .typealias target: ${typeExprText}`)] };
+        }
+        return {
+            item: {
+                kind: 'type-alias',
+                name: nameLeftTypeAlias[1] ?? '',
+                typeExpr,
+                span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+            },
+            diagnostics: [],
+        };
+    }
+    const oldTypeAlias = /^\.type\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/.exec(text);
+    if (oldTypeAlias) {
+        return {
+            diagnostics: [
+                parseDiagnostic(line, `Use "${oldTypeAlias[1] ?? ''} .typealias ..." for type aliases.`),
+            ],
+        };
+    }
+    return undefined;
+}
+function parseNameLeftLayoutHeader(text) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)(?::\s*|\s+)\.(type|union)\s*$/.exec(text);
+    return match
+        ? {
+            directive: match[2] ?? '',
+            name: match[1] ?? '',
+        }
+        : undefined;
+}
+function parseLayoutBlock(lines, index, header) {
+    const line = lines[index];
+    const layoutKind = header.directive === 'union' ? 'union' : 'record';
+    const endDirective = layoutKind === 'union' ? '.endunion' : '.endtype';
+    const fields = [];
+    const diagnostics = [];
+    let consumedUntilIndex = index;
+    let terminated = false;
+    for (let fieldIndex = index + 1; fieldIndex < lines.length; fieldIndex += 1) {
+        consumedUntilIndex = fieldIndex;
+        const fieldLine = lines[fieldIndex];
+        const fieldText = stripLineComment(fieldLine.text).trim();
+        if (fieldText.length === 0) {
+            continue;
+        }
+        if (fieldText === endDirective) {
+            terminated = true;
+            break;
+        }
+        const field = parseLayoutField(fieldText);
+        if (!field) {
+            diagnostics.push(parseDiagnostic(fieldLine, `invalid .${header.directive} field declaration`));
+            continue;
+        }
+        fields.push(field);
+    }
+    if (!terminated) {
+        diagnostics.push(parseDiagnostic(line, `.${header.directive} ${header.name} missing ${endDirective}`));
+    }
+    return {
+        consumedUntilIndex,
+        diagnostics,
+        item: {
+            kind: 'type',
+            name: header.name,
+            layoutKind,
+            fields,
+            span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+        },
+    };
+}
+function skipToLayoutEnd(lines, index, directive) {
+    const endDirective = directive === 'union' ? '.endunion' : '.endtype';
+    for (let next = index + 1; next < lines.length; next += 1) {
+        if (stripLineComment(lines[next].text).trim() === endDirective) {
+            return next;
+        }
+    }
+    return index;
+}
+function parseLayoutField(text) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/.exec(text);
+    if (!match) {
+        return undefined;
+    }
+    const name = match[1] ?? '';
+    const directive = (match[2] ?? '').toLowerCase();
+    const operand = match[3]?.trim();
+    return directive === '.field'
+        ? parseNamedField(name, operand)
+        : parseScalarDirectiveField(name, directive, operand);
+}
+function parseNamedField(name, operand) {
+    return operand === undefined ? undefined : parseFieldOperand(name, operand);
+}
+function parseScalarDirectiveField(name, directive, operand) {
+    if (operand !== undefined) {
+        return undefined;
+    }
+    const size = scalarDirectiveSize(directive);
+    return size === undefined ? undefined : { name, size };
+}
+function scalarDirectiveSize(directive) {
+    if (directive === '.byte')
+        return 1;
+    if (directive === '.word' || directive === '.addr')
+        return 2;
+    return undefined;
+}
+function parseFieldOperand(name, operand) {
+    const size = /^[0-9]+$/.test(operand) ? Number.parseInt(operand, 10) : undefined;
+    if (size !== undefined) {
+        return size > 0 ? { name, size } : undefined;
+    }
+    const scalar = scalarFieldSize(operand);
+    if (scalar !== undefined) {
+        return { name, size: scalar };
+    }
+    const typeExpr = parseTypeExpr(operand);
+    return typeExpr ? { name, size: 0, typeExpr } : undefined;
+}
+function scalarFieldSize(typeName) {
+    switch (typeName.toLowerCase()) {
+        case 'byte':
+            return 1;
+        case 'word':
+        case 'addr':
+            return 2;
+        default:
+            return undefined;
+    }
+}
+function parseDiagnostic(line, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstColumn(line.text),
+    };
+}
+function firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}

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

@@ -0,0 +1,5 @@
+import type { Expression, TypeExpr } from '../model/expression.js';
+export type ParseNestedExpression = (text: string) => Expression | undefined;
+export declare function parseTypeExpr(text: string): TypeExpr | undefined;
+export declare function parseLayoutExpression(text: string, parseNestedExpression: ParseNestedExpression): Expression | undefined;
+export declare function findMatchingBracket(text: string): number | undefined;

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

@@ -0,0 +1,175 @@
+export function parseTypeExpr(text) {
+    const trimmed = text.trim();
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)(?:\[\s*([0-9]+)\s*\])?$/.exec(trimmed);
+    if (!match) {
+        return undefined;
+    }
+    const name = match[1] ?? '';
+    const lengthText = match[2];
+    if (lengthText === undefined) {
+        return { name };
+    }
+    const length = Number.parseInt(lengthText, 10);
+    return length >= 0 ? { name, length } : undefined;
+}
+export function parseLayoutExpression(text, parseNestedExpression) {
+    const trimmed = text.trim();
+    const layoutCast = parseLayoutCast(trimmed, parseNestedExpression);
+    if (layoutCast) {
+        return layoutCast;
+    }
+    const sizeof = /^sizeof\s*\((.*)\)$/.exec(trimmed);
+    if (sizeof) {
+        const typeExpr = parseTypeExpr(sizeof[1] ?? '');
+        return typeExpr ? { kind: 'sizeof', typeExpr } : undefined;
+    }
+    const offset = /^offset\s*\((.*),(.*)\)$/.exec(trimmed);
+    if (offset) {
+        const typeExpr = parseTypeExpr(offset[1] ?? '');
+        const path = parseOffsetPath(offset[2] ?? '');
+        return typeExpr && path ? { kind: 'offset', typeExpr, path } : undefined;
+    }
+    return undefined;
+}
+export function findMatchingBracket(text) {
+    let state = { depth: 0, quote: undefined, escaped: false };
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index] ?? '';
+        if (state.quote !== undefined) {
+            state = scanQuotedBracketChar(char, state);
+            continue;
+        }
+        const quotedState = startBracketQuote(char, state);
+        if (quotedState) {
+            state = quotedState;
+            continue;
+        }
+        state = scanBracketDepth(char, state);
+        if (char === ']') {
+            if (state.depth === 0) {
+                return index;
+            }
+        }
+    }
+    return undefined;
+}
+function scanQuotedBracketChar(char, state) {
+    if (state.escaped)
+        return { ...state, escaped: false };
+    if (char === '\\')
+        return { ...state, escaped: true };
+    if (char === state.quote)
+        return { ...state, quote: undefined };
+    return state;
+}
+function startBracketQuote(char, state) {
+    return char === '"' || char === "'" ? { ...state, quote: char } : undefined;
+}
+function scanBracketDepth(char, state) {
+    if (char === '[')
+        return { ...state, depth: state.depth + 1 };
+    if (char === ']')
+        return { ...state, depth: state.depth - 1 };
+    return state;
+}
+function parseLayoutCast(text, parseNestedExpression) {
+    if (!text.startsWith('<')) {
+        return undefined;
+    }
+    const close = text.indexOf('>');
+    if (close <= 1) {
+        return undefined;
+    }
+    const typeExpr = parseTypeExpr(text.slice(1, close));
+    if (!typeExpr) {
+        return undefined;
+    }
+    const rest = text.slice(close + 1);
+    const base = /^(?:[A-Za-z_$][A-Za-z0-9_$?]*|\?[A-Za-z0-9_$?]+)/.exec(rest);
+    if (!base) {
+        return undefined;
+    }
+    const path = parseLayoutCastPath(rest.slice(base[0].length), parseNestedExpression);
+    if (!path) {
+        return undefined;
+    }
+    return {
+        kind: 'layout-cast',
+        typeExpr,
+        base: { kind: 'symbol', name: base[0] },
+        path,
+    };
+}
+function parseLayoutCastPath(text, parseNestedExpression) {
+    const parts = [];
+    let rest = text.trim();
+    while (rest.length > 0) {
+        const parsed = parseLayoutCastPathPart(rest, parseNestedExpression);
+        if (!parsed)
+            return undefined;
+        parts.push(parsed.part);
+        rest = parsed.rest.trim();
+    }
+    return parts.length > 0 ? parts : undefined;
+}
+function parseLayoutCastPathPart(text, parseNestedExpression) {
+    return text.startsWith('.')
+        ? parseLayoutCastField(text)
+        : parseLayoutCastIndex(text, parseNestedExpression);
+}
+function parseLayoutCastField(text) {
+    const field = /^\.([A-Za-z_][A-Za-z0-9_]*)/.exec(text);
+    return field ? { part: { kind: 'field', name: field[1] ?? '' }, rest: text.slice(field[0].length) } : undefined;
+}
+function parseLayoutCastIndex(text, parseNestedExpression) {
+    if (!text.startsWith('['))
+        return undefined;
+    const close = findMatchingBracket(text);
+    if (close === undefined)
+        return undefined;
+    const expression = parseNestedExpression(text.slice(1, close));
+    return expression
+        ? { part: { kind: 'index', expression }, rest: text.slice(close + 1) }
+        : undefined;
+}
+function parseOffsetPath(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    const parts = [];
+    let rest = trimmed;
+    while (rest.length > 0) {
+        const parsed = parseOffsetPathPart(rest);
+        if (!parsed)
+            return undefined;
+        parts.push(parsed.part);
+        rest = parsed.rest;
+        if (rest.length === 0) {
+            break;
+        }
+        if (!rest.startsWith('.')) {
+            return undefined;
+        }
+        rest = rest.slice(1);
+    }
+    return parts.length > 0 ? parts : undefined;
+}
+function parseOffsetPathPart(text) {
+    return text.startsWith('[') ? parseOffsetIndex(text) : parseOffsetField(text);
+}
+function parseOffsetIndex(text) {
+    const index = /^\[\s*([0-9]+)\s*\]/.exec(text);
+    return index
+        ? {
+            part: { kind: 'index', index: Number.parseInt(index[1] ?? '', 10) },
+            rest: text.slice(index[0].length),
+        }
+        : undefined;
+}
+function parseOffsetField(text) {
+    const field = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text);
+    return field
+        ? { part: { kind: 'field', name: field[0] }, rest: text.slice(field[0].length) }
+        : undefined;
+}

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

@@ -1,6 +1,6 @@
 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();
@@ -84,149 +84,10 @@ function withLineComment(line, result) {
         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,135 +107,6 @@ 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 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;