@jhlagado/azm 0.2.7 → 0.2.9

package/dist/src/syntax/expression-tokenizer.js

@@ -0,0 +1,310 @@
+import { findMatchingBracket, parseLayoutExpression, } from './parse-layout-expression.js';
+const TOKEN_SCANNERS = [
+    scanPunctuationToken,
+    scanShiftOperatorToken,
+    scanCurrentLocationOrHexToken,
+    scanQuotedByteToken,
+    scanSpecialTermToken,
+    scanNumberToken,
+    scanOperatorToken,
+    scanSymbolToken,
+];
+export function tokenizeExpression(text, parseNestedExpression) {
+    const tokens = [];
+    const input = text.trim();
+    let index = 0;
+    while (index < input.length) {
+        const char = input[index] ?? '';
+        if (/\s/.test(char)) {
+            index += 1;
+            continue;
+        }
+        const scanned = scanToken(input, index, parseNestedExpression);
+        if (!scanned)
+            return undefined;
+        tokens.push(scanned.token);
+        index = scanned.end;
+    }
+    return tokens.length > 0 ? tokens : undefined;
+}
+function scanToken(input, index, parseNestedExpression) {
+    for (const scanner of TOKEN_SCANNERS) {
+        const scanned = scanner(input, index, parseNestedExpression);
+        if (scanned)
+            return scanned;
+    }
+    return undefined;
+}
+function scanPunctuationToken(input, index) {
+    const char = input[index];
+    if (char === '(')
+        return { token: { kind: 'left-paren' }, end: index + 1 };
+    if (char === ')')
+        return { token: { kind: 'right-paren' }, end: index + 1 };
+    if (char === ',')
+        return { token: { kind: 'comma' }, end: index + 1 };
+    return undefined;
+}
+function scanShiftOperatorToken(input, index) {
+    const two = input.slice(index, index + 2);
+    return two === '<<' || two === '>>'
+        ? { token: { kind: 'operator', text: two }, end: index + 2 }
+        : undefined;
+}
+function scanCurrentLocationOrHexToken(input, index) {
+    if (input[index] !== '$')
+        return undefined;
+    const prefixedHex = /^\$[0-9A-Fa-f]+/.exec(input.slice(index));
+    if (prefixedHex) {
+        return {
+            token: { kind: 'number', value: Number.parseInt(prefixedHex[0].slice(1), 16) },
+            end: index + prefixedHex[0].length,
+        };
+    }
+    if (/^[A-Za-z_]/.test(input[index + 1] ?? '')) {
+        return undefined;
+    }
+    return { token: { kind: 'current-location' }, end: index + 1 };
+}
+function scanQuotedByteToken(input, index) {
+    const quote = input[index];
+    if (quote !== '"' && quote !== "'")
+        return undefined;
+    const quoted = scanQuotedByte(input, index, quote);
+    return quoted ? { token: { kind: 'number', value: quoted.value }, end: quoted.end } : undefined;
+}
+function scanSpecialTermToken(input, index, parseNestedExpression) {
+    const term = scanSpecialTerm(input, index, parseNestedExpression);
+    return term ? { token: { kind: 'expression', expression: term.expression }, end: term.end } : undefined;
+}
+function scanNumberToken(input, index) {
+    const number = scanNumber(input.slice(index));
+    return number
+        ? { token: { kind: 'number', value: number.value }, end: index + number.length }
+        : undefined;
+}
+function scanOperatorToken(input, index) {
+    const char = input[index] ?? '';
+    return isOperatorChar(char) ? { token: { kind: 'operator', text: char }, end: index + 1 } : undefined;
+}
+function scanSymbolToken(input, index) {
+    const symbol = /^(?:[A-Za-z_.][A-Za-z0-9_.?]*|\?[A-Za-z0-9_.?]+)/.exec(input.slice(index));
+    return symbol ? { token: { kind: 'symbol', text: symbol[0] }, end: index + symbol[0].length } : undefined;
+}
+function isOperatorChar(char) {
+    return ['*', '/', '%', '+', '-', '&', '^', '|', '~'].includes(char);
+}
+function scanSpecialTerm(input, start, parseNestedExpression) {
+    const byteFunction = scanByteFunction(input, start, parseNestedExpression);
+    if (byteFunction) {
+        return byteFunction;
+    }
+    return scanLayoutTerm(input, start, parseNestedExpression);
+}
+function scanByteFunction(input, start, parseNestedExpression) {
+    const head = /^(LSB|MSB)\s*\(/.exec(input.slice(start));
+    if (!head) {
+        return undefined;
+    }
+    const name = head[1];
+    const open = input.indexOf('(', start + name.length);
+    if (open === -1 || input.slice(start + name.length, open).trim().length > 0) {
+        return undefined;
+    }
+    const close = findMatchingParen(input, open);
+    if (close === undefined) {
+        return undefined;
+    }
+    const expression = parseNestedExpression(input.slice(open + 1, close));
+    return expression
+        ? { expression: { kind: 'byte-function', function: name, expression }, end: close + 1 }
+        : undefined;
+}
+function scanLayoutTerm(input, start, parseNestedExpression) {
+    const layoutCall = scanLayoutCallTerm(input, start, parseNestedExpression);
+    if (layoutCall)
+        return layoutCall;
+    if ((input[start] ?? '') !== '<') {
+        return undefined;
+    }
+    const end = scanLayoutCastEnd(input, start);
+    if (end === undefined) {
+        return undefined;
+    }
+    const expression = parseLayoutExpression(input.slice(start, end), parseNestedExpression);
+    return expression ? { expression, end } : undefined;
+}
+function scanLayoutCallTerm(input, start, parseNestedExpression) {
+    const head = scanLayoutCallHead(input, start);
+    if (!head)
+        return undefined;
+    const close = findMatchingParen(input, head.open);
+    if (close === undefined)
+        return undefined;
+    const expression = parseLayoutExpression(input.slice(start, close + 1), parseNestedExpression);
+    return expression ? { expression, end: close + 1 } : undefined;
+}
+function scanLayoutCallHead(input, start) {
+    const name = layoutCallNameAt(input, start);
+    if (!name)
+        return undefined;
+    const open = input.indexOf('(', start + name.length);
+    return open !== -1 && input.slice(start + name.length, open).trim().length === 0
+        ? { open }
+        : undefined;
+}
+function layoutCallNameAt(input, start) {
+    if (input.slice(start).startsWith('sizeof'))
+        return 'sizeof';
+    if (input.slice(start).startsWith('offset'))
+        return 'offset';
+    return undefined;
+}
+function findMatchingParen(text, open) {
+    let depth = 0;
+    let quote;
+    for (let index = open; index < text.length; index += 1) {
+        const char = text[index];
+        if (quote) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '(') {
+            depth += 1;
+        }
+        else if (char === ')') {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return undefined;
+}
+function scanLayoutCastEnd(input, start) {
+    const closeType = input.indexOf('>', start + 1);
+    if (closeType === -1) {
+        return undefined;
+    }
+    let index = closeType + 1;
+    const base = /^(?:[A-Za-z_$][A-Za-z0-9_$?]*|\?[A-Za-z0-9_$?]+)/.exec(input.slice(index));
+    if (!base) {
+        return undefined;
+    }
+    index += base[0].length;
+    let sawPath = false;
+    while (index < input.length) {
+        const char = input[index];
+        if (char === '.') {
+            const field = /^\.([A-Za-z_][A-Za-z0-9_]*)/.exec(input.slice(index));
+            if (!field) {
+                return undefined;
+            }
+            sawPath = true;
+            index += field[0].length;
+            continue;
+        }
+        if (char === '[') {
+            const close = findMatchingBracket(input.slice(index));
+            if (close === undefined) {
+                return undefined;
+            }
+            sawPath = true;
+            index += close + 1;
+            continue;
+        }
+        break;
+    }
+    return sawPath ? index : undefined;
+}
+function scanNumber(text) {
+    const trailingHex = /^[0-9][0-9A-Fa-f]*[Hh]\b/.exec(text);
+    if (trailingHex) {
+        return {
+            value: Number.parseInt(trailingHex[0].slice(0, -1), 16),
+            length: trailingHex[0].length,
+        };
+    }
+    const trailingBinary = /^[01]+[Bb]\b/.exec(text);
+    if (trailingBinary) {
+        return {
+            value: Number.parseInt(trailingBinary[0].slice(0, -1), 2),
+            length: trailingBinary[0].length,
+        };
+    }
+    const percentBinary = /^%[01]+/.exec(text);
+    if (percentBinary) {
+        return {
+            value: Number.parseInt(percentBinary[0].slice(1), 2),
+            length: percentBinary[0].length,
+        };
+    }
+    const prefixedBinary = /^0b[01]+/i.exec(text);
+    if (prefixedBinary) {
+        return {
+            value: Number.parseInt(prefixedBinary[0].slice(2), 2),
+            length: prefixedBinary[0].length,
+        };
+    }
+    const prefixedHex = /^0x[0-9A-Fa-f]+/i.exec(text);
+    if (prefixedHex) {
+        return { value: Number.parseInt(prefixedHex[0].slice(2), 16), length: prefixedHex[0].length };
+    }
+    const decimal = /^[0-9]+/.exec(text);
+    if (decimal) {
+        return { value: Number.parseInt(decimal[0], 10), length: decimal[0].length };
+    }
+    return undefined;
+}
+function scanQuotedByte(text, start, quote) {
+    const valueIndex = start + 1;
+    const value = text[valueIndex];
+    if (!isQuotedByteValueStart(value, quote))
+        return undefined;
+    const scanned = value === '\\' ? scanEscapedQuotedByte(text, valueIndex) : scanLiteralQuotedByte(value, valueIndex);
+    if (!scanned)
+        return undefined;
+    return text[scanned.end] === quote
+        ? { value: scanned.value, end: scanned.end + 1 }
+        : undefined;
+}
+function isQuotedByteValueStart(value, quote) {
+    return value !== undefined && value !== quote && value !== '\n' && value !== '\r';
+}
+function scanEscapedQuotedByte(text, valueIndex) {
+    const escaped = text[valueIndex + 1];
+    if (escaped === undefined)
+        return undefined;
+    const value = escapeByteValue(escaped);
+    return value === undefined ? undefined : { value, end: valueIndex + 2 };
+}
+function scanLiteralQuotedByte(value, valueIndex) {
+    const byte = value.codePointAt(0) ?? 0;
+    return { value: byte, end: valueIndex + (byte > 0xffff ? 2 : 1) };
+}
+function escapeByteValue(char) {
+    switch (char) {
+        case '0':
+            return 0;
+        case 'n':
+            return 10;
+        case 'r':
+            return 13;
+        case 't':
+            return 9;
+        case "'":
+            return 39;
+        case '"':
+            return 34;
+        case '\\':
+            return 92;
+        default:
+            return undefined;
+    }
+}

package/dist/src/syntax/parse-directive-statement.d.ts

@@ -0,0 +1,9 @@
+import type { LogicalLine } from '../source/logical-lines.js';
+import type { SourceSpan } from '../source/source-span.js';
+import type { ParseLineResult } from './parse-line.js';
+export declare function parseDirectiveStatement(line: LogicalLine, text: string, span: SourceSpan): ParseLineResult | undefined;
+export declare function parseColonDeclaration(line: LogicalLine, name: string, statementText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult | undefined;

package/dist/src/syntax/parse-directive-statement.js

@@ -0,0 +1,309 @@
+import { parseExpression, parseTypeExpr } from './parse-expression.js';
+const DIRECTIVE_PARSERS = [
+    {
+        pattern: /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/,
+        parse: (line, match, span) => parseEquItem(line, match[1] ?? '', match[2] ?? '', span),
+    },
+    {
+        pattern: /^\.org\s+(.+)$/,
+        parse: (line, match, span) => parseExpressionDirective(line, 'org', match[1] ?? '', span),
+    },
+    {
+        pattern: /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/,
+        parse: (line, match) => ({
+            items: [],
+            diagnostics: [parseError(line, `Use "${match[1] ?? ''} .enum ..." for enums.`)],
+        }),
+    },
+    {
+        pattern: /^([A-Za-z_][A-Za-z0-9_]*)\s+\.enum\s+(.+)$/,
+        parse: (line, match, span) => parseEnumItem(line, match[1] ?? '', match[2] ?? '', span),
+    },
+    {
+        pattern: /^(\.db|\.dw)\s+(.+)$/,
+        parse: (line, match, span) => parseDataDirective(line, match[1] ?? '', match[2] ?? '', span),
+    },
+    {
+        pattern: /^\.ds\s+(.+)$/,
+        parse: (line, match, span) => parseDsDirective(line, match[1] ?? '', span),
+    },
+    {
+        pattern: /^\.align\s+(.+)$/,
+        parse: (line, match, span) => parseExpressionDirective(line, 'align', match[1] ?? '', span),
+    },
+    {
+        pattern: /^\.end\s*$/,
+        parse: (_line, _match, span) => ({ items: [{ kind: 'end', span }], diagnostics: [] }),
+    },
+    {
+        pattern: /^(\.binfrom|\.binto)\s+(.+)$/,
+        parse: (line, match, span) => parseExpressionDirective(line, (match[1] ?? '').slice(1).toLowerCase(), match[2] ?? '', span),
+    },
+    {
+        pattern: /^(\.cstr|\.pstr|\.istr)\s+(.+)$/,
+        parse: (line, match, span) => parseStringDataDirective(line, (match[1] ?? '').slice(1).toLowerCase(), match[2] ?? '', span),
+    },
+];
+export function parseDirectiveStatement(line, text, span) {
+    for (const parser of DIRECTIVE_PARSERS) {
+        const match = parser.pattern.exec(text);
+        if (match) {
+            return parser.parse(line, match, span);
+        }
+    }
+    return undefined;
+}
+export 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 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 parseExpressionDirective(line, kind, expressionText, span) {
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        return {
+            items: [],
+            diagnostics: [parseError(line, `invalid .${kind} expression: ${expressionText}`)],
+        };
+    }
+    if (kind === 'align') {
+        return { items: [{ kind, alignment: expression, span }], diagnostics: [] };
+    }
+    return { items: [{ kind, expression, span }], diagnostics: [] };
+}
+function parseDataDirective(line, directiveText, valueText, span) {
+    const directive = directiveText.slice(1).toLowerCase();
+    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: [],
+    };
+}
+function parseDsDirective(line, valueText, span) {
+    const parts = splitValueList(valueText);
+    const listDiagnostic = validateDsValueList(line, parts);
+    if (listDiagnostic) {
+        return { items: [], diagnostics: [listDiagnostic] };
+    }
+    const sizeResult = parseDsSize(line, parts[0] ?? '');
+    if (sizeResult.diagnostic) {
+        return { items: [], diagnostics: [sizeResult.diagnostic] };
+    }
+    const fillResult = parseDsFill(line, parts[1]);
+    if (fillResult.diagnostic) {
+        return { items: [], diagnostics: [fillResult.diagnostic] };
+    }
+    return {
+        items: [
+            fillResult.fill === undefined
+                ? { kind: 'ds', size: sizeResult.size, span }
+                : { kind: 'ds', size: sizeResult.size, fill: fillResult.fill, span },
+        ],
+        diagnostics: [],
+    };
+}
+function validateDsValueList(line, parts) {
+    return parts.length < 1 || parts.length > 2
+        ? parseError(line, `invalid .ds value list`)
+        : undefined;
+}
+function parseDsSize(line, sizeText) {
+    const size = parseTypeSizeExpression(sizeText) ?? parseExpression(sizeText);
+    if (!size) {
+        return {
+            diagnostic: parseError(line, `invalid .ds size: ${sizeText}`),
+        };
+    }
+    return { size };
+}
+function parseDsFill(line, fillText) {
+    if (fillText === undefined)
+        return { fill: undefined };
+    const fill = parseExpression(fillText);
+    if (!fill) {
+        return {
+            diagnostic: parseError(line, `invalid .ds fill: ${fillText}`),
+        };
+    }
+    return { fill };
+}
+function parseStringDataDirective(line, directive, valueText, span) {
+    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: [] };
+}
+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 state = { quote: undefined, escaped: false, parenDepth: 0 };
+    let start = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (isValueSeparator(text[index] ?? '', state)) {
+            values.push(text.slice(start, index));
+            start = index + 1;
+            continue;
+        }
+        state = scanValueListChar(text[index] ?? '', state);
+    }
+    values.push(text.slice(start));
+    return values;
+}
+function isValueSeparator(char, state) {
+    return char === ',' && state.quote === undefined && state.parenDepth === 0;
+}
+function scanValueListChar(char, state) {
+    const escapedState = scanEscapedValueListChar(char, state);
+    if (escapedState)
+        return escapedState;
+    const quotedState = scanQuotedValueListChar(char, state);
+    if (quotedState)
+        return quotedState;
+    return scanParenthesizedValueListChar(char, state);
+}
+function scanEscapedValueListChar(char, state) {
+    if (state.escaped)
+        return { ...state, escaped: false };
+    if (char === '\\' && state.quote !== undefined)
+        return { ...state, escaped: true };
+    return undefined;
+}
+function scanQuotedValueListChar(char, state) {
+    if (char !== '"' && char !== "'")
+        return undefined;
+    return { ...state, quote: state.quote === char ? undefined : (state.quote ?? char) };
+}
+function scanParenthesizedValueListChar(char, state) {
+    if (state.quote !== undefined)
+        return state;
+    if (char === '(')
+        return { ...state, parenDepth: state.parenDepth + 1 };
+    if (char === ')')
+        return { ...state, parenDepth: Math.max(0, state.parenDepth - 1) };
+    return state;
+}
+function parseQuotedString(text) {
+    return parseQuotedStringWithQuotes(text, new Set(['"']));
+}
+function parseWholeQuotedString(text) {
+    return parseQuotedStringWithQuotes(text, new Set(['"', "'"]));
+}
+function parseQuotedStringWithQuotes(text, allowedQuotes) {
+    const input = text.trim();
+    const quote = input[0];
+    if (!quote || !allowedQuotes.has(quote) || input[input.length - 1] !== quote) {
+        return undefined;
+    }
+    return parseQuotedStringContent(input, quote);
+}
+function parseQuotedStringContent(input, quote) {
+    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 firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}
+function parseError(line, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstColumn(line.text),
+    };
+}

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

@@ -1,3 +1,3 @@
-import type { Expression, TypeExpr } from '../model/expression.js';
+import type { Expression } from '../model/expression.js';
+export { parseTypeExpr } from './parse-layout-expression.js';
 export declare function parseExpression(text: string): Expression | undefined;
-export declare function parseTypeExpr(text: string): TypeExpr | undefined;