@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/assembly/address-planning.js

@@ -1,6 +1,29 @@
 import { diagnostic, evaluateExpression, lookupEquateRecord, validateLayouts, } from '../semantics/expression-evaluation.js';
 import { instructionSize } from './fixup-emission.js';
 import { advanceCodePlacement, advancePlacement, applyOrg, createPlacementState, placementAddress, placementForOrg, } from './placement.js';
+export { resolveSymbols } from './address-symbols.js';
+import { defineEnumMembers, defineEquate, defineLabel, defineLayout, defineTypeAlias, } from './address-symbols.js';
+const ADDRESS_ITEM_HANDLERS = {
+    org: (context, item, items, itemIndex) => applyAddressOrg(context, items, itemIndex, item),
+    type: (context, item) => defineAddressLayout(context, item),
+    'type-alias': (context, item) => defineAddressTypeAlias(context, item),
+    equ: (context, item) => defineAddressEquate(context, item),
+    enum: (context, item) => defineAddressEnum(context, item),
+    comment: () => undefined,
+    label: (context, item) => defineAddressLabel(context, item),
+    db: (context, item) => advancePlacement(context.placement, dbSize(item, context.lookupEquates)),
+    dw: (context, item) => advancePlacement(context.placement, item.values.length * 2),
+    ds: (context, item) => advanceStorage(context, item),
+    align: (context, item) => advanceAlignment(context, item),
+    end: () => true,
+    binfrom: () => undefined,
+    binto: () => undefined,
+    'string-data': (context, item) => {
+        const stringItem = item;
+        advancePlacement(context.placement, stringDirectiveBytes(stringItem.directive, stringItem.value).length);
+    },
+    instruction: (context, item) => advanceInstruction(context, item),
+};
 export function buildAddressState(items, diagnostics) {
     let state = buildAddressStateOnce(items, [], undefined, false);
     let previousSignature = '';
@@ -15,115 +38,110 @@ export function buildAddressState(items, diagnostics) {
     return buildAddressStateOnce(items, diagnostics, state, true);
 }
 function buildAddressStateOnce(items, diagnostics, previous, reportUnknown) {
-    const labels = {};
-    const equates = new Map();
-    const layouts = new Map();
-    const enumNames = new Set();
-    const enumNamesLower = new Set();
-    let origin = 0;
-    let originSet = false;
-    const placement = createPlacementState();
+    const context = createAddressBuildContext(previous, diagnostics, reportUnknown);
     let ended = false;
-    const lookupLabels = previous?.labels ?? labels;
-    const lookupEquates = previous?.equates ?? equates;
-    const lookupLayouts = previous?.layouts ?? layouts;
     for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
         const item = items[itemIndex];
-        if (ended && item.kind !== 'binfrom' && item.kind !== 'binto') {
+        if (shouldSkipAfterEnd(ended, item)) {
             continue;
         }
-        switch (item.kind) {
-            case 'org': {
-                placement.activePlacement = placementForOrg(items, itemIndex);
-                const value = evaluateExpression(item.expression, lookupLabels, lookupEquates, item.span, diagnostics, {
-                    currentLocation: placementAddress(placement),
-                    layouts: lookupLayouts,
-                    reportUnknown,
-                });
-                if (value !== undefined) {
-                    if (!originSet) {
-                        origin = value;
-                        originSet = true;
-                    }
-                    applyOrg(placement, value);
-                }
-                break;
-            }
-            case 'type':
-                defineLayout(layouts, labels, equates, enumNamesLower, item.name, item.layoutKind, item.fields, item.span, diagnostics);
-                break;
-            case 'type-alias':
-                defineTypeAlias(layouts, labels, equates, enumNamesLower, item.name, item.typeExpr, item.span, diagnostics);
-                break;
-            case 'equ':
-                defineEquate(equates, labels, layouts, enumNames, enumNamesLower, item.name, item.expression, item.span, placementAddress(placement), diagnostics, item.stringValue);
-                break;
-            case 'enum':
-                defineEnumMembers(equates, labels, layouts, enumNames, enumNamesLower, item.name, item.members, item.span, diagnostics);
-                break;
-            case 'comment':
-                break;
-            case 'label':
-                defineLabel(labels, equates, layouts, enumNamesLower, item.name, placementAddress(placement), item.span, diagnostics);
-                break;
-            case 'db':
-                advancePlacement(placement, item.values.reduce((size, value) => size + dataValueSize(value, lookupEquates), 0));
-                break;
-            case 'dw':
-                advancePlacement(placement, item.values.length * 2);
-                break;
-            case 'ds': {
-                const size = evaluateExpression(item.size, lookupLabels, lookupEquates, item.span, diagnostics, {
-                    currentLocation: placementAddress(placement),
-                    layouts: lookupLayouts,
-                    reportUnknown,
-                });
-                if (size !== undefined) {
-                    advancePlacement(placement, size);
-                }
-                break;
-            }
-            case 'align': {
-                const alignment = evaluateExpression(item.alignment, lookupLabels, lookupEquates, item.span, diagnostics, {
-                    currentLocation: placementAddress(placement),
-                    layouts: lookupLayouts,
-                    reportUnknown,
-                });
-                if (alignment !== undefined) {
-                    if (alignment <= 0) {
-                        if (reportUnknown) {
-                            diagnostics.push(diagnostic(item.span, `.align value must be positive: ${alignment}.`));
-                        }
-                    }
-                    else {
-                        advancePlacement(placement, alignmentPadding(placementAddress(placement), alignment));
-                    }
-                }
-                break;
-            }
-            case 'end':
-                ended = true;
-                break;
-            case 'binfrom':
-            case 'binto':
-                break;
-            case 'string-data':
-                advancePlacement(placement, stringDirectiveBytes(item.directive, item.value).length);
-                break;
-            case 'instruction': {
-                const instructionBytes = instructionSize(item.instruction);
-                advanceCodePlacement(placement, instructionBytes);
-                if (placement.activePlacement === 'data') {
-                    advancePlacement(placement, instructionBytes);
-                }
-                break;
-            }
+        ended = ADDRESS_ITEM_HANDLERS[item.kind](context, item, items, itemIndex) === true || ended;
+    }
+    if (context.reportUnknown) {
+        validateLayouts(context.layouts, diagnostics);
+    }
+    return {
+        labels: context.labels,
+        equates: context.equates,
+        layouts: context.layouts,
+        origin: context.origin,
+    };
+}
+function shouldSkipAfterEnd(ended, item) {
+    return ended && item.kind !== 'binfrom' && item.kind !== 'binto';
+}
+function createAddressBuildContext(previous, diagnostics, reportUnknown) {
+    const labels = {};
+    const equates = new Map();
+    const layouts = new Map();
+    return {
+        labels,
+        equates,
+        layouts,
+        enumNames: new Set(),
+        enumNamesLower: new Set(),
+        diagnostics,
+        lookupLabels: previous?.labels ?? labels,
+        lookupEquates: previous?.equates ?? equates,
+        lookupLayouts: previous?.layouts ?? layouts,
+        reportUnknown,
+        placement: createPlacementState(),
+        origin: 0,
+        originSet: false,
+    };
+}
+function applyAddressOrg(context, items, itemIndex, item) {
+    context.placement.activePlacement = placementForOrg(items, itemIndex);
+    const value = evaluateAddressExpression(context, item.expression, item.span);
+    if (value === undefined) {
+        return;
+    }
+    if (!context.originSet) {
+        context.origin = value;
+        context.originSet = true;
+    }
+    applyOrg(context.placement, value);
+}
+function defineAddressLayout(context, item) {
+    defineLayout(context.layouts, context.labels, context.equates, context.enumNamesLower, item.name, item.layoutKind, item.fields, item.span, context.diagnostics);
+}
+function defineAddressTypeAlias(context, item) {
+    defineTypeAlias(context.layouts, context.labels, context.equates, context.enumNamesLower, item.name, item.typeExpr, item.span, context.diagnostics);
+}
+function defineAddressEquate(context, item) {
+    defineEquate(context.equates, context.labels, context.layouts, context.enumNames, context.enumNamesLower, item.name, item.expression, item.span, placementAddress(context.placement), context.diagnostics, item.stringValue);
+}
+function defineAddressEnum(context, item) {
+    defineEnumMembers(context.equates, context.labels, context.layouts, context.enumNames, context.enumNamesLower, item.name, item.members, item.span, context.diagnostics);
+}
+function defineAddressLabel(context, item) {
+    defineLabel(context.labels, context.equates, context.layouts, context.enumNamesLower, item.name, placementAddress(context.placement), item.span, context.diagnostics);
+}
+function advanceStorage(context, item) {
+    const size = evaluateAddressExpression(context, item.size, item.span);
+    if (size !== undefined) {
+        advancePlacement(context.placement, size);
+    }
+}
+function advanceAlignment(context, item) {
+    const alignment = evaluateAddressExpression(context, item.alignment, item.span);
+    if (alignment === undefined) {
+        return;
+    }
+    if (alignment <= 0) {
+        if (context.reportUnknown) {
+            context.diagnostics.push(diagnostic(item.span, `.align value must be positive: ${alignment}.`));
         }
+        return;
     }
-    if (reportUnknown) {
-        validateLayouts(layouts, diagnostics);
+    advancePlacement(context.placement, alignmentPadding(placementAddress(context.placement), alignment));
+}
+function advanceInstruction(context, item) {
+    const instructionBytes = instructionSize(item.instruction);
+    advanceCodePlacement(context.placement, instructionBytes);
+    if (context.placement.activePlacement === 'data') {
+        advancePlacement(context.placement, instructionBytes);
     }
-    return { labels, equates, layouts, origin };
+}
+function evaluateAddressExpression(context, expression, span) {
+    return evaluateExpression(expression, context.lookupLabels, context.lookupEquates, span, context.diagnostics, {
+        currentLocation: placementAddress(context.placement),
+        layouts: context.lookupLayouts,
+        reportUnknown: context.reportUnknown,
+    });
+}
+function dbSize(item, lookupEquates) {
+    return item.values.reduce((size, value) => size + dataValueSize(value, lookupEquates), 0);
 }
 export function stringDirectiveBytes(directive, value) {
     const bytes = [...value].map((char) => char.codePointAt(0) ?? 0);
@@ -167,120 +185,3 @@ function addressStateSignature(state) {
         origin: state.origin,
     });
 }
-function defineLayout(layouts, labels, equates, enumNamesLower, name, layoutKind, fields, span, diagnostics) {
-    const lowerName = name.toLowerCase();
-    if (hasCaseInsensitiveMapKey(layouts, lowerName) ||
-        hasCaseInsensitiveKey(labels, lowerName) ||
-        hasCaseInsensitiveMapKey(equates, lowerName) ||
-        enumNamesLower.has(lowerName)) {
-        diagnostics.push(diagnostic(span, `duplicate type name: ${name}`));
-        return;
-    }
-    const fieldNames = new Set();
-    for (const field of fields) {
-        const fieldLower = field.name.toLowerCase();
-        if (fieldNames.has(fieldLower)) {
-            diagnostics.push(diagnostic(span, `duplicate type field name: ${field.name}`));
-            continue;
-        }
-        fieldNames.add(fieldLower);
-    }
-    layouts.set(name, { kind: layoutKind, fields, span });
-}
-function defineTypeAlias(layouts, labels, equates, enumNamesLower, name, typeExpr, span, diagnostics) {
-    const lowerName = name.toLowerCase();
-    if (hasCaseInsensitiveMapKey(layouts, lowerName) ||
-        hasCaseInsensitiveKey(labels, lowerName) ||
-        hasCaseInsensitiveMapKey(equates, lowerName) ||
-        enumNamesLower.has(lowerName)) {
-        diagnostics.push(diagnostic(span, `duplicate type name: ${name}`));
-        return;
-    }
-    layouts.set(name, { kind: 'alias', typeExpr, span });
-}
-function defineLabel(labels, equates, layouts, enumNamesLower, name, address, span, diagnostics) {
-    if (labels[name] !== undefined ||
-        equates.has(name) ||
-        hasCaseInsensitiveMapKey(layouts, name.toLowerCase()) ||
-        enumNamesLower.has(name.toLowerCase())) {
-        diagnostics.push(diagnostic(span, `duplicate symbol: ${name}`));
-        return;
-    }
-    labels[name] = address;
-}
-function defineEquate(equates, labels, layouts, enumNames, enumNamesLower, name, expression, span, currentLocation, diagnostics, stringValue) {
-    if (labels[name] !== undefined ||
-        equates.has(name) ||
-        hasCaseInsensitiveMapKey(layouts, name.toLowerCase()) ||
-        enumNames.has(name) ||
-        enumNamesLower.has(name.toLowerCase())) {
-        diagnostics.push(diagnostic(span, `duplicate symbol: ${name}`));
-        return;
-    }
-    equates.set(name, {
-        expression,
-        span,
-        currentLocation,
-        ...(stringValue !== undefined ? { stringValue } : {}),
-    });
-}
-function defineEnumMembers(equates, labels, layouts, enumNames, enumNamesLower, enumName, members, span, diagnostics) {
-    const enumNameLower = enumName.toLowerCase();
-    if (hasCaseInsensitiveKey(labels, enumNameLower) ||
-        hasCaseInsensitiveMapKey(equates, enumNameLower) ||
-        hasCaseInsensitiveMapKey(layouts, enumNameLower) ||
-        enumNamesLower.has(enumNameLower)) {
-        diagnostics.push(diagnostic(span, `duplicate enum name: ${enumName}`));
-        return;
-    }
-    enumNames.add(enumName);
-    enumNamesLower.add(enumNameLower);
-    const memberNames = new Set();
-    for (let index = 0; index < members.length; index += 1) {
-        const member = members[index] ?? '';
-        const memberLower = member.toLowerCase();
-        if (memberNames.has(memberLower)) {
-            diagnostics.push(diagnostic(span, `duplicate enum member name: ${member}`));
-            continue;
-        }
-        memberNames.add(memberLower);
-        const qualifiedName = `${enumName}.${member}`;
-        if (hasCaseInsensitiveKey(labels, qualifiedName.toLowerCase()) ||
-            hasCaseInsensitiveMapKey(equates, qualifiedName.toLowerCase())) {
-            diagnostics.push(diagnostic(span, `duplicate symbol: ${qualifiedName}`));
-            continue;
-        }
-        equates.set(qualifiedName, {
-            expression: { kind: 'number', value: index },
-            span,
-            currentLocation: 0,
-            enumMember: true,
-        });
-    }
-}
-function hasCaseInsensitiveKey(record, lowerName) {
-    return Object.keys(record).some((key) => key.toLowerCase() === lowerName);
-}
-function hasCaseInsensitiveMapKey(map, lowerName) {
-    for (const key of map.keys()) {
-        if (key.toLowerCase() === lowerName) {
-            return true;
-        }
-    }
-    return false;
-}
-export function resolveSymbols(labels, equates, layouts, diagnostics) {
-    const symbols = { ...labels };
-    for (const [name, record] of equates) {
-        const value = evaluateExpression(record.expression, labels, equates, record.span, diagnostics, {
-            currentLocation: record.currentLocation,
-            visiting: new Set([name]),
-            layouts,
-            reportUnknown: false,
-        });
-        if (value !== undefined) {
-            symbols[name] = value;
-        }
-    }
-    return symbols;
-}

package/dist/src/assembly/address-symbols.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { Expression, TypeExpr } from '../model/expression.js';
+import type { LayoutField } from '../model/source-item.js';
+import type { SymbolTable } from '../model/symbol.js';
+import type { SourceSpan } from '../source/source-span.js';
+import { type EquateRecord, type LayoutRecord } from '../semantics/expression-evaluation.js';
+export declare function defineLayout(layouts: Map<string, LayoutRecord>, labels: Readonly<Record<string, number>>, equates: ReadonlyMap<string, EquateRecord>, enumNamesLower: ReadonlySet<string>, name: string, layoutKind: 'record' | 'union', fields: readonly LayoutField[], span: SourceSpan, diagnostics: Diagnostic[]): void;
+export declare function defineTypeAlias(layouts: Map<string, LayoutRecord>, labels: Readonly<Record<string, number>>, equates: ReadonlyMap<string, EquateRecord>, enumNamesLower: ReadonlySet<string>, name: string, typeExpr: TypeExpr, span: SourceSpan, diagnostics: Diagnostic[]): void;
+export declare function defineLabel(labels: Record<string, number>, equates: ReadonlyMap<string, EquateRecord>, layouts: ReadonlyMap<string, LayoutRecord>, enumNamesLower: ReadonlySet<string>, name: string, address: number, span: SourceSpan, diagnostics: Diagnostic[]): void;
+export declare function defineEquate(equates: Map<string, EquateRecord>, labels: Readonly<Record<string, number>>, layouts: ReadonlyMap<string, LayoutRecord>, enumNames: ReadonlySet<string>, enumNamesLower: ReadonlySet<string>, name: string, expression: Expression, span: SourceSpan, currentLocation: number, diagnostics: Diagnostic[], stringValue?: string): void;
+export declare function defineEnumMembers(equates: Map<string, EquateRecord>, labels: Readonly<Record<string, number>>, layouts: ReadonlyMap<string, LayoutRecord>, enumNames: Set<string>, enumNamesLower: Set<string>, enumName: string, members: readonly string[], span: SourceSpan, diagnostics: Diagnostic[]): void;
+export declare function resolveSymbols(labels: Readonly<Record<string, number>>, equates: ReadonlyMap<string, EquateRecord>, layouts: ReadonlyMap<string, LayoutRecord>, diagnostics: Diagnostic[]): SymbolTable;

package/dist/src/assembly/address-symbols.js

@@ -0,0 +1,118 @@
+import { diagnostic, evaluateExpression, } from '../semantics/expression-evaluation.js';
+export function defineLayout(layouts, labels, equates, enumNamesLower, name, layoutKind, fields, span, diagnostics) {
+    const lowerName = name.toLowerCase();
+    if (hasCaseInsensitiveMapKey(layouts, lowerName) ||
+        hasCaseInsensitiveKey(labels, lowerName) ||
+        hasCaseInsensitiveMapKey(equates, lowerName) ||
+        enumNamesLower.has(lowerName)) {
+        diagnostics.push(diagnostic(span, `duplicate type name: ${name}`));
+        return;
+    }
+    const fieldNames = new Set();
+    for (const field of fields) {
+        const fieldLower = field.name.toLowerCase();
+        if (fieldNames.has(fieldLower)) {
+            diagnostics.push(diagnostic(span, `duplicate type field name: ${field.name}`));
+            continue;
+        }
+        fieldNames.add(fieldLower);
+    }
+    layouts.set(name, { kind: layoutKind, fields, span });
+}
+export function defineTypeAlias(layouts, labels, equates, enumNamesLower, name, typeExpr, span, diagnostics) {
+    const lowerName = name.toLowerCase();
+    if (hasCaseInsensitiveMapKey(layouts, lowerName) ||
+        hasCaseInsensitiveKey(labels, lowerName) ||
+        hasCaseInsensitiveMapKey(equates, lowerName) ||
+        enumNamesLower.has(lowerName)) {
+        diagnostics.push(diagnostic(span, `duplicate type name: ${name}`));
+        return;
+    }
+    layouts.set(name, { kind: 'alias', typeExpr, span });
+}
+export function defineLabel(labels, equates, layouts, enumNamesLower, name, address, span, diagnostics) {
+    if (labels[name] !== undefined ||
+        equates.has(name) ||
+        hasCaseInsensitiveMapKey(layouts, name.toLowerCase()) ||
+        enumNamesLower.has(name.toLowerCase())) {
+        diagnostics.push(diagnostic(span, `duplicate symbol: ${name}`));
+        return;
+    }
+    labels[name] = address;
+}
+export function defineEquate(equates, labels, layouts, enumNames, enumNamesLower, name, expression, span, currentLocation, diagnostics, stringValue) {
+    if (labels[name] !== undefined ||
+        equates.has(name) ||
+        hasCaseInsensitiveMapKey(layouts, name.toLowerCase()) ||
+        enumNames.has(name) ||
+        enumNamesLower.has(name.toLowerCase())) {
+        diagnostics.push(diagnostic(span, `duplicate symbol: ${name}`));
+        return;
+    }
+    equates.set(name, {
+        expression,
+        span,
+        currentLocation,
+        ...(stringValue !== undefined ? { stringValue } : {}),
+    });
+}
+export function defineEnumMembers(equates, labels, layouts, enumNames, enumNamesLower, enumName, members, span, diagnostics) {
+    const enumNameLower = enumName.toLowerCase();
+    if (hasCaseInsensitiveKey(labels, enumNameLower) ||
+        hasCaseInsensitiveMapKey(equates, enumNameLower) ||
+        hasCaseInsensitiveMapKey(layouts, enumNameLower) ||
+        enumNamesLower.has(enumNameLower)) {
+        diagnostics.push(diagnostic(span, `duplicate enum name: ${enumName}`));
+        return;
+    }
+    enumNames.add(enumName);
+    enumNamesLower.add(enumNameLower);
+    const memberNames = new Set();
+    for (let index = 0; index < members.length; index += 1) {
+        const member = members[index] ?? '';
+        const memberLower = member.toLowerCase();
+        if (memberNames.has(memberLower)) {
+            diagnostics.push(diagnostic(span, `duplicate enum member name: ${member}`));
+            continue;
+        }
+        memberNames.add(memberLower);
+        const qualifiedName = `${enumName}.${member}`;
+        if (hasCaseInsensitiveKey(labels, qualifiedName.toLowerCase()) ||
+            hasCaseInsensitiveMapKey(equates, qualifiedName.toLowerCase())) {
+            diagnostics.push(diagnostic(span, `duplicate symbol: ${qualifiedName}`));
+            continue;
+        }
+        equates.set(qualifiedName, {
+            expression: { kind: 'number', value: index },
+            span,
+            currentLocation: 0,
+            enumMember: true,
+        });
+    }
+}
+export function resolveSymbols(labels, equates, layouts, diagnostics) {
+    const symbols = { ...labels };
+    for (const [name, record] of equates) {
+        const value = evaluateExpression(record.expression, labels, equates, record.span, diagnostics, {
+            currentLocation: record.currentLocation,
+            visiting: new Set([name]),
+            layouts,
+            reportUnknown: false,
+        });
+        if (value !== undefined) {
+            symbols[name] = value;
+        }
+    }
+    return symbols;
+}
+function hasCaseInsensitiveKey(record, lowerName) {
+    return Object.keys(record).some((key) => key.toLowerCase() === lowerName);
+}
+function hasCaseInsensitiveMapKey(map, lowerName) {
+    for (const key of map.keys()) {
+        if (key.toLowerCase() === lowerName) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/src/assembly/fixup-emission.js

@@ -1,4 +1,5 @@
 import { diagnostic, evaluateExpression, lookupSymbolValue, } from '../semantics/expression-evaluation.js';
+import { applyBinaryOperator, applyUnaryOperator, } from '../semantics/constant-operators.js';
 import { encodeZ80Instruction } from '../z80/encode.js';
 export function emitInstruction(instruction, span, currentAddress, labels, equates, diagnostics, bytes, fixups, layouts) {
     const encoded = encodeZ80Instruction(instruction);
@@ -169,25 +170,34 @@ function fixupTargetFromExpression(expression) {
     if (expression.kind === 'symbol') {
         return { symbol: expression.name, addend: 0 };
     }
-    if (expression.kind !== 'binary') {
+    return expression.kind === 'binary' ? binaryFixupTarget(expression) : undefined;
+}
+function binaryFixupTarget(expression) {
+    if (expression.operator !== '+' && expression.operator !== '-')
         return undefined;
-    }
-    if (expression.operator === '+' || expression.operator === '-') {
-        const leftSymbol = expression.left.kind === 'symbol' ? expression.left.name : undefined;
-        const rightSymbol = expression.right.kind === 'symbol' ? expression.right.name : undefined;
-        const leftConstant = constantExpressionValue(expression.left);
-        const rightConstant = constantExpressionValue(expression.right);
-        if (leftSymbol && rightConstant !== undefined) {
-            return {
-                symbol: leftSymbol,
-                addend: expression.operator === '+' ? rightConstant : -rightConstant,
-            };
-        }
-        if (expression.operator === '+' && rightSymbol && leftConstant !== undefined) {
-            return { symbol: rightSymbol, addend: leftConstant };
-        }
-    }
-    return undefined;
+    return leftSymbolFixupTarget(expression) ?? rightSymbolFixupTarget(expression);
+}
+function expressionSymbol(expression) {
+    return expression.kind === 'symbol' ? expression.name : undefined;
+}
+function leftSymbolFixupTarget(expression) {
+    const symbol = expressionSymbol(expression.left);
+    const rightConstant = constantExpressionValue(expression.right);
+    if (!symbol || rightConstant === undefined)
+        return undefined;
+    return {
+        symbol,
+        addend: expression.operator === '+' ? rightConstant : -rightConstant,
+    };
+}
+function rightSymbolFixupTarget(expression) {
+    if (expression.operator !== '+')
+        return undefined;
+    const symbol = expressionSymbol(expression.right);
+    const leftConstant = constantExpressionValue(expression.left);
+    return symbol && leftConstant !== undefined
+        ? { symbol, addend: leftConstant }
+        : undefined;
 }
 function constantExpressionValue(expression) {
     switch (expression.kind) {
@@ -207,14 +217,7 @@ function constantUnaryExpressionValue(expression) {
     if (value === undefined) {
         return undefined;
     }
-    switch (expression.operator) {
-        case '+':
-            return value;
-        case '-':
-            return -value;
-        case '~':
-            return ~value;
-    }
+    return applyUnaryOperator(expression.operator, value);
 }
 function constantBinaryExpressionValue(expression) {
     const left = constantExpressionValue(expression.left);
@@ -222,26 +225,5 @@ function constantBinaryExpressionValue(expression) {
     if (left === undefined || right === undefined) {
         return undefined;
     }
-    switch (expression.operator) {
-        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;
-        case '<<':
-            return left << right;
-        case '>>':
-            return left >> right;
-    }
+    return applyBinaryOperator(expression.operator, left, right);
 }