@jhlagado/azm 0.2.0 → 0.2.2

package/dist/src/core/compile.js

@@ -4,15 +4,18 @@ import { createSourceFile } from '../source/source-file.js';
 import { scanLogicalLines } from '../source/logical-lines.js';
 import { stripLineComment } from '../source/strip-line-comment.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
-import { parseTypeExpr } from '../syntax/parse-expression.js';
+import { parseExpression, parseTypeExpr } from '../syntax/parse-expression.js';
 import { collectOps, expandOpInvocation, parseOpInvocation } from '../expansion/op-expansion.js';
+import { normalizeDirectiveAlias } from '../syntax/directive-aliases.js';
+import { evaluateExpression, lookupEquateRecord, } from '../semantics/expression-evaluation.js';
 export function parseNextSourceItems(lines, options = {}) {
     const diagnostics = [];
     const items = [];
-    const pendingLines = [...lines];
     const parseOptions = options.directiveAliasPolicy === undefined
         ? {}
         : { directiveAliasPolicy: options.directiveAliasPolicy };
+    const conditional = applyConditionalAssembly(lines, diagnostics, parseOptions.directiveAliasPolicy);
+    const pendingLines = [...conditional.lines];
     const { ops, opLineIndexes } = collectOps(pendingLines, diagnostics, parseOptions);
     let afterTopLevelEnd = false;
     for (let index = 0; index < pendingLines.length; index += 1) {
@@ -23,9 +26,61 @@ export function parseNextSourceItems(lines, options = {}) {
         if (afterTopLevelEnd && !isPostEndParseAllowed(line.text)) {
             continue;
         }
-        const layoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i.exec(stripLineComment(line.text).trim());
+        const colonLayoutHeader = /^([A-Za-z_][A-Za-z0-9_]*):\s*\.(type|union)\s*$/.exec(stripLineComment(line.text).trim());
+        if (colonLayoutHeader) {
+            const directive = colonLayoutHeader[2] ?? 'type';
+            diagnostics.push(parseDiagnostic(line, `Use "${colonLayoutHeader[1] ?? ''} .${directive}" for layouts; colon labels mark addresses.`));
+            const endDirective = directive === 'union' ? '.endunion' : '.endtype';
+            for (index += 1; index < pendingLines.length; index += 1) {
+                if (stripLineComment(pendingLines[index].text).trim() === endDirective) {
+                    break;
+                }
+            }
+            continue;
+        }
+        const nameLeftTypeAlias = /^([A-Za-z_][A-Za-z0-9_]*)\s+\.typealias\s+(.+)$/.exec(stripLineComment(line.text).trim());
+        if (nameLeftTypeAlias) {
+            const typeExprText = nameLeftTypeAlias[2] ?? '';
+            const typeExpr = parseTypeExpr(typeExprText);
+            if (!typeExpr) {
+                diagnostics.push(parseDiagnostic(line, `invalid .typealias target: ${typeExprText}`));
+            }
+            else {
+                items.push({
+                    kind: 'type-alias',
+                    name: nameLeftTypeAlias[1] ?? '',
+                    typeExpr,
+                    span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+                });
+            }
+            continue;
+        }
+        const typeAlias = /^\.type\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/.exec(stripLineComment(line.text).trim());
+        if (typeAlias) {
+            diagnostics.push(parseDiagnostic(line, `Use "${typeAlias[1] ?? ''} .typealias ..." for type aliases.`));
+            continue;
+        }
+        const nameLeftLayoutHeader = /^([A-Za-z_][A-Za-z0-9_]*)\s+\.(type|union)\s*$/.exec(stripLineComment(line.text).trim());
+        const prefixLayoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/.exec(stripLineComment(line.text).trim());
+        if (prefixLayoutHeader) {
+            const directive = prefixLayoutHeader[1] ?? 'type';
+            diagnostics.push(parseDiagnostic(line, `Use "${prefixLayoutHeader[2] ?? ''} .${directive}" for layouts.`));
+            const endDirective = directive === 'union' ? '.endunion' : '.endtype';
+            for (index += 1; index < pendingLines.length; index += 1) {
+                if (stripLineComment(pendingLines[index].text).trim() === endDirective) {
+                    break;
+                }
+            }
+            continue;
+        }
+        const layoutHeader = nameLeftLayoutHeader
+            ? {
+                directive: nameLeftLayoutHeader[2] ?? '',
+                name: nameLeftLayoutHeader[1] ?? '',
+            }
+            : undefined;
         if (layoutHeader) {
-            const layoutKind = (layoutHeader[1] ?? '').toLowerCase() === 'union' ? 'union' : 'record';
+            const layoutKind = layoutHeader.directive === 'union' ? 'union' : 'record';
             const endDirective = layoutKind === 'union' ? '.endunion' : '.endtype';
             const fields = [];
             let terminated = false;
@@ -35,23 +90,23 @@ export function parseNextSourceItems(lines, options = {}) {
                 if (fieldText.length === 0) {
                     continue;
                 }
-                if (fieldText.toLowerCase() === endDirective) {
+                if (fieldText === endDirective) {
                     terminated = true;
                     break;
                 }
                 const field = parseLayoutField(fieldText);
                 if (!field) {
-                    diagnostics.push(parseDiagnostic(fieldLine, `invalid .${layoutHeader[1]} field declaration`));
+                    diagnostics.push(parseDiagnostic(fieldLine, `invalid .${layoutHeader.directive} field declaration`));
                     continue;
                 }
                 fields.push(field);
             }
             if (!terminated) {
-                diagnostics.push(parseDiagnostic(line, `.${layoutHeader[1] ?? ''} ${layoutHeader[2] ?? ''} missing ${endDirective}`));
+                diagnostics.push(parseDiagnostic(line, `.${layoutHeader.directive} ${layoutHeader.name} missing ${endDirective}`));
             }
             items.push({
                 kind: 'type',
-                name: layoutHeader[2] ?? '',
+                name: layoutHeader.name,
                 layoutKind,
                 fields,
                 span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
@@ -78,6 +133,134 @@ export function parseNextSourceItems(lines, options = {}) {
     }
     return { diagnostics, items };
 }
+function applyConditionalAssembly(lines, diagnostics, directiveAliasPolicy) {
+    const out = [];
+    const equates = new Map();
+    const locationDependentEquates = new Set();
+    const stack = [];
+    for (const line of lines) {
+        const text = stripLineComment(line.text).trim();
+        const ifDirective = /^\.if\s+(.+)$/.exec(text);
+        if (ifDirective) {
+            const parentActive = conditionalActive(stack);
+            const expressionText = ifDirective[1] ?? '';
+            const value = parentActive
+                ? evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics)
+                : undefined;
+            const conditionActive = parentActive && value !== undefined && value !== 0;
+            stack.push({ line, parentActive, conditionActive, elseSeen: false });
+            continue;
+        }
+        if (/^\.else\s*$/.test(text)) {
+            const frame = stack.pop();
+            if (!frame) {
+                diagnostics.push(parseDiagnostic(line, 'unmatched .else'));
+                continue;
+            }
+            if (frame.elseSeen) {
+                diagnostics.push(parseDiagnostic(line, 'duplicate .else'));
+            }
+            stack.push({
+                line: frame.line,
+                parentActive: frame.parentActive,
+                conditionActive: frame.parentActive && !frame.conditionActive,
+                elseSeen: true,
+            });
+            continue;
+        }
+        if (/^\.endif\s*$/.test(text)) {
+            if (!stack.pop()) {
+                diagnostics.push(parseDiagnostic(line, 'unmatched .endif'));
+            }
+            continue;
+        }
+        if (!conditionalActive(stack)) {
+            continue;
+        }
+        out.push(line);
+        recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy);
+    }
+    for (const frame of stack) {
+        diagnostics.push(parseDiagnostic(frame.line, 'unterminated .if'));
+    }
+    return { lines: out };
+}
+function conditionalActive(stack) {
+    return stack.every((frame) => frame.parentActive && frame.conditionActive);
+}
+function evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics) {
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        diagnostics.push(parseDiagnostic(line, `invalid .if expression: ${expressionText}`));
+        return undefined;
+    }
+    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
+        diagnostics.push(parseDiagnostic(line, 'invalid .if expression: current location is not available during conditional assembly'));
+        return undefined;
+    }
+    return evaluateExpression(expression, {}, equates, { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) }, diagnostics, { currentLocation: 0 });
+}
+function recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy) {
+    const text = normalizeDirectiveAlias(stripLineComment(line.text), directiveAliasPolicy).trim();
+    const statement = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):\s*(.+)$/.exec(text);
+    if (statement && /^\.equ\b/.test(statement[2] ?? '')) {
+        return;
+    }
+    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/.exec(text);
+    if (!equ) {
+        return;
+    }
+    const name = equ[1] ?? '';
+    const expressionText = equ[2] ?? '';
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        return;
+    }
+    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
+        locationDependentEquates.add(canonicalConditionalSymbolKey(name));
+    }
+    equates.set(name, {
+        expression,
+        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+        currentLocation: 0,
+    });
+}
+function expressionReferencesCurrentLocation(expression, equates, locationDependentEquates, visiting = new Set()) {
+    switch (expression.kind) {
+        case 'current-location':
+            return true;
+        case 'symbol': {
+            if (locationDependentEquates.has(canonicalConditionalSymbolKey(expression.name))) {
+                return true;
+            }
+            const lookup = lookupEquateRecord(equates, expression.name);
+            if (!lookup || visiting.has(canonicalConditionalSymbolKey(lookup.key))) {
+                return false;
+            }
+            const nextVisiting = new Set(visiting);
+            nextVisiting.add(canonicalConditionalSymbolKey(lookup.key));
+            return expressionReferencesCurrentLocation(lookup.record.expression, equates, locationDependentEquates, nextVisiting);
+        }
+        case 'byte-function':
+        case 'unary':
+            return expressionReferencesCurrentLocation(expression.expression, equates, locationDependentEquates, visiting);
+        case 'binary':
+            return (expressionReferencesCurrentLocation(expression.left, equates, locationDependentEquates, visiting) ||
+                expressionReferencesCurrentLocation(expression.right, equates, locationDependentEquates, visiting));
+        case 'layout-cast':
+            return (expressionReferencesCurrentLocation(expression.base, equates, locationDependentEquates, visiting) ||
+                expression.path.some((part) => part.kind === 'index' &&
+                    expressionReferencesCurrentLocation(part.expression, equates, locationDependentEquates, visiting)));
+        case 'number':
+        case 'type-size':
+        case 'sizeof':
+        case 'offset':
+            return false;
+    }
+}
+function canonicalConditionalSymbolKey(name) {
+    return name.toLowerCase();
+}
 export function compileSource(sourceText, options = {}) {
     const source = createSourceFile(options.entryName ?? '<memory>', sourceText);
     const { diagnostics, items } = parseNextSourceItems(scanLogicalLines(source));
@@ -107,7 +290,7 @@ function isPostEndParseAllowed(text) {
     return /^(?:\.binfrom|\.binto|binfrom|binto)\b/i.test(stripLineComment(text).trim());
 }
 function parseLayoutField(text) {
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/i.exec(text);
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/.exec(text);
     if (!match) {
         return undefined;
     }

package/dist/src/expansion/op-expansion.js

@@ -663,9 +663,11 @@ function renameSourceItem(item, localLabelMap) {
                 ...item,
                 instruction: renameInstructionExpressions(item.instruction, localLabelMap),
             };
+        case 'comment':
         case 'end':
         case 'enum':
         case 'type':
+        case 'type-alias':
         case 'string-data':
             return item;
     }

package/dist/src/model/expression.d.ts

@@ -12,6 +12,10 @@ export type Expression = {
 } | {
     readonly kind: 'sizeof';
     readonly typeExpr: TypeExpr;
+} | {
+    readonly kind: 'byte-function';
+    readonly function: 'LSB' | 'MSB';
+    readonly expression: Expression;
 } | {
     readonly kind: 'offset';
     readonly typeExpr: TypeExpr;

package/dist/src/model/source-item.d.ts

@@ -14,6 +14,12 @@ export type SourceItem = {
 } | {
     readonly kind: 'label';
     readonly name: string;
+    readonly isEntry?: boolean;
+    readonly span: SourceSpan;
+} | {
+    readonly kind: 'comment';
+    readonly text: string;
+    readonly origin: 'user' | 'generated';
     readonly span: SourceSpan;
 } | {
     readonly kind: 'db';
@@ -54,6 +60,11 @@ export type SourceItem = {
     readonly layoutKind: 'record' | 'union';
     readonly fields: readonly LayoutField[];
     readonly span: SourceSpan;
+} | {
+    readonly kind: 'type-alias';
+    readonly name: string;
+    readonly typeExpr: TypeExpr;
+    readonly span: SourceSpan;
 } | {
     readonly kind: 'string-data';
     readonly directive: 'cstr' | 'pstr' | 'istr';

package/dist/src/outputs/index.js

@@ -1,13 +1,11 @@
 import { writeBin } from './write-bin.js';
 import { writeD8m } from './write-d8.js';
 import { writeHex } from './write-hex.js';
-import { writeListing } from './write-listing.js';
 import { writeAsm80 } from './write-asm80.js';
 /** Default in-memory writers for Stage 12 compile API. */
 export const defaultFormatWriters = {
     writeBin,
     writeHex,
     writeD8m,
-    writeListing,
     writeAsm80,
 };

package/dist/src/outputs/types.d.ts

@@ -21,7 +21,7 @@ export interface EmittedSourceSegment {
     kind: D8mSegmentKind;
     confidence: D8mSegmentConfidence;
 }
-/** Symbol metadata shared by listing and D8 writers. */
+/** Symbol metadata shared by output writers. */
 export type SymbolEntry = {
     kind: 'label' | 'data';
     name: string;
@@ -50,12 +50,6 @@ export interface HexArtifact {
     path?: string;
     text: string;
 }
-/** Listing artifact. */
-export interface ListingArtifact {
-    kind: 'lst';
-    path?: string;
-    text: string;
-}
 /** In-memory register-care audit report artifact. */
 export interface RegisterCareReportArtifact {
     kind: 'register-care-report';
@@ -122,7 +116,6 @@ export interface D8mGenerator {
     version?: string;
     inputs?: {
         entry?: string;
-        listing?: string;
         hex?: string;
         bin?: string;
     };
@@ -153,16 +146,11 @@ export interface WriteBinOptions {
     binFrom?: number;
     startAddress?: number;
 }
-export interface WriteListingOptions {
-    lineEnding?: '\n' | '\r\n';
-    bytesPerLine?: number;
-}
 export interface WriteD8mOptions {
     rootDir?: string;
     packageVersion?: string;
     inputs?: {
         entry?: string;
-        listing?: string;
         hex?: string;
         bin?: string;
     };
@@ -171,12 +159,11 @@ export interface WriteD8mOptions {
 }
 export interface WriteAsm80Options {
 }
-export type Artifact = BinArtifact | HexArtifact | ListingArtifact | D8mArtifact | Asm80Artifact | RegisterCareReportArtifact | RegisterCareInterfaceArtifact | RegisterCareAnnotationsArtifact;
-/** Writer contract used by the Stage 12 compile API. */
+export type Artifact = BinArtifact | HexArtifact | D8mArtifact | Asm80Artifact | RegisterCareReportArtifact | RegisterCareInterfaceArtifact | RegisterCareAnnotationsArtifact;
+/** Writer contract used by the compile API. */
 export interface FormatWriters {
     writeHex(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteHexOptions): HexArtifact;
     writeBin(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteBinOptions): BinArtifact;
     writeD8m(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteD8mOptions): D8mArtifact;
-    writeListing?(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteListingOptions): ListingArtifact;
     writeAsm80?(items: readonly SourceItem[], symbols: readonly SymbolEntry[], opts?: WriteAsm80Options): Asm80Artifact;
 }