Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/C/Firefox/devtools/client/shared/sourceeditor/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 4 kB

Quelle wasm.js Sprache: JAVA

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

const wasmparser = require("resource://devtools/client/shared/vendor/WasmParser.js");
const wasmdis = require("resource://devtools/client/shared/vendor/WasmDis.js");

const wasmStates = new WeakMap();

function getWasmText(subject, data) {
  if (wasmStates.has(subject)) {
    const wasmState = wasmStates.get(subject);
    return { lines: wasmState.result.lines, done: wasmState.result.done };
  }
  const parser = new wasmparser.BinaryReader();
  parser.setData(data.buffer, 0, data.length);
  const dis = new wasmdis.WasmDisassembler();
  dis.addOffsets = true;
  const done = dis.disassembleChunk(parser);
  let result = dis.getResult();
  if (result.lines.length === 0) {
    result = { lines: ["No luck with wast conversion"], offsets: [0], done };
  }
  // Cache mappings of WASM offsets to lines
  const offsets = result.offsets,
    lines = [];
  for (let line = 0; line < offsets.length; line++) {
    const offset = offsets[line];
    lines[offset] = line;
  }
  wasmStates.set(subject, { offsets, lines, result });

  return { lines: result.lines, done: result.done };
}

/**
* Creates wasm formatter function used to generate the hexadecimal number
* displayed in the line gutter
*
* @param {Object} subject - An object which decribes the source, it is comprised of the sourceId
* @returns {Function}
*/
function getWasmLineNumberFormatter(subject) {
  const codeOf0 = 48,
    codeOfA = 65;
  const buffer = [
    codeOf0,
    codeOf0,
    codeOf0,
    codeOf0,
    codeOf0,
    codeOf0,
    codeOf0,
    codeOf0,
  ];
  let last0 = 7;
  return function (line) {
    const offset = lineToWasmOffset(subject, line - 1);
    if (offset === undefined) {
      return "";
    }
    let i = 7;
    for (let n = offset | 0; n !== 0 && i >= 0; n >>= 4, i--) {
      const nibble = n & 15;
      buffer[i] = nibble < 10 ? codeOf0 + nibble : codeOfA - 10 + nibble;
    }
    for (let j = i; j > last0; j--) {
      buffer[j] = codeOf0;
    }
    last0 = i;
    return String.fromCharCode.apply(null, buffer);
  };
}

/**
* Checks if the specified source exists in the cache.
* This is used to determine if the source is a WASM source
*
* @param {Object} subject
* @returns {Boolean}
*/
function isWasm(subject) {
  return wasmStates.has(subject);
}

/**
* Converts the source (decimal) line to its WASM offset
*
* @param {Object} subject
* @param {Number} line
* @param {Boolean} findNextOffset
*        There are scenarios (e.g are empty lines) where we might want to find the next best offset match.
*        Every line will usually have offsets assigned except empty lines (which could be between functions
*        or some declarations).
* @returns {Number}
*/
function lineToWasmOffset(subject, line, findNextOffset = false) {
  const wasmState = wasmStates.get(subject);
  if (!wasmState) {
    return undefined;
  }

  let offset = wasmState.offsets[line];
  if (findNextOffset) {
    while (offset === undefined && line > 0) {
      offset = wasmState.offsets[--line];
    }
  }
  return offset;
}

/**
* Converts the WASM offset to the source line
*
* @param {Object} subject
* @param {Number} offset
* @returns {Number}
*/
function wasmOffsetToLine(subject, offset) {
  const wasmState = wasmStates.get(subject);
  return wasmState.lines[offset];
}

// A cache of the wasm source text as an array of lines.
// The lines are cached with the value object of the source content
// as the key.
const wasmLines = new WeakMap();

function renderWasmText(subject, content) {
  if (wasmLines.has(content)) {
    return wasmLines.get(content) || [];
  }

  // binary does not survive as Uint8Array, converting from string
  const { binary } = content.value;
  const data = new Uint8Array(binary.length);
  for (let i = 0; i < data.length; i++) {
    data[i] = binary.charCodeAt(i);
  }
  const { lines } = getWasmText(subject, data);
  const MAX_LINES = 1000000;
  if (lines.length > MAX_LINES) {
    lines.splice(MAX_LINES, lines.length - MAX_LINES);
    lines.push(";; .... text is truncated due to the size");
  }

  wasmLines.set(content, lines);
  return lines;
}

module.exports = {
  getWasmText,
  getWasmLineNumberFormatter,
  isWasm,
  lineToWasmOffset,
  wasmOffsetToLine,
  renderWasmText,
};

quality83%

¤ Dauer der Verarbeitung: 0.1 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.