@jhlagado/azm 0.2.1 → 0.2.2

package/dist/src/outputs/write-asm80.js

@@ -14,6 +14,7 @@ export function writeAsm80(items, symbols, opts = {}) {
     void opts;
     const evalContext = {
         constants: collectConstants(symbols),
+        symbols: collectSymbolValues(symbols),
         layouts: collectLayouts(items),
     };
     const lines = [asm80Header, ''];
@@ -43,6 +44,13 @@ function collectConstants(symbols) {
     }
     return constants;
 }
+function collectSymbolValues(symbols) {
+    const values = new Map();
+    for (const symbol of symbols) {
+        values.set(symbol.name, symbol.kind === 'constant' ? symbol.value : symbol.address);
+    }
+    return values;
+}
 function collectLayouts(items) {
     const layouts = new Map();
     for (const item of items) {
@@ -53,6 +61,13 @@ function collectLayouts(items) {
                 span: item.span,
             });
         }
+        else if (item.kind === 'type-alias') {
+            layouts.set(item.name, {
+                kind: 'alias',
+                typeExpr: item.typeExpr,
+                span: item.span,
+            });
+        }
     }
     return layouts;
 }
@@ -95,6 +110,7 @@ function formatItem(item, evalContext, state) {
             return withImplicitOrg(state, formatInstruction(item.instruction, evalContext)?.text, instructionSize(item.instruction));
         case 'enum':
         case 'type':
+        case 'type-alias':
         case 'end':
         case 'binfrom':
         case 'binto':
@@ -497,12 +513,20 @@ function evaluateLoweredConstant(expression, evalContext) {
                 reportUnknown: false,
             });
         }
+        case 'offset':
         case 'sizeof':
             return evaluateExpression(expression, {}, new Map(), silentSpan, [], {
                 currentLocation: 0,
                 layouts: evalContext.layouts,
                 reportUnknown: false,
             });
+        case 'byte-function': {
+            const value = evaluateLoweredResolvedConstant(expression.expression, evalContext);
+            if (value === undefined) {
+                return undefined;
+            }
+            return expression.function === 'LSB' ? value & 0xff : (value >> 8) & 0xff;
+        }
         case 'unary': {
             const value = evaluateLoweredConstant(expression.expression, evalContext);
             if (value === undefined) {
@@ -552,6 +576,66 @@ function evaluateLoweredConstant(expression, evalContext) {
             return undefined;
     }
 }
+function evaluateLoweredResolvedConstant(expression, evalContext) {
+    switch (expression.kind) {
+        case 'symbol':
+            return evalContext.symbols.get(expression.name);
+        case 'unary': {
+            const value = evaluateLoweredResolvedConstant(expression.expression, evalContext);
+            if (value === undefined) {
+                return undefined;
+            }
+            switch (expression.operator) {
+                case '+':
+                    return value;
+                case '-':
+                    return -value;
+                case '~':
+                    return ~value;
+            }
+            break;
+        }
+        case 'binary': {
+            const left = evaluateLoweredResolvedConstant(expression.left, evalContext);
+            const right = evaluateLoweredResolvedConstant(expression.right, evalContext);
+            if (left === undefined || right === undefined) {
+                return undefined;
+            }
+            switch (expression.operator) {
+                case '+':
+                    return left + right;
+                case '-':
+                    return left - right;
+                case '*':
+                    return left * right;
+                case '/':
+                    return right === 0 ? undefined : Math.trunc(left / right);
+                case '%':
+                    return right === 0 ? undefined : left % right;
+                case '&':
+                    return left & right;
+                case '^':
+                    return left ^ right;
+                case '|':
+                    return left | right;
+                case '<<':
+                    return left << right;
+                case '>>':
+                    return left >> right;
+            }
+            break;
+        }
+        case 'byte-function': {
+            const value = evaluateLoweredResolvedConstant(expression.expression, evalContext);
+            if (value === undefined) {
+                return undefined;
+            }
+            return expression.function === 'LSB' ? value & 0xff : (value >> 8) & 0xff;
+        }
+        default:
+            return evaluateLoweredConstant(expression, evalContext);
+    }
+}
 function formatLoweredNumber(value, width) {
     const normalized = value < 0 ? 0x10000 + (value & 0xffff) : value;
     const digits = normalized.toString(16).toUpperCase();

package/dist/src/semantics/expression-evaluation.d.ts

@@ -1,5 +1,5 @@
 import type { Diagnostic } from '../model/diagnostic.js';
-import type { Expression } from '../model/expression.js';
+import type { Expression, TypeExpr } from '../model/expression.js';
 import type { LayoutField } from '../model/source-item.js';
 import type { SourceSpan } from '../source/source-span.js';
 export interface EquateRecord {
@@ -9,11 +9,15 @@ export interface EquateRecord {
     readonly enumMember?: boolean;
     readonly stringValue?: string;
 }
-export interface LayoutRecord {
+export type LayoutRecord = {
     readonly kind: 'record' | 'union';
     readonly fields: readonly LayoutField[];
     readonly span: SourceSpan;
-}
+} | {
+    readonly kind: 'alias';
+    readonly typeExpr: TypeExpr;
+    readonly span: SourceSpan;
+};
 export declare function lookupEquateRecord(equates: ReadonlyMap<string, EquateRecord>, name: string): {
     readonly key: string;
     readonly record: EquateRecord;

package/dist/src/semantics/expression-evaluation.js

@@ -39,6 +39,8 @@ export function evaluateExpression(expression, labels, equates, span, diagnostic
             return evaluateTypeSize(expression.typeExpr, labels, equates, span, diagnostics, options);
         case 'sizeof':
             return evaluateSizeof(expression.typeExpr, options.layouts, span, diagnostics);
+        case 'byte-function':
+            return evaluateByteFunction(expression, labels, equates, span, diagnostics, options);
         case 'offset':
             return evaluateOffset(expression.typeExpr, expression.path, options.layouts, span, diagnostics);
         case 'layout-cast':
@@ -51,6 +53,13 @@ export function evaluateExpression(expression, labels, equates, span, diagnostic
             return evaluateBinary(expression, labels, equates, span, diagnostics, options);
     }
 }
+function evaluateByteFunction(expression, labels, equates, span, diagnostics, options) {
+    const value = evaluateExpression(expression.expression, labels, equates, span, diagnostics, options);
+    if (value === undefined) {
+        return undefined;
+    }
+    return expression.function === 'LSB' ? value & 0xff : (value >> 8) & 0xff;
+}
 function evaluateTypeSize(typeExpr, labels, equates, span, diagnostics, options) {
     if (options.layouts) {
         const sizeDiagnostics = [];
@@ -146,6 +155,13 @@ function evaluateOffset(typeExpr, path, layouts, span, diagnostics) {
     return undefined;
 }
 function typeExprSize(typeExpr, layouts, span, diagnostics, visiting) {
+    const resolvedTypeExpr = resolveLayoutAlias(typeExpr, layouts, span, diagnostics, visiting);
+    if (!resolvedTypeExpr) {
+        return undefined;
+    }
+    if (resolvedTypeExpr !== typeExpr) {
+        return typeExprSize(resolvedTypeExpr, layouts, span, diagnostics, visiting);
+    }
     const scalar = scalarSize(typeExpr.name);
     const baseSize = scalar ??
         (() => {
@@ -162,6 +178,9 @@ function typeExprSize(typeExpr, layouts, span, diagnostics, visiting) {
     return typeExpr.length === undefined ? baseSize : baseSize * typeExpr.length;
 }
 function layoutSize(typeName, layout, layouts, span, diagnostics, visiting) {
+    if (layout.kind === 'alias') {
+        return typeExprSize(layout.typeExpr, layouts, span, diagnostics, visiting);
+    }
     const fieldSizes = [];
     for (const field of layout.fields) {
         const size = fieldSize(field, layouts, span, diagnostics, visiting);
@@ -187,6 +206,13 @@ function fieldSize(field, layouts, span, diagnostics, visiting) {
     return typeExprSize(field.typeExpr, layouts, span, diagnostics, new Set([...visiting, field.typeExpr.name]));
 }
 function offsetPath(typeExpr, parts, layouts, span, diagnostics) {
+    const resolvedTypeExpr = resolveLayoutAlias(typeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+    if (!resolvedTypeExpr) {
+        return undefined;
+    }
+    if (resolvedTypeExpr !== typeExpr) {
+        return offsetPath(resolvedTypeExpr, parts, layouts, span, diagnostics);
+    }
     const [head, ...tail] = parts;
     if (head === undefined) {
         return undefined;
@@ -218,6 +244,9 @@ function offsetPath(typeExpr, parts, layouts, span, diagnostics) {
         diagnostics.push(diagnostic(span, `unknown type: ${typeExpr.name}`));
         return undefined;
     }
+    if (layout.kind === 'alias') {
+        return offsetPath(layout.typeExpr, parts, layouts, span, diagnostics);
+    }
     let currentOffset = 0;
     for (const field of layout.fields) {
         const fieldOffset = layout.kind === 'union' ? 0 : currentOffset;
@@ -246,6 +275,13 @@ function offsetPath(typeExpr, parts, layouts, span, diagnostics) {
     return undefined;
 }
 function layoutCastOffset(typeExpr, parts, labels, equates, layouts, span, diagnostics, options) {
+    const resolvedTypeExpr = resolveLayoutAlias(typeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+    if (!resolvedTypeExpr) {
+        return undefined;
+    }
+    if (resolvedTypeExpr !== typeExpr) {
+        return layoutCastOffset(resolvedTypeExpr, parts, labels, equates, layouts, span, diagnostics, options);
+    }
     const [head, ...tail] = parts;
     if (head === undefined) {
         return 0;
@@ -286,6 +322,9 @@ function layoutCastOffset(typeExpr, parts, labels, equates, layouts, span, diagn
         diagnostics.push(diagnostic(span, `unknown type: ${typeExpr.name}`));
         return undefined;
     }
+    if (layout.kind === 'alias') {
+        return layoutCastOffset(layout.typeExpr, parts, labels, equates, layouts, span, diagnostics, options);
+    }
     let currentOffset = 0;
     for (const field of layout.fields) {
         const fieldOffset = layout.kind === 'union' ? 0 : currentOffset;
@@ -330,6 +369,24 @@ function registerIndexName(expression) {
 function formatTypeExpr(typeExpr) {
     return typeExpr.length === undefined ? typeExpr.name : `${typeExpr.name}[${typeExpr.length}]`;
 }
+function resolveLayoutAlias(typeExpr, layouts, span, diagnostics, visiting) {
+    const layout = layouts.get(typeExpr.name);
+    if (!layout || layout.kind !== 'alias') {
+        return typeExpr;
+    }
+    if (visiting.has(layout.typeExpr.name)) {
+        diagnostics.push(diagnostic(span, `recursive type: ${typeExpr.name}`));
+        return undefined;
+    }
+    const target = resolveLayoutAlias(layout.typeExpr, layouts, span, diagnostics, new Set([...visiting, layout.typeExpr.name]));
+    if (!target) {
+        return undefined;
+    }
+    const length = typeExpr.length === undefined
+        ? target.length
+        : (target.length ?? 1) * typeExpr.length;
+    return length === undefined ? { name: target.name } : { name: target.name, length };
+}
 function formatOffsetPath(path) {
     return path.map((part) => (part.kind === 'field' ? part.name : `[${part.index}]`)).join('.');
 }

package/dist/src/syntax/directive-aliases.js

@@ -160,14 +160,14 @@ export function normalizeDirectiveAlias(text, policy = DEFAULT_DIRECTIVE_ALIAS_P
     if (label) {
         return `${leading}${label[1]} ${normalizeHead(label[2] ?? '', policy)}`;
     }
-    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+([A-Za-z]+)\b(.*)$/.exec(trimmed);
+    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+([A-Za-z][A-Za-z0-9_]*)\b(.*)$/.exec(trimmed);
     if (equ && resolveDirectiveAlias(equ[2] ?? '', policy) === '.equ') {
         return `${leading}${equ[1]} .equ${equ[3] ?? ''}`;
     }
     return `${leading}${normalizeHead(trimmed, policy)}`;
 }
 function normalizeHead(text, policy) {
-    const head = /^([A-Za-z]+)\b(.*)$/.exec(text);
+    const head = /^([A-Za-z][A-Za-z0-9_]*)\b(.*)$/.exec(text);
     if (!head) {
         return text;
     }
@@ -181,7 +181,7 @@ function normalizeAliasKey(key) {
     const trimmed = key.trim();
     if (!/^[.]?[A-Za-z][A-Za-z0-9_]*$/.test(trimmed))
         return undefined;
-    return trimmed.replace(/^\./, '').toUpperCase();
+    return trimmed.replace(/^\./, '');
 }
 function normalizeAliasTarget(value) {
     const trimmed = value.trim().toLowerCase();
@@ -189,11 +189,10 @@ function normalizeAliasTarget(value) {
     return CANONICAL_DIRECTIVES.has(dotted) ? dotted : undefined;
 }
 function resolveDirectiveAlias(head, policy) {
-    const key = normalizeAliasKey(head);
-    if (!key)
-        return undefined;
-    const dotted = `.${key.toLowerCase()}`;
-    if (head.trim().startsWith('.') && CANONICAL_DIRECTIVES.has(dotted))
-        return dotted;
-    return policy.directiveAliases.get(key);
+    const trimmed = head.trim();
+    if (trimmed.startsWith('.')) {
+        return CANONICAL_DIRECTIVES.has(trimmed) ? trimmed : undefined;
+    }
+    const key = head.trim();
+    return /^[A-Za-z][A-Za-z0-9_]*$/.test(key) ? policy.directiveAliases.get(key) : undefined;
 }

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

@@ -36,7 +36,7 @@ export function parseExpression(text) {
         }
         if (token.kind === 'symbol') {
             const next = tokenList[index + 1];
-            if (token.text.toLowerCase() === 'sizeof' && next?.kind === 'left-paren') {
+            if (token.text === 'sizeof' && next?.kind === 'left-paren') {
                 index += 2;
                 const typeName = tokenList[index];
                 if (typeName?.kind !== 'symbol' || tokenList[index + 1]?.kind !== 'right-paren') {
@@ -45,7 +45,7 @@ export function parseExpression(text) {
                 index += 2;
                 return { kind: 'sizeof', typeExpr: { name: typeName.text } };
             }
-            if (token.text.toLowerCase() === 'offset' && next?.kind === 'left-paren') {
+            if (token.text === 'offset' && next?.kind === 'left-paren') {
                 index += 2;
                 const typeName = tokenList[index];
                 const comma = tokenList[index + 1];
@@ -133,12 +133,12 @@ function parseLayoutExpression(text) {
     if (layoutCast) {
         return layoutCast;
     }
-    const sizeof = /^sizeof\s*\((.*)\)$/i.exec(trimmed);
+    const sizeof = /^sizeof\s*\((.*)\)$/.exec(trimmed);
     if (sizeof) {
         const typeExpr = parseTypeExpr(sizeof[1] ?? '');
         return typeExpr ? { kind: 'sizeof', typeExpr } : undefined;
     }
-    const offset = /^offset\s*\((.*),(.*)\)$/i.exec(trimmed);
+    const offset = /^offset\s*\((.*),(.*)\)$/.exec(trimmed);
     if (offset) {
         const typeExpr = parseTypeExpr(offset[1] ?? '');
         const path = parseOffsetPath(offset[2] ?? '');
@@ -317,7 +317,7 @@ function tokenizeExpression(text) {
             index += 1;
             continue;
         }
-        if (char === "'" || char === '"') {
+        if (char === "'") {
             const quoted = scanQuotedByte(input, index, char);
             if (!quoted) {
                 return undefined;
@@ -326,7 +326,7 @@ function tokenizeExpression(text) {
             index = quoted.end;
             continue;
         }
-        const layoutTerm = scanLayoutTerm(input, index);
+        const layoutTerm = scanSpecialTerm(input, index);
         if (layoutTerm) {
             tokens.push({ kind: 'expression', expression: layoutTerm.expression });
             index = layoutTerm.end;
@@ -353,9 +353,34 @@ function tokenizeExpression(text) {
     }
     return tokens.length > 0 ? tokens : undefined;
 }
+function scanSpecialTerm(input, start) {
+    const byteFunction = scanByteFunction(input, start);
+    if (byteFunction) {
+        return byteFunction;
+    }
+    return scanLayoutTerm(input, start);
+}
+function scanByteFunction(input, start) {
+    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 = parseExpression(input.slice(open + 1, close));
+    return expression
+        ? { expression: { kind: 'byte-function', function: name, expression }, end: close + 1 }
+        : undefined;
+}
 function scanLayoutTerm(input, start) {
-    const lower = input.slice(start).toLowerCase();
-    if (lower.startsWith('sizeof')) {
+    if (input.slice(start).startsWith('sizeof')) {
         const open = input.indexOf('(', start + 'sizeof'.length);
         if (open === -1 || input.slice(start + 'sizeof'.length, open).trim().length > 0) {
             return undefined;
@@ -367,7 +392,7 @@ function scanLayoutTerm(input, start) {
         const expression = parseLayoutExpression(input.slice(start, close + 1));
         return expression ? { expression, end: close + 1 } : undefined;
     }
-    if (lower.startsWith('offset')) {
+    if (input.slice(start).startsWith('offset')) {
         const open = input.indexOf('(', start + 'offset'.length);
         if (open === -1 || input.slice(start + 'offset'.length, open).trim().length > 0) {
             return undefined;

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

@@ -14,9 +14,9 @@ export function parseLogicalLine(line, options = {}) {
         const labelName = normalizeEntryLabelName(rawLabel);
         const isEntry = rawLabel.startsWith('@');
         const statementText = labelWithStatement[2] ?? '';
-        const equStatement = parseColonLabelEqu(line, labelName, statementText, span);
-        if (equStatement) {
-            return equStatement;
+        const invalidDeclaration = parseColonDeclarationError(labelName, statementText);
+        if (invalidDeclaration) {
+            return { items: [], diagnostics: [parseError(line, invalidDeclaration)] };
         }
         const parsedStatement = parseCanonicalStatement(line, statementText, span);
         return withLineComment(line, {
@@ -86,6 +86,13 @@ function withLineComment(line, result) {
 }
 function parseEquItem(line, name, expressionText, span) {
     const stringValue = parseWholeQuotedString(expressionText.trim());
+    const quotePolicyError = parseEquQuotePolicyError(expressionText.trim());
+    if (quotePolicyError) {
+        return {
+            items: [],
+            diagnostics: [parseError(line, quotePolicyError)],
+        };
+    }
     const expression = stringValue !== undefined && stringValue.length > 1
         ? { kind: 'number', value: 0 }
         : parseExpression(expressionText);
@@ -108,19 +115,12 @@ function parseEquItem(line, name, expressionText, span) {
         diagnostics: [],
     };
 }
-function parseColonLabelEqu(line, name, text, span) {
-    const equ = /^\.equ\s+(.+)$/i.exec(text);
-    if (!equ) {
-        return undefined;
-    }
-    return parseEquItem(line, name, equ[1] ?? '', span);
-}
 function parseCanonicalStatement(line, text, span) {
-    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/i.exec(text);
+    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+(.+)$/i.exec(text);
+    const org = /^\.org\s+(.+)$/.exec(text);
     if (org) {
         const expressionText = org[1] ?? '';
         const expression = parseExpression(expressionText);
@@ -132,32 +132,18 @@ function parseCanonicalStatement(line, text, span) {
         }
         return { items: [{ kind: 'org', expression, span }], diagnostics: [] };
     }
-    const enumDecl = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/i.exec(text);
+    const enumDecl = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/.exec(text);
     if (enumDecl) {
-        const name = enumDecl[1] ?? '';
-        const membersText = enumDecl[2] ?? '';
-        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: [] };
+        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+(.+)$/i.exec(text);
+    const data = /^(\.db|\.dw)\s+(.+)$/.exec(text);
     if (data) {
         const directive = (data[1] ?? '').slice(1).toLowerCase();
         const valueText = data[2] ?? '';
@@ -166,9 +152,10 @@ function parseCanonicalStatement(line, text, span) {
             ? parts.map(parseDataValue).filter((value) => value !== undefined)
             : parts.map(parseExpression).filter((value) => value !== undefined);
         if (values.length !== parts.length) {
+            const quotePolicyError = parts.map(parseDataQuotePolicyError).find(Boolean);
             return {
                 items: [],
-                diagnostics: [parseError(line, `invalid .${directive} value list`)],
+                diagnostics: [parseError(line, quotePolicyError ?? `invalid .${directive} value list`)],
             };
         }
         return {
@@ -178,7 +165,7 @@ function parseCanonicalStatement(line, text, span) {
             diagnostics: [],
         };
     }
-    const ds = /^\.ds\s+(.+)$/i.exec(text);
+    const ds = /^\.ds\s+(.+)$/.exec(text);
     if (ds) {
         const parts = splitValueList(ds[1] ?? '');
         if (parts.length < 1 || parts.length > 2) {
@@ -208,7 +195,7 @@ function parseCanonicalStatement(line, text, span) {
             diagnostics: [],
         };
     }
-    const align = /^\.align\s+(.+)$/i.exec(text);
+    const align = /^\.align\s+(.+)$/.exec(text);
     if (align) {
         const expressionText = align[1] ?? '';
         const alignment = parseExpression(expressionText);
@@ -220,10 +207,10 @@ function parseCanonicalStatement(line, text, span) {
         }
         return { items: [{ kind: 'align', alignment, span }], diagnostics: [] };
     }
-    if (/^\.end\s*$/i.test(text)) {
+    if (/^\.end\s*$/.test(text)) {
         return { items: [{ kind: 'end', span }], diagnostics: [] };
     }
-    const rangeControl = /^(\.binfrom|\.binto)\s+(.+)$/i.exec(text);
+    const rangeControl = /^(\.binfrom|\.binto)\s+(.+)$/.exec(text);
     if (rangeControl) {
         const kind = (rangeControl[1] ?? '').slice(1).toLowerCase();
         const expressionText = rangeControl[2] ?? '';
@@ -236,7 +223,7 @@ function parseCanonicalStatement(line, text, span) {
         }
         return { items: [{ kind, expression, span }], diagnostics: [] };
     }
-    const stringData = /^(\.cstr|\.pstr|\.istr)\s+(.+)$/i.exec(text);
+    const stringData = /^(\.cstr|\.pstr|\.istr)\s+(.+)$/.exec(text);
     if (stringData) {
         const directive = (stringData[1] ?? '').slice(1).toLowerCase();
         const valueText = stringData[2] ?? '';
@@ -244,7 +231,7 @@ function parseCanonicalStatement(line, text, span) {
         if (value === undefined) {
             return {
                 items: [],
-                diagnostics: [parseError(line, `.${directive} expects one quoted string`)],
+                diagnostics: [parseError(line, `.${directive} expects one double-quoted string`)],
             };
         }
         return { items: [{ kind: 'string-data', directive, value, span }], diagnostics: [] };
@@ -267,6 +254,46 @@ function parseCanonicalStatement(line, text, span) {
     }
     return { items: [], diagnostics: [parseError(line, `unsupported source line: ${text}`)] };
 }
+function parseColonDeclarationError(name, statementText) {
+    if (/^\.equ\b/.test(statementText)) {
+        return `Use "${name} .equ ..." for constants; colon labels mark addresses.`;
+    }
+    if (/^\.enum\b/.test(statementText)) {
+        return `Use "${name} .enum ..." for enums; colon labels mark addresses.`;
+    }
+    if (/^\.typealias\b/.test(statementText)) {
+        return `Use "${name} .typealias ..." for type aliases; colon labels mark addresses.`;
+    }
+    if (/^\.type\b/.test(statementText)) {
+        return `Use "${name} .type" for layouts; colon labels mark addresses.`;
+    }
+    if (/^\.union\b/.test(statementText)) {
+        return `Use "${name} .union" for layouts; colon labels mark addresses.`;
+    }
+    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;
@@ -342,7 +369,7 @@ function parseDataValue(text) {
 function parseWholeQuotedString(text) {
     const input = text.trim();
     const quote = input[0];
-    if ((quote !== '"' && quote !== "'") || input[input.length - 1] !== quote) {
+    if (quote !== '"' || input[input.length - 1] !== quote) {
         return undefined;
     }
     let value = '';
@@ -363,6 +390,22 @@ function parseWholeQuotedString(text) {
     }
     return value;
 }
+function parseEquQuotePolicyError(text) {
+    if (!text.startsWith('"') || !text.endsWith('"')) {
+        return undefined;
+    }
+    const stringValue = parseWholeQuotedString(text);
+    return stringValue !== undefined && stringValue.length === 1
+        ? 'double-quoted values are strings; use single quotes for character literals'
+        : undefined;
+}
+function parseDataQuotePolicyError(text) {
+    const input = text.trim();
+    if (!input.startsWith("'") || !input.endsWith("'")) {
+        return undefined;
+    }
+    return 'single quotes are for one character literal; use double quotes for strings';
+}
 function normalizeEntryLabelName(raw) {
     return raw.startsWith('@') ? raw.slice(1) : raw;
 }

package/dist/src/tooling/case-style.js

@@ -68,6 +68,9 @@ function isPotentialOpInvocationLine(text) {
         return false;
     if (/^[A-Za-z_][A-Za-z0-9_]*\s+\.?equ\b/i.test(text))
         return false;
+    if (/^[A-Za-z_][A-Za-z0-9_]*\s+\.(?:enum|type|union|typealias|field|byte|word|addr)\b/.test(text)) {
+        return false;
+    }
     if (/^(?:op|end|enum|type|union|field|byte|word|addr)\b/i.test(text))
         return false;
     if (/^(?:org|equ|db|dw|ds|align|include|binfrom|binto|cstr|pstr|istr)\b/i.test(text)) {