@jhlagado/azm 0.2.0 → 0.2.2

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

@@ -1,397 +0,0 @@
-import { parseDiag as diag } from './parseDiagnostics.js';
-import { CHAR_ESCAPE_VALUES, IMM_BINARY_OPERATORS, IMM_BINARY_OPERATOR_PRECEDENCE, IMM_MULTI_CHAR_OPERATORS, IMM_UNARY_OPERATOR_SET, } from './grammarData.js';
-export function immLiteral(filePath, s, value) {
-    return { kind: 'ImmLiteral', span: { ...s, file: filePath }, value };
-}
-function immName(filePath, s, name) {
-    return { kind: 'ImmName', span: { ...s, file: filePath }, name };
-}
-export function parseTypeExprFromText(typeText, typeSpan) {
-    let rest = typeText.trim();
-    const nameMatch = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(rest);
-    if (!nameMatch)
-        return undefined;
-    const name = nameMatch[1];
-    rest = rest.slice(name.length).trimStart();
-    let typeExpr = { kind: 'TypeName', span: typeSpan, name };
-    while (rest.startsWith('[')) {
-        const m = /^\[\s*([0-9]+)?\s*\]/.exec(rest);
-        if (!m)
-            return undefined;
-        const lenText = m[1];
-        if (lenText === undefined)
-            return undefined;
-        typeExpr = {
-            kind: 'ArrayType',
-            span: typeSpan,
-            element: typeExpr,
-            length: Number.parseInt(lenText, 10),
-        };
-        rest = rest.slice(m[0].length).trimStart();
-    }
-    if (rest.length > 0)
-        return undefined;
-    return typeExpr;
-}
-export function diagIfArrayLengthMissing(diagnostics, filePath, typeText, where) {
-    if (!/\[\s*\]/.test(typeText))
-        return false;
-    diag(diagnostics, filePath, `Array length is required here; write T[N].`, where);
-    return true;
-}
-export function parseNumberLiteral(text) {
-    const t = text.trim();
-    if (/^[0-9][0-9A-Fa-f]*[Hh]$/.test(t)) {
-        return Number.parseInt(t.slice(0, -1), 16);
-    }
-    if (/^[01]+[Bb]$/.test(t)) {
-        return Number.parseInt(t.slice(0, -1), 2);
-    }
-    if (/^\$[0-9A-Fa-f]+$/.test(t)) {
-        return Number.parseInt(t.slice(1), 16);
-    }
-    if (/^%[01]+$/.test(t)) {
-        return Number.parseInt(t.slice(1), 2);
-    }
-    if (/^0b[01]+$/.test(t)) {
-        return Number.parseInt(t.slice(2), 2);
-    }
-    if (/^0x[0-9A-Fa-f]+$/i.test(t)) {
-        return Number.parseInt(t.slice(2), 16);
-    }
-    if (/^[0-9]+$/.test(t)) {
-        return Number.parseInt(t, 10);
-    }
-    return undefined;
-}
-function isImmUnaryOp(op) {
-    return IMM_UNARY_OPERATOR_SET.has(op);
-}
-function isImmBinaryOp(op) {
-    return IMM_BINARY_OPERATORS.has(op);
-}
-function isImmOpToken(text) {
-    return IMM_UNARY_OPERATOR_SET.has(text) || IMM_BINARY_OPERATORS.has(text);
-}
-function scanQuotedByteValue(s, start, quote) {
-    let i = start + 1;
-    if (i >= s.length)
-        return undefined;
-    let value;
-    if (s[i] === '\\') {
-        i++;
-        if (i >= s.length)
-            return undefined;
-        const esc = s[i];
-        i++;
-        if (esc === 'x') {
-            const hex = s.slice(i, i + 2);
-            if (!/^[0-9A-Fa-f]{2}$/.test(hex))
-                return undefined;
-            value = Number.parseInt(hex, 16);
-            i += 2;
-        }
-        else {
-            const escaped = CHAR_ESCAPE_VALUES.get(esc);
-            if (escaped === undefined)
-                return undefined;
-            value = escaped;
-        }
-    }
-    else {
-        if (s[i] === quote || s[i] === '\n' || s[i] === '\r')
-            return undefined;
-        const cp = s.codePointAt(i);
-        if (cp === undefined)
-            return undefined;
-        value = cp;
-        i += cp > 0xffff ? 2 : 1;
-    }
-    if (i >= s.length || s[i] !== quote)
-        return undefined;
-    return { value, end: i + 1 };
-}
-function tokenizeImm(text) {
-    const out = [];
-    let i = 0;
-    const s = text.trim();
-    while (i < s.length) {
-        const ch = s[i];
-        if (/\s/.test(ch)) {
-            i++;
-            continue;
-        }
-        if (ch === '(') {
-            out.push({ kind: 'lparen' });
-            i++;
-            continue;
-        }
-        if (ch === ',') {
-            out.push({ kind: 'comma' });
-            i++;
-            continue;
-        }
-        if (ch === '.') {
-            out.push({ kind: 'dot' });
-            i++;
-            continue;
-        }
-        if (ch === ')') {
-            out.push({ kind: 'rparen' });
-            i++;
-            continue;
-        }
-        if (ch === '[') {
-            out.push({ kind: 'lbrack' });
-            i++;
-            continue;
-        }
-        if (ch === ']') {
-            out.push({ kind: 'rbrack' });
-            i++;
-            continue;
-        }
-        const two = s.slice(i, i + 2);
-        if (IMM_MULTI_CHAR_OPERATORS.has(two)) {
-            out.push({ kind: 'op', text: two });
-            i += 2;
-            continue;
-        }
-        if (ch === '$') {
-            if (/^[0-9A-Fa-f]/.test(s[i + 1] ?? '')) {
-                const num = /^\$[0-9A-Fa-f]+/.exec(s.slice(i));
-                if (!num)
-                    return undefined;
-                out.push({ kind: 'num', text: num[0] });
-                i += num[0].length;
-                continue;
-            }
-            if (/^[A-Za-z_]/.test(s[i + 1] ?? ''))
-                return undefined;
-            out.push({ kind: 'current' });
-            i++;
-            continue;
-        }
-        if (ch === "'" || ch === '"') {
-            const quoted = scanQuotedByteValue(s, i, ch);
-            if (!quoted)
-                return undefined;
-            i = quoted.end;
-            out.push({ kind: 'num', text: String(quoted.value) });
-            continue;
-        }
-        const num = /^([0-9][0-9A-Fa-f]*[Hh]|%[01]+|0b[01]+|0x[0-9A-Fa-f]+|[01]+[Bb]|[0-9]+)/i.exec(s.slice(i));
-        if (num) {
-            out.push({ kind: 'num', text: num[0] });
-            i += num[0].length;
-            continue;
-        }
-        if (isImmOpToken(ch)) {
-            out.push({ kind: 'op', text: ch });
-            i++;
-            continue;
-        }
-        const ident = /^[A-Za-z_][A-Za-z0-9_]*/.exec(s.slice(i));
-        if (ident) {
-            out.push({ kind: 'ident', text: ident[0] });
-            i += ident[0].length;
-            continue;
-        }
-        return undefined;
-    }
-    return out;
-}
-export function parseImmExprFromText(filePath, exprText, exprSpan, diagnostics, emitDiagnostics = true) {
-    const tokenized = tokenizeImm(exprText);
-    if (!tokenized) {
-        if (emitDiagnostics) {
-            diag(diagnostics, filePath, `Invalid imm expression: ${exprText}`, {
-                line: exprSpan.start.line,
-                column: exprSpan.start.column,
-            });
-        }
-        return undefined;
-    }
-    const tokens = tokenized;
-    let idx = 0;
-    function parseDottedIdentName() {
-        const first = tokens[idx];
-        if (!first || first.kind !== 'ident')
-            return undefined;
-        const parts = [first.text];
-        idx++;
-        while (tokens[idx]?.kind === 'dot') {
-            const next = tokens[idx + 1];
-            if (!next || next.kind !== 'ident')
-                return undefined;
-            parts.push(next.text);
-            idx += 2;
-        }
-        return parts.join('.');
-    }
-    function parseBuiltinTypeExprArg() {
-        const nameTok = tokens[idx];
-        if (!nameTok || nameTok.kind !== 'ident')
-            return undefined;
-        const name = nameTok.text;
-        idx++;
-        let typeExpr = { kind: 'TypeName', span: exprSpan, name };
-        while (tokens[idx]?.kind === 'lbrack') {
-            idx++;
-            const lenTok = tokens[idx];
-            if (!lenTok || lenTok.kind !== 'num')
-                return undefined;
-            if (!/^[0-9]+$/.test(lenTok.text))
-                return undefined;
-            const len = Number.parseInt(lenTok.text, 10);
-            idx++;
-            if (tokens[idx]?.kind !== 'rbrack')
-                return undefined;
-            idx++;
-            typeExpr = { kind: 'ArrayType', span: exprSpan, element: typeExpr, length: len };
-        }
-        return typeExpr;
-    }
-    function parseOffsetPathArg() {
-        const root = tokens[idx];
-        if (!root || (root.kind !== 'ident' && root.kind !== 'lbrack'))
-            return undefined;
-        const base = root.kind === 'ident' ? root.text : undefined;
-        if (base !== undefined)
-            idx++;
-        const path = {
-            kind: 'OffsetPath',
-            span: exprSpan,
-            ...(base !== undefined ? { base } : {}),
-            steps: [],
-        };
-        while (true) {
-            if (tokens[idx]?.kind === 'dot') {
-                idx++;
-                const fieldTok = tokens[idx];
-                if (!fieldTok || fieldTok.kind !== 'ident')
-                    return undefined;
-                idx++;
-                path.steps.push({ kind: 'OffsetField', span: exprSpan, name: fieldTok.text });
-                continue;
-            }
-            if (tokens[idx]?.kind === 'lbrack') {
-                idx++;
-                const inner = parseExpr(1);
-                if (!inner)
-                    return undefined;
-                if (tokens[idx]?.kind !== 'rbrack')
-                    return undefined;
-                idx++;
-                path.steps.push({ kind: 'OffsetIndex', span: exprSpan, expr: inner });
-                continue;
-            }
-            break;
-        }
-        return path;
-    }
-    function parseExpr(minPrec) {
-        let left = parsePrimary();
-        if (!left)
-            return undefined;
-        while (true) {
-            const t = tokens[idx];
-            if (!t || t.kind !== 'op')
-                break;
-            const prec = IMM_BINARY_OPERATOR_PRECEDENCE.get(t.text) ?? 0;
-            if (prec < minPrec)
-                break;
-            if (!isImmBinaryOp(t.text))
-                break;
-            idx++;
-            const right = parseExpr(prec + 1);
-            if (!right)
-                return undefined;
-            left = { kind: 'ImmBinary', span: exprSpan, op: t.text, left, right };
-        }
-        return left;
-    }
-    function parsePrimary() {
-        const t = tokens[idx];
-        if (!t)
-            return undefined;
-        if (t.kind === 'num') {
-            idx++;
-            const n = parseNumberLiteral(t.text);
-            if (n === undefined)
-                return undefined;
-            return immLiteral(filePath, exprSpan, n);
-        }
-        if (t.kind === 'current') {
-            idx++;
-            return { kind: 'ImmCurrentLocation', span: { ...exprSpan, file: filePath } };
-        }
-        if (t.kind === 'ident') {
-            if (t.text === 'sizeof' && tokens[idx + 1]?.kind === 'lparen') {
-                idx += 2;
-                const typeExpr = parseBuiltinTypeExprArg();
-                if (!typeExpr)
-                    return undefined;
-                if (tokens[idx]?.kind !== 'rparen')
-                    return undefined;
-                idx++;
-                return { kind: 'ImmSizeof', span: exprSpan, typeExpr };
-            }
-            if (t.text === 'offset' && tokens[idx + 1]?.kind === 'lparen') {
-                idx += 2;
-                const typeExpr = parseBuiltinTypeExprArg();
-                if (!typeExpr)
-                    return undefined;
-                if (tokens[idx]?.kind !== 'comma')
-                    return undefined;
-                idx++;
-                const path = parseOffsetPathArg();
-                if (!path)
-                    return undefined;
-                if (tokens[idx]?.kind !== 'rparen')
-                    return undefined;
-                idx++;
-                return { kind: 'ImmOffset', span: exprSpan, typeExpr, path };
-            }
-            const name = parseDottedIdentName();
-            return name ? immName(filePath, exprSpan, name) : undefined;
-        }
-        if (t.kind === 'dot') {
-            const next = tokens[idx + 1];
-            if (!next || next.kind !== 'ident')
-                return undefined;
-            const name = next.text;
-            idx += 2;
-            return immName(filePath, exprSpan, `.${name}`);
-        }
-        if (t.kind === 'op' && isImmUnaryOp(t.text)) {
-            idx++;
-            const inner = parsePrimary();
-            if (!inner)
-                return undefined;
-            return { kind: 'ImmUnary', span: exprSpan, op: t.text, expr: inner };
-        }
-        if (t.kind === 'lparen') {
-            idx++;
-            const inner = parseExpr(1);
-            if (!inner)
-                return undefined;
-            if (tokens[idx]?.kind !== 'rparen')
-                return undefined;
-            idx++;
-            return inner;
-        }
-        return undefined;
-    }
-    const root = parseExpr(1);
-    if (!root || idx !== tokens.length) {
-        if (emitDiagnostics) {
-            diag(diagnostics, filePath, `Invalid imm expression: ${exprText}`, {
-                line: exprSpan.start.line,
-                column: exprSpan.start.column,
-            });
-        }
-        return undefined;
-    }
-    return root;
-}

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

@@ -1,11 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { SourceFile } from './source.js';
-export type LogicalLine = {
-    raw: string;
-    startOffset: number;
-    endOffset: number;
-    lineNo: number;
-    filePath: string;
-};
-export declare function buildLogicalLines(file: SourceFile, sourcePath: string, diagnostics: Diagnostic[]): LogicalLine[];
-export declare function getLogicalLine(logicalLines: LogicalLine[], lineIndex: number, sourcePath: string): LogicalLine;

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

@@ -1,94 +0,0 @@
-import { parseDiag as diag } from './parseDiagnostics.js';
-export function buildLogicalLines(file, sourcePath, diagnostics) {
-    const logicalLines = [];
-    for (let i = 0; i < file.lineStarts.length; i++) {
-        const startOffset = file.lineStarts[i] ?? 0;
-        const nextStart = file.lineStarts[i + 1] ?? file.text.length;
-        let rawWithEol = file.text.slice(startOffset, nextStart);
-        if (rawWithEol.endsWith('\n'))
-            rawWithEol = rawWithEol.slice(0, -1);
-        if (rawWithEol.endsWith('\r'))
-            rawWithEol = rawWithEol.slice(0, -1);
-        const raw = rawWithEol;
-        const lineNo = file.lineBaseLines?.[i] ?? i + 1;
-        const filePath = file.lineFiles?.[i] ?? sourcePath;
-        let segmentStart = 0;
-        let inChar = false;
-        let inString = false;
-        let escaped = false;
-        for (let j = 0; j < raw.length; j++) {
-            const ch = raw[j];
-            if (inChar || inString) {
-                if (escaped) {
-                    escaped = false;
-                    continue;
-                }
-                if (ch === '\\') {
-                    escaped = true;
-                    continue;
-                }
-                if (inChar && ch === "'") {
-                    inChar = false;
-                    continue;
-                }
-                if (inString && ch === '"') {
-                    inString = false;
-                    continue;
-                }
-                continue;
-            }
-            if (ch === ';') {
-                break;
-            }
-            if (ch === "'") {
-                inChar = true;
-                continue;
-            }
-            if (ch === '"') {
-                inString = true;
-                continue;
-            }
-            if (ch === '\\') {
-                const rest = raw.slice(j + 1);
-                const hasWhitespace = rest.length > 0 && /[ \t]/.test(rest[0]);
-                if (!hasWhitespace && rest.length > 0)
-                    continue;
-                const nonSpaceIndex = rest.search(/[^\s]/);
-                const nextToken = nonSpaceIndex >= 0 ? rest[nonSpaceIndex] : '';
-                if (nonSpaceIndex === -1 || nextToken === ';') {
-                    diag(diagnostics, filePath, 'Trailing backslash must be followed by another statement.', {
-                        line: lineNo,
-                        column: j + 1,
-                    });
-                    continue;
-                }
-                const segment = raw.slice(segmentStart, j);
-                logicalLines.push({
-                    raw: segment,
-                    startOffset: startOffset + segmentStart,
-                    endOffset: startOffset + j,
-                    lineNo,
-                    filePath,
-                });
-                segmentStart = j + 1;
-            }
-        }
-        logicalLines.push({
-            raw: raw.slice(segmentStart),
-            startOffset: startOffset + segmentStart,
-            endOffset: startOffset + raw.length,
-            lineNo,
-            filePath,
-        });
-    }
-    return logicalLines;
-}
-export function getLogicalLine(logicalLines, lineIndex, sourcePath) {
-    return (logicalLines[lineIndex] ?? {
-        raw: '',
-        startOffset: 0,
-        endOffset: 0,
-        lineNo: 1,
-        filePath: sourcePath,
-    });
-}

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

@@ -1,25 +0,0 @@
-import type { OpDeclNode, OpParamNode, SourceSpan } from './ast.js';
-import type { SourceFile } from './source.js';
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { ParseParamsContext } from './parseParams.js';
-type RawLine = {
-    raw: string;
-    startOffset: number;
-    endOffset: number;
-    lineNo: number;
-    filePath: string;
-};
-type ParseOpContext = {
-    file: SourceFile;
-    lineCount: number;
-    diagnostics: Diagnostic[];
-    sourcePath: string;
-    getRawLine: (lineIndex: number) => RawLine;
-    parseOpParamsFromText: (filePath: string, paramsText: string, paramsSpan: SourceSpan, diagnostics: Diagnostic[], ctx: ParseParamsContext) => OpParamNode[] | undefined;
-} & ParseParamsContext;
-type ParsedOpDecl = {
-    node: OpDeclNode;
-    nextIndex: number;
-};
-export declare function parseTopLevelOpDecl(opTail: string, stmtText: string, stmtSpan: SourceSpan, lineNo: number, startIndex: number, ctx: ParseOpContext): ParsedOpDecl | undefined;
-export {};

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

@@ -1,120 +0,0 @@
-import { span } from './source.js';
-import { parseDiag as diag } from './parseDiagnostics.js';
-import { appendParsedAsmStatement, parseAsmStatement } from './parseAsmStatements.js';
-import { topLevelStartKeyword } from './parseTopLevelCommon.js';
-import { stripLineComment as stripComment } from './parseParserShared.js';
-import { parseOpHeader } from './parseOpHeader.js';
-export function parseTopLevelOpDecl(opTail, stmtText, stmtSpan, lineNo, startIndex, ctx) {
-    const { file, lineCount, diagnostics, sourcePath, getRawLine, isReservedTopLevelName, parseOpParamsFromText, } = ctx;
-    const parsedHeader = parseOpHeader({
-        header: opTail,
-        stmtText,
-        stmtSpan,
-        lineNo,
-        diagnostics,
-        sourcePath,
-        expectedHeader: '<name>(...)',
-        isReservedTopLevelName,
-        parseParams: (paramsText) => parseOpParamsFromText(sourcePath, paramsText, stmtSpan, diagnostics, {
-            isReservedTopLevelName,
-        }),
-    });
-    if (!parsedHeader) {
-        return undefined;
-    }
-    const name = parsedHeader.name;
-    const params = parsedHeader.params;
-    const trailing = parsedHeader.trailing.trim();
-    if (trailing.length > 0) {
-        diag(diagnostics, sourcePath, `Invalid op header: unexpected trailing tokens`, {
-            line: lineNo,
-            column: 1,
-        });
-        return undefined;
-    }
-    const opStartOffset = stmtSpan.start.offset;
-    let index = startIndex + 1;
-    const bodyItems = [];
-    let terminated = false;
-    let interruptedByKeyword;
-    let interruptedByLine;
-    let interruptedByFilePath;
-    let opEndOffset = file.text.length;
-    while (index < lineCount) {
-        const { raw: rawLine, startOffset: so, endOffset: eo, lineNo: bodyLineNo, filePath: bodyFilePath, } = getRawLine(index);
-        const rawNoComment = stripComment(rawLine);
-        const content = rawNoComment.trim();
-        const contentLower = content.toLowerCase();
-        if (content.length === 0) {
-            index++;
-            continue;
-        }
-        if (bodyItems.length === 0 && contentLower === 'asm') {
-            diag(diagnostics, bodyFilePath, `Unexpected "asm" in op body (op bodies are implicit)`, {
-                line: bodyLineNo,
-                column: 1,
-            });
-            index++;
-            continue;
-        }
-        if (contentLower === 'end') {
-            terminated = true;
-            opEndOffset = eo;
-            index++;
-            break;
-        }
-        const topKeyword = topLevelStartKeyword(content);
-        if (topKeyword !== undefined) {
-            interruptedByKeyword = topKeyword;
-            interruptedByLine = bodyLineNo;
-            interruptedByFilePath = bodyFilePath;
-            break;
-        }
-        const fullSpan = span(file, so, eo);
-        const contentStart = rawNoComment.indexOf(content);
-        const contentSpan = contentStart >= 0 ? span(file, so + contentStart, so + rawNoComment.length) : fullSpan;
-        const labelMatch = /^([A-Za-z_][A-Za-z0-9_]*)\s*:(?!\=)\s*(.*)$/.exec(content);
-        if (labelMatch) {
-            const label = labelMatch[1];
-            const remainder = labelMatch[2] ?? '';
-            bodyItems.push({ kind: 'AsmLabel', span: fullSpan, name: label });
-            if (remainder.trim().length > 0) {
-                const stmt = parseAsmStatement(bodyFilePath, remainder, contentSpan, diagnostics);
-                appendParsedAsmStatement(bodyItems, stmt);
-            }
-            index++;
-            continue;
-        }
-        const stmt = parseAsmStatement(bodyFilePath, content, contentSpan, diagnostics);
-        appendParsedAsmStatement(bodyItems, stmt);
-        index++;
-    }
-    if (!terminated) {
-        if (interruptedByKeyword !== undefined && interruptedByLine !== undefined) {
-            diag(diagnostics, interruptedByFilePath ?? sourcePath, `Unterminated op "${name}": expected "end" before "${interruptedByKeyword}"`, {
-                line: interruptedByLine,
-                column: 1,
-            });
-        }
-        else {
-            diag(diagnostics, sourcePath, `Unterminated op "${name}": missing "end"`, {
-                line: lineNo,
-                column: 1,
-            });
-        }
-    }
-    return {
-        node: {
-            kind: 'OpDecl',
-            span: span(file, opStartOffset, opEndOffset),
-            name,
-            params,
-            body: {
-                kind: 'AsmBlock',
-                span: span(file, opStartOffset, opEndOffset),
-                items: bodyItems,
-            },
-        },
-        nextIndex: index,
-    };
-}

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

@@ -1,20 +0,0 @@
-import type { SourceSpan } from './ast.js';
-import type { Diagnostic } from '../diagnosticTypes.js';
-type ParsedOpHeader<TParam> = {
-    name: string;
-    params: TParam[];
-    trailing: string;
-};
-type ParseOpHeaderOptions<TParam> = {
-    header: string;
-    stmtText: string;
-    stmtSpan: SourceSpan;
-    lineNo: number;
-    diagnostics: Diagnostic[];
-    sourcePath: string;
-    expectedHeader: string;
-    isReservedTopLevelName: (name: string) => boolean;
-    parseParams: (paramsText: string) => TParam[] | undefined;
-};
-export declare function parseOpHeader<TParam>(options: ParseOpHeaderOptions<TParam>): ParsedOpHeader<TParam> | undefined;
-export {};