@glimmer/runtime/dist/modules/es5/lib/opcodes.js

Minimal runtime needed to render Glimmer templates

import { valueForRef } from '@glimmer/reference';
import { assert, fillNulls, LOCAL_LOGGER } from '@glimmer/util';
import { $fp, $pc, $ra, $sp } from '@glimmer/vm';
import { isScopeReference } from './scope';
import { DESTROYABLE_STACK, INNER_VM, STACKS } from './symbols';
import { CURSOR_STACK } from './vm/element-builder';
export var AppendOpcodes = /*#__PURE__*/function () {
  function AppendOpcodes() {
    this.evaluateOpcode = fillNulls(104
    /* Size */
    ).slice();
  }

  var _proto = AppendOpcodes.prototype;

  _proto.add = function add(name, evaluate, kind) {
    if (kind === void 0) {
      kind = 'syscall';
    }

    this.evaluateOpcode[name] = {
      syscall: kind !== 'machine',
      evaluate: evaluate
    };
  };

  _proto.debugBefore = function debugBefore(vm, opcode) {
    var params = undefined;
    var opName = undefined;

    if (false
    /* LOCAL_SHOULD_LOG */
    ) {
        var pos = vm[INNER_VM].fetchRegister($pc) - opcode.size;
        var _ref = [];
        opName = _ref[0];
        params = _ref[1];
        // console.log(`${typePos(vm['pc'])}.`);
        LOCAL_LOGGER.log(pos + ". ");
        var debugParams = [];

        for (var prop in params) {
          debugParams.push(prop, '=', params[prop]);
        }

        LOCAL_LOGGER.log.apply(LOCAL_LOGGER, debugParams);
      }

    var sp;

    if (false
    /* LOCAL_DEBUG */
    ) {
        sp = vm.fetchValue($sp);
      }

    return {
      sp: sp,
      pc: vm.fetchValue($pc),
      name: opName,
      params: params,
      type: opcode.type,
      isMachine: opcode.isMachine,
      size: opcode.size,
      state: undefined
    };
  };

  _proto.debugAfter = function debugAfter(vm, pre) {
    var sp = pre.sp,
        type = pre.type,
        isMachine = pre.isMachine,
        pc = pre.pc;

    if (false
    /* LOCAL_DEBUG */
    ) {
        var meta = type;
        var actualChange = vm.fetchValue($sp) - sp;

        if (meta && meta.check && typeof meta.stackChange === 'number' && meta.stackChange !== actualChange) {
          throw new Error("Error in " + pre.name + ":\n\n" + pc + ". " + "\n\nStack changed by " + actualChange + ", expected " + meta.stackChange);
        }

        if (false
        /* LOCAL_SHOULD_LOG */
        ) {
            LOCAL_LOGGER.log('%c -> pc: %d, ra: %d, fp: %d, sp: %d, s0: %O, s1: %O, t0: %O, t1: %O, v0: %O', 'color: orange', vm[INNER_VM].registers[$pc], vm[INNER_VM].registers[$ra], vm[INNER_VM].registers[$fp], vm[INNER_VM].registers[$sp], vm['s0'], vm['s1'], vm['t0'], vm['t1'], vm['v0']);
            LOCAL_LOGGER.log('%c -> eval stack', 'color: red', vm.stack.toArray());
            LOCAL_LOGGER.log('%c -> block stack', 'color: magenta', vm.elements().debugBlocks());
            LOCAL_LOGGER.log('%c -> destructor stack', 'color: violet', vm[DESTROYABLE_STACK].toArray());

            if (vm[STACKS].scope.current === null) {
              LOCAL_LOGGER.log('%c -> scope', 'color: green', 'null');
            } else {
              LOCAL_LOGGER.log('%c -> scope', 'color: green', vm.scope().slots.map(function (s) {
                return isScopeReference(s) ? valueForRef(s) : s;
              }));
            }

            LOCAL_LOGGER.log('%c -> elements', 'color: blue', vm.elements()[CURSOR_STACK].current.element);
            LOCAL_LOGGER.log('%c -> constructing', 'color: aqua', vm.elements()['constructing']);
          }
      }
  };

  _proto.evaluate = function evaluate(vm, opcode, type) {
    var operation = this.evaluateOpcode[type];

    if (operation.syscall) {
      false && assert(!opcode.isMachine, "BUG: Mismatch between operation.syscall (" + operation.syscall + ") and opcode.isMachine (" + opcode.isMachine + ") for " + opcode.type);
      operation.evaluate(vm, opcode);
    } else {
      false && assert(opcode.isMachine, "BUG: Mismatch between operation.syscall (" + operation.syscall + ") and opcode.isMachine (" + opcode.isMachine + ") for " + opcode.type);
      operation.evaluate(vm[INNER_VM], opcode);
    }
  };

  return AppendOpcodes;
}();
export var APPEND_OPCODES = new AppendOpcodes();
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../packages/@glimmer/runtime/lib/opcodes.ts"],"names":[],"mappings":"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","sourcesContent":["import { debug, logOpcode, opcodeMetadata, recordStackSize } from '@glimmer/debug';\nimport { Dict, Maybe, Op, Option, RuntimeOp } from '@glimmer/interfaces';\nimport { LOCAL_DEBUG, LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';\nimport { valueForRef } from '@glimmer/reference';\nimport { assert, fillNulls, LOCAL_LOGGER } from '@glimmer/util';\nimport { $fp, $pc, $ra, $sp } from '@glimmer/vm';\nimport { isScopeReference } from './scope';\nimport { CONSTANTS, DESTROYABLE_STACK, INNER_VM, STACKS } from './symbols';\nimport { LowLevelVM, VM } from './vm';\nimport { InternalVM } from './vm/append';\nimport { CURSOR_STACK } from './vm/element-builder';\n\nexport interface OpcodeJSON {\n  type: number | string;\n  guid?: Option<number>;\n  deopted?: boolean;\n  args?: string[];\n  details?: Dict<Option<string>>;\n  children?: OpcodeJSON[];\n}\n\nexport type Operand1 = number;\nexport type Operand2 = number;\nexport type Operand3 = number;\n\nexport type Syscall = (vm: InternalVM, opcode: RuntimeOp) => void;\nexport type MachineOpcode = (vm: LowLevelVM, opcode: RuntimeOp) => void;\n\nexport type Evaluate =\n  | { syscall: true; evaluate: Syscall }\n  | { syscall: false; evaluate: MachineOpcode };\n\nexport type DebugState = {\n  pc: number;\n  sp: number;\n  type: number;\n  isMachine: 0 | 1;\n  size: number;\n  params?: Maybe<Dict>;\n  name?: string;\n  state: unknown;\n};\n\nexport class AppendOpcodes {\n  private evaluateOpcode: Evaluate[] = fillNulls<Evaluate>(Op.Size).slice();\n\n  add<Name extends Op>(name: Name, evaluate: Syscall): void;\n  add<Name extends Op>(name: Name, evaluate: MachineOpcode, kind: 'machine'): void;\n  add<Name extends Op>(name: Name, evaluate: Syscall | MachineOpcode, kind = 'syscall'): void {\n    this.evaluateOpcode[name as number] = {\n      syscall: kind !== 'machine',\n      evaluate,\n    } as Evaluate;\n  }\n\n  debugBefore(vm: VM, opcode: RuntimeOp): DebugState {\n    let params: Maybe<Dict> = undefined;\n    let opName: string | undefined = undefined;\n\n    if (LOCAL_SHOULD_LOG) {\n      let pos = vm[INNER_VM].fetchRegister($pc) - opcode.size;\n\n      [opName, params] = debug(vm[CONSTANTS], opcode, opcode.isMachine)!;\n\n      // console.log(`${typePos(vm['pc'])}.`);\n      LOCAL_LOGGER.log(`${pos}. ${logOpcode(opName, params)}`);\n\n      let debugParams = [];\n      for (let prop in params) {\n        debugParams.push(prop, '=', params[prop]);\n      }\n\n      LOCAL_LOGGER.log(...debugParams);\n    }\n\n    let sp: number;\n\n    if (LOCAL_DEBUG) {\n      sp = vm.fetchValue($sp);\n    }\n\n    recordStackSize(vm.fetchValue($sp));\n    return {\n      sp: sp!,\n      pc: vm.fetchValue($pc),\n      name: opName,\n      params,\n      type: opcode.type,\n      isMachine: opcode.isMachine,\n      size: opcode.size,\n      state: undefined,\n    };\n  }\n\n  debugAfter(vm: VM, pre: DebugState) {\n    let { sp, type, isMachine, pc } = pre;\n\n    if (LOCAL_DEBUG) {\n      let meta = opcodeMetadata(type, isMachine);\n      let actualChange = vm.fetchValue($sp) - sp!;\n      if (\n        meta &&\n        meta.check &&\n        typeof meta.stackChange! === 'number' &&\n        meta.stackChange! !== actualChange\n      ) {\n        throw new Error(\n          `Error in ${pre.name}:\\n\\n${pc}. ${logOpcode(\n            pre.name!,\n            pre.params!\n          )}\\n\\nStack changed by ${actualChange}, expected ${meta.stackChange!}`\n        );\n      }\n\n      if (LOCAL_SHOULD_LOG) {\n        LOCAL_LOGGER.log(\n          '%c -> pc: %d, ra: %d, fp: %d, sp: %d, s0: %O, s1: %O, t0: %O, t1: %O, v0: %O',\n          'color: orange',\n          vm[INNER_VM].registers[$pc],\n          vm[INNER_VM].registers[$ra],\n          vm[INNER_VM].registers[$fp],\n          vm[INNER_VM].registers[$sp],\n          vm['s0'],\n          vm['s1'],\n          vm['t0'],\n          vm['t1'],\n          vm['v0']\n        );\n        LOCAL_LOGGER.log('%c -> eval stack', 'color: red', vm.stack.toArray());\n        LOCAL_LOGGER.log('%c -> block stack', 'color: magenta', vm.elements().debugBlocks());\n        LOCAL_LOGGER.log(\n          '%c -> destructor stack',\n          'color: violet',\n          vm[DESTROYABLE_STACK].toArray()\n        );\n        if (vm[STACKS].scope.current === null) {\n          LOCAL_LOGGER.log('%c -> scope', 'color: green', 'null');\n        } else {\n          LOCAL_LOGGER.log(\n            '%c -> scope',\n            'color: green',\n            vm.scope().slots.map((s) => (isScopeReference(s) ? valueForRef(s) : s))\n          );\n        }\n\n        LOCAL_LOGGER.log(\n          '%c -> elements',\n          'color: blue',\n          vm.elements()[CURSOR_STACK].current!.element\n        );\n\n        LOCAL_LOGGER.log('%c -> constructing', 'color: aqua', vm.elements()['constructing']);\n      }\n    }\n  }\n\n  evaluate(vm: VM, opcode: RuntimeOp, type: number) {\n    let operation = this.evaluateOpcode[type];\n\n    if (operation.syscall) {\n      assert(\n        !opcode.isMachine,\n        `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`\n      );\n      operation.evaluate(vm, opcode);\n    } else {\n      assert(\n        opcode.isMachine,\n        `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`\n      );\n      operation.evaluate(vm[INNER_VM], opcode);\n    }\n  }\n}\n\nexport const APPEND_OPCODES = new AppendOpcodes();\n"],"sourceRoot":""}