Quelle mapScopes.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/>. */

import {
  getSettledSourceTextContent,
  isMapScopesEnabled,
  getSelectedFrame,
  getGeneratedFrameScope,
  getOriginalFrameScope,
  getFirstSourceActorForGeneratedSource,
} from "../../selectors/index";
import {
  loadOriginalSourceText,
  loadGeneratedSourceText,
} from "../sources/loadSourceText";
import { validateSelectedFrame } from "../../utils/context";
import { PROMISE } from "../utils/middleware/promise";

import { log } from "../../utils/log";

import { buildMappedScopes } from "../../utils/pause/mapScopes/index";
import { isFulfilled } from "../../utils/async-value";

import { getMappedLocation } from "../../utils/source-maps";

const expressionRegex = /\bfp\(\)/g;

export async function buildOriginalScopes(
  selectedFrame,
  client,
  generatedScopes
) {
  if (!selectedFrame.originalVariables) {
    throw new TypeError("(frame.originalVariables: XScopeVariables)");
  }
  const originalVariables = selectedFrame.originalVariables;
  const frameBase = originalVariables.frameBase || "";

  const inputs = [];
  for (let i = 0; i < originalVariables.vars.length; i++) {
    const { expr } = originalVariables.vars[i];
    const expression = expr
      ? expr.replace(expressionRegex, frameBase)
      : "void 0";

    inputs[i] = expression;
  }

  const results = await client.evaluateExpressions(inputs, {
    frameId: selectedFrame.id,
  });

  const variables = {};
  for (let i = 0; i < originalVariables.vars.length; i++) {
    const { name } = originalVariables.vars[i];
    variables[name] = { value: results[i].result };
  }

  const bindings = {
    arguments: [],
    variables,
  };

  const { actor } = await generatedScopes;
  const scope = {
    type: "function",
    scopeKind: "",
    actor,
    bindings,
    parent: null,
    function: null,
    block: null,
  };
  return {
    mappings: {},
    scope,
  };
}

export function toggleMapScopes() {
  return async function ({ dispatch, getState }) {
    if (isMapScopesEnabled(getState())) {
      dispatch({ type: "TOGGLE_MAP_SCOPES", mapScopes: false });
      return;
    }

    dispatch({ type: "TOGGLE_MAP_SCOPES", mapScopes: true });

    // Ignore the call if there is no selected frame (we are not paused?)
    const state = getState();
    const selectedFrame = getSelectedFrame(state);
    if (!selectedFrame) {
      return;
    }

    if (getOriginalFrameScope(getState(), selectedFrame)) {
      return;
    }

    // Also ignore the call if we didn't fetch the scopes for the selected frame
    const scopes = getGeneratedFrameScope(getState(), selectedFrame);
    if (!scopes) {
      return;
    }

    dispatch(mapScopes(selectedFrame, Promise.resolve(scopes.scope)));
  };
}

export function mapScopes(selectedFrame, scopes) {
  return async function (thunkArgs) {
    const { getState, dispatch, client } = thunkArgs;

    await dispatch({
      type: "MAP_SCOPES",
      selectedFrame,
      [PROMISE]: (async function () {
        if (selectedFrame.isOriginal && selectedFrame.originalVariables) {
          return buildOriginalScopes(selectedFrame, client, scopes);
        }

        // getMappedScopes is only specific to the sources where we map the variables
        // in scope and so only need a thread context. Assert that we are on the same thread
        // before retrieving a thread context.
        validateSelectedFrame(getState(), selectedFrame);

        return dispatch(getMappedScopes(scopes, selectedFrame));
      })(),
    });
  };
}

/**
* Get scopes mapped for a precise location.
*
* @param {Promise} scopes
*        Can be null. Result of Commands.js's client.getFrameScopes
* @param {Objects locations
*        Frame object, or custom object with 'location' and 'generatedLocation' attributes.
*/
export function getMappedScopes(scopes, locations) {
  return async function (thunkArgs) {
    const { getState, dispatch } = thunkArgs;
    const generatedSource = locations.generatedLocation.source;
    const source = locations.location.source;

    if (
      !isMapScopesEnabled(getState()) ||
      !source ||
      !generatedSource ||
      generatedSource.isWasm ||
      source.isPrettyPrinted ||
      !source.isOriginal
    ) {
      return null;
    }

    // Load source text for the original source
    await dispatch(loadOriginalSourceText(source));

    const generatedSourceActor = getFirstSourceActorForGeneratedSource(
      getState(),
      generatedSource.id
    );

    // Also load source text for its corresponding generated source
    await dispatch(loadGeneratedSourceText(generatedSourceActor));

    try {
      const content =
        // load original source text content
        getSettledSourceTextContent(getState(), locations.location);

      return await buildMappedScopes(
        source,
        content && isFulfilled(content)
          ? content.value
          : { type: "text", value: "", contentType: undefined },
        locations,
        await scopes,
        thunkArgs
      );
    } catch (e) {
      log(e);
      return null;
    }
  };
}

/**
* Used to map variables used within conditional and log breakpoints.
*/
export function getMappedScopesForLocation(location) {
  return async function (thunkArgs) {
    const { dispatch } = thunkArgs;
    const mappedLocation = await getMappedLocation(location, thunkArgs);
    return dispatch(getMappedScopes(null, mappedLocation));
  };
}

quality73%

¤ Dauer der Verarbeitung: 0.12 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.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.