@jhlagado/azm 0.2.7 → 0.2.9

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

@@ -0,0 +1,189 @@
+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: spanForLine(line),
+            },
+            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: spanForLine(line),
+        },
+    };
+}
+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 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;
+}